>[snip]
> -test_expect_failure '--update-refs skips branch symrefs to current branch' '
> +test_expect_success '--update-refs skips branch symrefs to current branch' '
>  	test_when_finished "
>  		test_might_fail git rebase --abort &&
>  		git checkout primary &&

> git rebase --update-refs can fail after the normal rebase path has
> successfully updated the current branch when another local branch is a
> symbolic ref to it.
>
> One practical way to arrive at that setup is a default branch rename from
> master to main. While the migration is in progress, a user may keep
> refs/heads/main as a symbolic ref to refs/heads/master so that both names
> continue to work locally.
>
> If pull.rebase is enabled, a plain git pull can then finish the rebase of
> master and still fail while trying to update the main alias. The reported
> failure looked like this, with line breaks adjusted for the cover letter:
>
> Successfully rebased and updated refs/heads/master.
> error: update_ref failed for ref 'refs/heads/main':
> cannot lock ref 'refs/heads/main':
> is at fc2c7bd5f17abec7861ef759edcd33a1e16662a1
> but expected 531cabdfb49098d6ffa502ed4bf91d1b35edfcfa
> Updated the following refs with --update-refs:
> Failed to update the following refs with --update-refs:
>         refs/heads/main

> From: Son Luong Ngoc <sluongng@gmail.com>
> 
> rebase --update-refs queues local branch decorations by their literal
> refnames. When a branch such as refs/heads/main is a symbolic ref to
> the current branch, the normal rebase path first updates the current
> branch and the queued symref update later tries to update the same
> referent with the old value it recorded before the rebase.
> 
> Add a known-breakage test that exercises this case so that the fix can
> flip it to test_expect_success. The expected behavior is that the branch
> symref keeps pointing at the rebased current branch.

> +test_expect_failure '--update-refs skips branch symrefs to current branch' '
> +	test_when_finished "
> +		test_might_fail git rebase --abort &&
> +		git checkout primary &&
> +		test_might_fail git symbolic-ref -d refs/heads/update-refs-symref-alias &&
> +		test_might_fail git branch -D update-refs-symref update-refs-symref-base
> +	" &&
> +	git checkout -B update-refs-symref-base primary &&
> +	test_commit --no-tag update-refs-symref-base symref-base.t &&
> +	git checkout -B update-refs-symref &&
> +	test_commit --no-tag update-refs-symref-topic symref-topic.t &&
> +	git checkout update-refs-symref-base &&
> +	test_commit --no-tag update-refs-symref-newbase symref-newbase.t &&
> +	git checkout update-refs-symref &&
> +	git symbolic-ref refs/heads/update-refs-symref-alias refs/heads/update-refs-symref &&

> +
> +	git rebase --update-refs update-refs-symref-base 2>err &&
> +
> +	test_cmp_rev update-refs-symref-base update-refs-symref^ &&
> +	test_cmp_rev refs/heads/update-refs-symref refs/heads/update-refs-symref-alias &&
> +	test_write_lines refs/heads/update-refs-symref >expect &&
> +	git symbolic-ref refs/heads/update-refs-symref-alias >actual &&
> +	test_cmp expect actual
> +'
> +
>   test_expect_success '--update-refs updates refs correctly' '
>   	git checkout -B update-refs no-conflict-branch &&
>   	git branch -f base HEAD~4 &&

> From: Son Luong Ngoc <sluongng@gmail.com>
> 
> rebase --update-refs records local branch decorations before replaying
> commits. If a decoration is a symbolic branch such as refs/heads/main
> pointing at refs/heads/master, updating it later dereferences back to
> master and can fail because the normal rebase path already moved that
> branch.

> Signed-off-by: Son Luong Ngoc <sluongng@gmail.com>
> ---
>   sequencer.c                   | 63 +++++++++++++++++++++++++++++------
>   t/t3404-rebase-interactive.sh |  2 +-
>   2 files changed, 53 insertions(+), 12 deletions(-)
> 
> diff --git a/sequencer.c b/sequencer.c
> index 1ee4b2875b..4a83d1337c 100644
> --- a/sequencer.c
> +++ b/sequencer.c
> @@ -6445,15 +6445,22 @@ static int add_decorations_to_list(const struct commit *commit,
>   				   struct todo_add_branch_context *ctx)
>   {
>   	const struct name_decoration *decoration = get_name_decoration(&commit->object);
> -	const char *head_ref = refs_resolve_ref_unsafe(get_main_ref_store(the_repository),
> -						       "HEAD",
> +	struct ref_store *refs = get_main_ref_store(the_repository);
> +	const char *head_ref = refs_resolve_ref_unsafe(refs, "HEAD",
>   						       RESOLVE_REF_READING,
> -						       NULL,
> -						       NULL);
> +						       NULL, NULL);
> +	char *resolved_head_ref = refs_resolve_refdup(refs, "HEAD",
> +						       RESOLVE_REF_READING,
> +						       NULL, NULL);

> +	struct strbuf update_ref = STRBUF_INIT;
>   
>   	while (decoration) {
>   		struct todo_item *item;
>   		const char *path;
> +		const char *ref = decoration->name;
> +		const char *resolved_ref;
> +		int is_symref = 0;
> +		int flags = 0;
>   		size_t base_offset = ctx->buf->len;
>   
>   		/*
> @@ -6461,12 +6468,44 @@ static int add_decorations_to_list(const struct commit *commit,
>   		 * updated by the default rebase behavior.
>   		 * Exclude it from the list of refs to update,
>   		 * as well as any non-branch decorations.
> +		 *
> +		 * Resolve branch symrefs after checking for the current HEAD so
> +		 * that aliases do not schedule duplicate updates for their
> +		 * referents.
> +		 *
>   		 * Non-branch decorations may be present if the pretty format
>   		 * includes "%d", which would have loaded all refs
>   		 * into the global decoration table.
>   		 */
> -		if ((head_ref && !strcmp(head_ref, decoration->name)) ||
> -		    (decoration->type != DECORATION_REF_LOCAL)) {
> +		if (decoration->type != DECORATION_REF_LOCAL) {
> +			decoration = decoration->next;
> +			continue;
> +		}
> +
> +		if (head_ref && !strcmp(head_ref, ref)) {
> +			decoration = decoration->next;
> +			continue;
> +		}

> +
> +		strbuf_reset(&update_ref);
> +		resolved_ref = refs_resolve_ref_unsafe(refs, ref,
> +						       RESOLVE_REF_READING |
> +						       RESOLVE_REF_NO_RECURSE,

> +			}
> +
> +			strbuf_addstr(&update_ref, resolved_ref);
> +			ref = update_ref.buf;
> +			is_symref = 1;
> +		}
> +
> +		if ((is_symref && resolved_head_ref &&
> +		     !strcmp(resolved_head_ref, ref)) ||
> +		    string_list_has_string(&ctx->refs_to_oids, ref)) {
>   			decoration = decoration->next;
>   			continue;
>   		}
> @@ -6478,19 +6517,19 @@ static int add_decorations_to_list(const struct commit *commit,
>   		memset(item, 0, sizeof(*item));
>   
>   		/* If the branch is checked out, then leave a comment instead. */
> -		if ((path = branch_checked_out(decoration->name))) {
> +		if ((path = branch_checked_out(ref))) {
>   			item->command = TODO_COMMENT;
>   			strbuf_commented_addf(ctx->buf, comment_line_str,
>   					      "Ref %s checked out at '%s'\n",
> -					      decoration->name, path);
> +					      ref, path);
>   		} else {
>   			struct string_list_item *sti;
>   			item->command = TODO_UPDATE_REF;
> -			strbuf_addf(ctx->buf, "%s\n", decoration->name);
> +			strbuf_addf(ctx->buf, "%s\n", ref);
>   
>   			sti = string_list_insert(&ctx->refs_to_oids,
> -						 decoration->name);
> -			sti->util = init_update_ref_record(decoration->name);
> +						 ref);
> +			sti->util = init_update_ref_record(ref);
>   		}
>   
>   		item->offset_in_buf = base_offset;
> @@ -6501,6 +6540,8 @@ static int add_decorations_to_list(const struct commit *commit,
>   		decoration = decoration->next;
>   	}
>   
> +	strbuf_release(&update_ref);
> +	free(resolved_head_ref);
>   	return 0;
>   }
>   
> diff --git a/t/t3404-rebase-interactive.sh b/t/t3404-rebase-interactive.sh
> index 42ba8cc313..29447c0fc3 100755
> --- a/t/t3404-rebase-interactive.sh
> +++ b/t/t3404-rebase-interactive.sh
> @@ -1978,7 +1978,7 @@ test_expect_success '--update-refs ignores non-branch decorations' '
>   	test_cmp expect actual
>   '
>   
> -test_expect_failure '--update-refs skips branch symrefs to current branch' '
> +test_expect_success '--update-refs skips branch symrefs to current branch' '
>   	test_when_finished "
>   		test_might_fail git rebase --abort &&
>   		git checkout primary &&

> From: Son Luong Ngoc <sluongng@gmail.com>
> 
> git rebase --update-refs can fail after the normal rebase path has
> updated the current branch when another local branch is a symref to it.
> This can happen during a default-branch rename where refs/heads/main
> points at refs/heads/master while users migrate.
> 
> The sequencer queues update-ref commands from local branch decorations.
> Commit 106b6885c7 (rebase: ignore non-branch update-refs) filters out
> decorations that are not local branches, such as HEAD and tags. A branch
> symref is different: it is still a local branch decoration, but if it
> resolves to another branch then that target branch is itself present in
> the decoration list and will be updated as a concrete branch.
> 
> Skip branch decorations whose symrefs resolve to refs/heads/*, because
> those targets are already represented by concrete branch decorations.
> This prevents aliases from scheduling a second update for the same
> branch. Keep symrefs to non-branch targets on the existing path.

> Preserve the existing checked-out branch handling before applying these
> skips. Such refs still need a todo-list comment instead of an update-ref
> command, even when the checked-out ref is the branch being rebased or a
> branch symref alias. Use a copy of the resolved HEAD ref so later ref
> resolution does not overwrite it.

> diff --git a/sequencer.c b/sequencer.c
> index 1ee4b2875b..6ab8b47108 100644
> --- a/sequencer.c
> +++ b/sequencer.c
> @@ -6445,28 +6445,46 @@ static int add_decorations_to_list(const struct commit *commit,
>   				   struct todo_add_branch_context *ctx)
>   {
>   	const struct name_decoration *decoration = get_name_decoration(&commit->object);
> -	const char *head_ref = refs_resolve_ref_unsafe(get_main_ref_store(the_repository),
> -						       "HEAD",
> -						       RESOLVE_REF_READING,
> -						       NULL,
> -						       NULL);
> +	struct ref_store *refs = get_main_ref_store(the_repository);
> +	char *head_ref = refs_resolve_refdup(refs, "HEAD",
> +					     RESOLVE_REF_READING,
> +					     NULL, NULL);

>   	while (decoration) {
>   		struct todo_item *item;
>   		const char *path;
> +		const char *resolved_ref;
> +		int flags = 0;
>   		size_t base_offset = ctx->buf->len;
>   
>   		/*
> -		 * If the branch is the current HEAD, then it will be
> -		 * updated by the default rebase behavior.
> -		 * Exclude it from the list of refs to update,
> -		 * as well as any non-branch decorations.
>   		 * Non-branch decorations may be present if the pretty format
>   		 * includes "%d", which would have loaded all refs
>   		 * into the global decoration table.
>   		 */
> -		if ((head_ref && !strcmp(head_ref, decoration->name)) ||
> -		    (decoration->type != DECORATION_REF_LOCAL)) {
> +		if (decoration->type != DECORATION_REF_LOCAL) {
> +			decoration = decoration->next;
> +			continue;
> +		}

> A symref that points to another branch should always be skipped. When we
> look up which branches are checked out (see worktree.c:add_head_info()) we
> use
>
> 	refs_resolve_ref_unsafe(get_worktree_ref_store(wt),
> 				 "HEAD",
> 				 0,
> 				 &wt->head_oid, &flags);
>
> so it will never report a symref as being checked out - it always resolves
> any symrefs first.

> On 03/06/2026 11:27, Son Luong Ngoc via GitGitGadget wrote:
> > From: Son Luong Ngoc <sluongng@gmail.com>
> >
> > git rebase --update-refs can fail after the normal rebase path has
> > updated the current branch when another local branch is a symref to it.
> > This can happen during a default-branch rename where refs/heads/main
> > points at refs/heads/master while users migrate.
> >
> > The sequencer queues update-ref commands from local branch decorations.
> > Commit 106b6885c7 (rebase: ignore non-branch update-refs) filters out
> > decorations that are not local branches, such as HEAD and tags. A branch
> > symref is different: it is still a local branch decoration, but if it
> > resolves to another branch then that target branch is itself present in
> > the decoration list and will be updated as a concrete branch.
> >
> > Skip branch decorations whose symrefs resolve to refs/heads/*, because
> > those targets are already represented by concrete branch decorations.
> > This prevents aliases from scheduling a second update for the same
> > branch. Keep symrefs to non-branch targets on the existing path.
>
> Makes sense
>
> > Preserve the existing checked-out branch handling before applying these
> > skips. Such refs still need a todo-list comment instead of an update-ref
> > command, even when the checked-out ref is the branch being rebased or a
> > branch symref alias. Use a copy of the resolved HEAD ref so later ref
> > resolution does not overwrite it.
>
> I don't quite understand this. A symref that points to another branch
> should always be skipped. When we look up which branches are checked out
> (see worktree.c:add_head_info()) we use
>
> refs_resolve_ref_unsafe(get_worktree_ref_store(wt),
> "HEAD",
> 0,
> &wt->head_oid, &flags);
>
> so it will never report a symref as being checked out - it always
> resolves any symrefs first.
>
> If we have a symref pointing somewhere outside of "refs/heads" then we
> need to check whether the target is checked out, not the symref itself.
> I'm not sure how likely that is to happen in practice.
>
> > diff --git a/sequencer.c b/sequencer.c
> > index 1ee4b2875b..6ab8b47108 100644
> > --- a/sequencer.c
> > +++ b/sequencer.c
> > @@ -6445,28 +6445,46 @@ static int add_decorations_to_list(const struct commit *commit,
> > struct todo_add_branch_context *ctx)
> > {
> > const struct name_decoration *decoration = get_name_decoration(&commit->object);
> > - const char *head_ref = refs_resolve_ref_unsafe(get_main_ref_store(the_repository),
> > - "HEAD",
> > - RESOLVE_REF_READING,
> > - NULL,
> > - NULL);
> > + struct ref_store *refs = get_main_ref_store(the_repository);
> > + char *head_ref = refs_resolve_refdup(refs, "HEAD",
> > + RESOLVE_REF_READING,
> > + NULL, NULL);
>
> This part and the test look good now
> > while (decoration) {
> > struct todo_item *item;
> > const char *path;
> > + const char *resolved_ref;
> > + int flags = 0;
> > size_t base_offset = ctx->buf->len;
> >
> > /*
> > - * If the branch is the current HEAD, then it will be
> > - * updated by the default rebase behavior.
> > - * Exclude it from the list of refs to update,
> > - * as well as any non-branch decorations.
> > * Non-branch decorations may be present if the pretty format
> > * includes "%d", which would have loaded all refs
> > * into the global decoration table.
> > */
> > - if ((head_ref && !strcmp(head_ref, decoration->name)) ||
> > - (decoration->type != DECORATION_REF_LOCAL)) {
> > + if (decoration->type != DECORATION_REF_LOCAL) {
> > + decoration = decoration->next;
> > + continue;
> > + }
>
> If a decoration matches the current branch why don't we just skip it
> like we used to? (As an aside the existing code in wrong because if the
> user runs "git rebase --update-refs <upstream> <branch>" HEAD does not
> point to "<branch>" but lets not worry about that now)
>
> > + path = branch_checked_out(decoration->name);
>
> As I said above if the symref target is anther branch we should skip it
> and if the target is not a branch then we need to check if the target is
> checked out so we need to resolve the ref before calling
> branch_checked_out().
>
> Thanks
>
> Phillip

> From: Son Luong Ngoc <sluongng@gmail.com>
> 
> git rebase --update-refs can finish rewriting the current branch and
> then fail while updating a local branch that is a symbolic ref. This can
> happen during a default-branch rename where refs/heads/main points at
> refs/heads/master while users migrate.
> 
> The problem is a partially applied ref update: the main rebase has
> already succeeded when the later ref update fails.
> 
> The sequencer queues updates from local branch decorations. Commit
> 106b6885c7 (rebase: ignore non-branch update-refs) filters out
> decorations such as HEAD and tags. A branch symref is still a local
> branch decoration, but refs_update_ref() dereferences it, so an alias to
> another branch duplicates the concrete branch update.
> 
> Resolve local branch decorations before queuing them. Skip symrefs whose
> targets are under refs/heads/ so that only the concrete branch update is
> queued. Keep an owned copy of the resolved HEAD and skip the current
> branch before checked-out handling so later ref resolution cannot change
> the comparison.
> 
> This prevents a successful rebase from being followed by a failed,
> partially applied ref update while preserving each alias as a symref.

> Signed-off-by: Son Luong Ngoc <sluongng@gmail.com>
> ---
>   sequencer.c                   | 44 +++++++++++++++++++++++++----------
>   t/t3400-rebase.sh             |  2 +-
>   t/t3404-rebase-interactive.sh | 16 +++++++++++++
>   3 files changed, 49 insertions(+), 13 deletions(-)
> 
> diff --git a/sequencer.c b/sequencer.c
> index 1355a99a09..63aba60a08 100644
> --- a/sequencer.c
> +++ b/sequencer.c
> @@ -6465,32 +6465,50 @@ static int add_decorations_to_list(const struct commit *commit,
>   				   struct todo_add_branch_context *ctx)
>   {
>   	const struct name_decoration *decoration = get_name_decoration(&commit->object);
> -	const char *head_ref = refs_resolve_ref_unsafe(get_main_ref_store(the_repository),
> -						       "HEAD",
> -						       RESOLVE_REF_READING,
> -						       NULL,
> -						       NULL);
> +	struct ref_store *refs = get_main_ref_store(the_repository);
> +	char *head_ref = refs_resolve_refdup(refs, "HEAD",
> +					     RESOLVE_REF_READING,
> +					     NULL, NULL);
>   
>   	while (decoration) {
>   		struct todo_item *item;
>   		const char *path;
> +		char *resolved_ref;
> +		int flags = 0;
>   		size_t base_offset = ctx->buf->len;
>   
>   		/*
> -		 * If the branch is the current HEAD, then it will be
> -		 * updated by the default rebase behavior.
> -		 * Exclude it from the list of refs to update,
> -		 * as well as any non-branch decorations.
>   		 * Non-branch decorations may be present if the pretty format
>   		 * includes "%d", which would have loaded all refs
>   		 * into the global decoration table.
>   		 */
> -		if ((head_ref && !strcmp(head_ref, decoration->name)) ||
> -		    (decoration->type != DECORATION_REF_LOCAL)) {
> +		if (decoration->type != DECORATION_REF_LOCAL) {
> +			decoration = decoration->next;
> +			continue;
> +		}

> +		resolved_ref = refs_resolve_refdup(refs, decoration->name,
> +						      RESOLVE_REF_READING,
> +						      NULL, &flags);
> +		if (resolved_ref && (flags & REF_ISSYMREF) &&
> +		    starts_with(resolved_ref, "refs/heads/")) {
> +			free(resolved_ref);
> +			decoration = decoration->next;
> +			continue;
> +		}

> +		/*
> +		 * If the branch is the current HEAD, then it will be
> +		 * updated by the default rebase behavior.
> +		 */
> +		if (head_ref && !strcmp(head_ref, decoration->name)) {
> +			free(resolved_ref);
>   			decoration = decoration->next;
>   			continue;
>   		}

> diff --git a/t/t3400-rebase.sh b/t/t3400-rebase.sh
> index e62e07b894..1a02f6546b 100755
> --- a/t/t3400-rebase.sh
> +++ b/t/t3400-rebase.sh
> @@ -471,7 +471,7 @@ test_expect_success 'git rebase --update-ref with core.commentChar and branch on

> diff --git a/t/t3404-rebase-interactive.sh b/t/t3404-rebase-interactive.sh
> index e64816770a..11afa8be56 100755
> --- a/t/t3404-rebase-interactive.sh
> +++ b/t/t3404-rebase-interactive.sh
> @@ -1975,15 +1975,23 @@ test_expect_success '--update-refs ignores non-branch decorations' '
>   	) &&
>   	grep ^update-ref todo >actual &&
>   	test_write_lines "update-ref refs/heads/no-conflict-branch" >expect &&
> +	test_grep ! "^# Ref refs/heads/update-refs checked out" todo &&

>   	test_cmp expect actual
>   '
>   
>   test_expect_success '--update-refs updates refs correctly' '
> +	test_when_finished "
> +		test_might_fail git symbolic-ref -d refs/heads/no-conflict-branch-alias &&
> +		test_might_fail git symbolic-ref -d refs/heads/second-alias
> +	" &&
>   	git checkout -B update-refs no-conflict-branch &&
>   	git branch -f base HEAD~4 &&
>   	git branch -f first HEAD~3 &&
>   	git branch -f second HEAD~3 &&
>   	git branch -f third HEAD~1 &&
> +	git symbolic-ref refs/heads/no-conflict-branch-alias \
> +		refs/heads/no-conflict-branch &&
> +	git symbolic-ref refs/heads/second-alias refs/heads/second &&
>   	test_commit extra2 fileX &&
>   	git commit --amend --fixup=L &&
>   
> @@ -1991,8 +1999,16 @@ test_expect_success '--update-refs updates refs correctly' '
>   
>   	test_cmp_rev HEAD~3 refs/heads/first &&
>   	test_cmp_rev HEAD~3 refs/heads/second &&
> +	test_cmp_rev HEAD~3 refs/heads/second-alias &&
>   	test_cmp_rev HEAD~1 refs/heads/third &&
>   	test_cmp_rev HEAD refs/heads/no-conflict-branch &&
> +	test_cmp_rev HEAD refs/heads/no-conflict-branch-alias &&
> +	test_write_lines refs/heads/no-conflict-branch >expect &&
> +	git symbolic-ref refs/heads/no-conflict-branch-alias >actual &&
> +	test_cmp expect actual &&
> +	test_write_lines refs/heads/second >expect &&
> +	git symbolic-ref refs/heads/second-alias >actual &&
> +	test_cmp expect actual &&

> On 22/07/2026 09:15, Son Luong Ngoc via GitGitGadget wrote:
>> From: Son Luong Ngoc <sluongng@gmail.com>
>>
>> git rebase --update-refs can finish rewriting the current branch and
>> then fail while updating a local branch that is a symbolic ref. This can
>> happen during a default-branch rename where refs/heads/main points at
>> refs/heads/master while users migrate.
>>
>> The problem is a partially applied ref update: the main rebase has
>> already succeeded when the later ref update fails.
>>
>> The sequencer queues updates from local branch decorations. Commit
>> 106b6885c7 (rebase: ignore non-branch update-refs) filters out
>> decorations such as HEAD and tags. A branch symref is still a local
>> branch decoration, but refs_update_ref() dereferences it, so an alias to
>> another branch duplicates the concrete branch update.
>>
>> Resolve local branch decorations before queuing them. Skip symrefs whose
>> targets are under refs/heads/ so that only the concrete branch update is
>> queued. Keep an owned copy of the resolved HEAD and skip the current
>> branch before checked-out handling so later ref resolution cannot change
>> the comparison.
>>
>> This prevents a successful rebase from being followed by a failed,
>> partially applied ref update while preserving each alias as a symref.
> 
> Thanks for re-rolling I'm pretty sure the logic is sound now but I'm a 
> bit confused by a couple of things - see my comments below.
> 
>> Signed-off-by: Son Luong Ngoc <sluongng@gmail.com>
>> ---
>>   sequencer.c                   | 44 +++++++++++++++++++++++++----------
>>   t/t3400-rebase.sh             |  2 +-
>>   t/t3404-rebase-interactive.sh | 16 +++++++++++++
>>   3 files changed, 49 insertions(+), 13 deletions(-)
>>
>> diff --git a/sequencer.c b/sequencer.c
>> index 1355a99a09..63aba60a08 100644
>> --- a/sequencer.c
>> +++ b/sequencer.c
>> @@ -6465,32 +6465,50 @@ static int add_decorations_to_list(const 
>> struct commit *commit,
>>                      struct todo_add_branch_context *ctx)
>>   {
>>       const struct name_decoration *decoration = 
>> get_name_decoration(&commit->object);
>> -    const char *head_ref = 
>> refs_resolve_ref_unsafe(get_main_ref_store(the_repository),
>> -                               "HEAD",
>> -                               RESOLVE_REF_READING,
>> -                               NULL,
>> -                               NULL);
>> +    struct ref_store *refs = get_main_ref_store(the_repository);
>> +    char *head_ref = refs_resolve_refdup(refs, "HEAD",
>> +                         RESOLVE_REF_READING,
>> +                         NULL, NULL);
>>       while (decoration) {
>>           struct todo_item *item;
>>           const char *path;
>> +        char *resolved_ref;
>> +        int flags = 0;
>>           size_t base_offset = ctx->buf->len;
>>           /*
>> -         * If the branch is the current HEAD, then it will be
>> -         * updated by the default rebase behavior.
>> -         * Exclude it from the list of refs to update,
>> -         * as well as any non-branch decorations.
>>            * Non-branch decorations may be present if the pretty format
>>            * includes "%d", which would have loaded all refs
>>            * into the global decoration table.
>>            */
>> -        if ((head_ref && !strcmp(head_ref, decoration->name)) ||
>> -            (decoration->type != DECORATION_REF_LOCAL)) {
>> +        if (decoration->type != DECORATION_REF_LOCAL) {
>> +            decoration = decoration->next;
>> +            continue;
>> +        }
> 
> It would be nice to have a comment here explaining what we're doing. 
> Also I don't think we need to copy the refname so it would be more 
> efficient to use refs_resolve_ref_unsafe().

>> +        resolved_ref = refs_resolve_refdup(refs, decoration->name,
>> +                              RESOLVE_REF_READING,
>> +                              NULL, &flags);
>> +        if (resolved_ref && (flags & REF_ISSYMREF) &&
>> +            starts_with(resolved_ref, "refs/heads/")) {
>> +            free(resolved_ref);
>> +            decoration = decoration->next;
>> +            continue;
>> +        }
> 
> We skip any symbolic refs that point to another branch which is good.
> 
>> +        /*
>> +         * If the branch is the current HEAD, then it will be
>> +         * updated by the default rebase behavior.
>> +         */
>> +        if (head_ref && !strcmp(head_ref, decoration->name)) {
>> +            free(resolved_ref);
>>               decoration = decoration->next;
>>               continue;
>>           }
> 
> Then we check to see if the decoration matches HEAD which we used to do 
> above - I'm not clear why we have moved this check.

> 
>> +        path = branch_checked_out(decoration->name);
>> +
> 
> This belongs in the next patch I think.
> 
>> diff --git a/t/t3400-rebase.sh b/t/t3400-rebase.sh
>> index e62e07b894..1a02f6546b 100755
>> --- a/t/t3400-rebase.sh
>> +++ b/t/t3400-rebase.sh
>> @@ -471,7 +471,7 @@ test_expect_success 'git rebase --update-ref with 
>> core.commentChar and branch on
> 
> Adding an extra context line shows
> 
>      git checkout topic2>       GIT_SEQUENCE_EDITOR="cat >actual" git -c 
> core.commentChar=% \
>>            rebase -i --update-refs base &&
>>       test_grep "% Ref refs/heads/wt-topic checked out at" actual &&
>> -    test_grep "% Ref refs/heads/topic2 checked out at" actual
>> +    test_grep ! "% Ref refs/heads/topic2 checked out at" actual
> 
> As topic2 is checked out in the worktree where the rebase is running why 
> did this line appear before?
> 
>> diff --git a/t/t3404-rebase-interactive.sh b/t/t3404-rebase- 
>> interactive.sh
>> index e64816770a..11afa8be56 100755
>> --- a/t/t3404-rebase-interactive.sh
>> +++ b/t/t3404-rebase-interactive.sh
>> @@ -1975,15 +1975,23 @@ test_expect_success '--update-refs ignores 
>> non-branch decorations' '
>>       ) &&
>>       grep ^update-ref todo >actual &&
>>       test_write_lines "update-ref refs/heads/no-conflict-branch" 
>> >expect &&
>> +    test_grep ! "^# Ref refs/heads/update-refs checked out" todo &&
> 
> Lets move this line below test_cmp so we keep that line next to the ones 
> that create the files that are being compared. Is this another case 
> where we used to add this comment and no longer do so?
> 
>>       test_cmp expect actual
>>   '
>>   test_expect_success '--update-refs updates refs correctly' '
>> +    test_when_finished "
>> +        test_might_fail git symbolic-ref -d refs/heads/no-conflict- 
>> branch-alias &&
>> +        test_might_fail git symbolic-ref -d refs/heads/second-alias
>> +    " &&
>>       git checkout -B update-refs no-conflict-branch &&
>>       git branch -f base HEAD~4 &&
>>       git branch -f first HEAD~3 &&
>>       git branch -f second HEAD~3 &&
>>       git branch -f third HEAD~1 &&
>> +    git symbolic-ref refs/heads/no-conflict-branch-alias \
>> +        refs/heads/no-conflict-branch &&
>> +    git symbolic-ref refs/heads/second-alias refs/heads/second &&
>>       test_commit extra2 fileX &&
>>       git commit --amend --fixup=L &&
>> @@ -1991,8 +1999,16 @@ test_expect_success '--update-refs updates refs 
>> correctly' '
>>       test_cmp_rev HEAD~3 refs/heads/first &&
>>       test_cmp_rev HEAD~3 refs/heads/second &&
>> +    test_cmp_rev HEAD~3 refs/heads/second-alias &&
>>       test_cmp_rev HEAD~1 refs/heads/third &&
>>       test_cmp_rev HEAD refs/heads/no-conflict-branch &&
>> +    test_cmp_rev HEAD refs/heads/no-conflict-branch-alias &&
>> +    test_write_lines refs/heads/no-conflict-branch >expect &&
>> +    git symbolic-ref refs/heads/no-conflict-branch-alias >actual &&
>> +    test_cmp expect actual &&
>> +    test_write_lines refs/heads/second >expect &&
>> +    git symbolic-ref refs/heads/second-alias >actual &&
>> +    test_cmp expect actual &&
> 
> This looks good - we check that "rebase --update-refs" succeeds withh 
> branches that are symrefs and also that those refs are untouched by the 
> rebase.
> 
> Thanks
> 
> Phillip
> 
>>       q_to_tab >expect <<-\EOF &&
>>       Successfully rebased and updated refs/heads/update-refs.
> 

> > > +        if (head_ref && !strcmp(head_ref, decoration->name)) {
> > > +            free(resolved_ref);
> > >               decoration = decoration->next;
> > >               continue;
> > >           }
> > > +
> > > +        path = branch_checked_out(decoration->name);
> >
> > Then we check to see if the decoration matches HEAD which we used to do
> > above - I'm not clear why we have moved this check.

>> Thanks for re-rolling I'm pretty sure the logic is sound now but I'm a 
>> bit confused by a couple of things - see my comments below.
>> ...
>> It would be nice to have a comment here explaining what we're doing. 
>> Also I don't think we need to copy the refname so it would be more 
>> efficient to use refs_resolve_ref_unsafe().
>
> Looking at this again we cannot use refs_resolve_ref_unsafe() because 
> the result would be overwritten by the call to refs_resolve_refdup() in 
> branch_checked_out().

>>> +        /*
>>> +         * If the branch is the current HEAD, then it will be
>>> +         * updated by the default rebase behavior.
>>> +         */
>>> +        if (head_ref && !strcmp(head_ref, decoration->name)) {
>>> +            free(resolved_ref);
>>>               decoration = decoration->next;
>>>               continue;
>>>           }
>> 
>> Then we check to see if the decoration matches HEAD which we used to do 
>> above - I'm not clear why we have moved this check.
>
> Should we be using "resolved_ref" instead of "decoration->name"? That 
> would explain why this was moved and would makes sense as we resolve 
> symrefs when reading HEAD. When HEAD points outside "refs/heads/" we'd 
> then skip updating any symrefs under "refs/heads/" that pointed to the 
> same ref as HEAD.

> Phillip Wood <phillip.wood123@gmail.com> writes:
> 
>>> Thanks for re-rolling I'm pretty sure the logic is sound now but I'm a
>>> bit confused by a couple of things - see my comments below.
>>> ...
>>> It would be nice to have a comment here explaining what we're doing.
>>> Also I don't think we need to copy the refname so it would be more
>>> efficient to use refs_resolve_ref_unsafe().
>>
>> Looking at this again we cannot use refs_resolve_ref_unsafe() because
>> the result would be overwritten by the call to refs_resolve_refdup() in
>> branch_checked_out().
> 
> Makes sense.  Thanks for raising a possible alternative and then
> clarifying that it is not quite workable.
> 
>>>> +        /*
>>>> +         * If the branch is the current HEAD, then it will be
>>>> +         * updated by the default rebase behavior.
>>>> +         */
>>>> +        if (head_ref && !strcmp(head_ref, decoration->name)) {
>>>> +            free(resolved_ref);
>>>>                decoration = decoration->next;
>>>>                continue;
>>>>            }
>>>
>>> Then we check to see if the decoration matches HEAD which we used to do
>>> above - I'm not clear why we have moved this check.
>>
>> Should we be using "resolved_ref" instead of "decoration->name"? That
>> would explain why this was moved and would makes sense as we resolve
>> symrefs when reading HEAD. When HEAD points outside "refs/heads/" we'd
>> then skip updating any symrefs under "refs/heads/" that pointed to the
>> same ref as HEAD.
> 
> Yeah, decoration is very much end-user facing and if we can make
> behavioural decision based on a more stable resolved_ref that would
> make it easier to reason about.
> 
> But stepping back a bit, is having a HEAD that is a symref and
> points outside "refs/heads/" an invalid state?  Why are we catering
> to such a configuration to begin with?

>> But stepping back a bit, is having a HEAD that is a symref and
>> points outside "refs/heads/" an invalid state?  Why are we catering
>> to such a configuration to begin with?
>
> We allow HEAD to point to anything below "refs/" - see e9cc02f0e4 
> (symbolic-ref: allow refs/<whatever> in HEAD, 2009-02-13).

> Phillip Wood <phillip.wood123@gmail.com> writes:
> 
>>> But stepping back a bit, is having a HEAD that is a symref and
>>> points outside "refs/heads/" an invalid state?  Why are we catering
>>> to such a configuration to begin with?
>>
>> We allow HEAD to point to anything below "refs/" - see e9cc02f0e4
>> (symbolic-ref: allow refs/<whatever> in HEAD, 2009-02-13).
> 
> But that was about a low level mechanism that must be more lenient
> to be usable as repair tools to recover from such a broken state,
> no?

>> But that was about a low level mechanism that must be more lenient
>> to be usable as repair tools to recover from such a broken state,
>> no?
>
> It checks the new value of HEAD, not the old one so I don't think so. 
> The commit message talks about topgit using "git symbolic-ref" to set 
> head outside "refs/heads/" - peff had previously tried to tighten it to 
> reject non-branch refs but that broke topgit. I've just had a quick look 
> at the topgit code and still sets HEAD to point to "refs/top-bases/..." 
> by default[1], although there are plans to start using 
> "refs/heads/{top-bases}/..." instead.

> Phillip Wood <phillip.wood123@gmail.com> writes:
> 
>>> But that was about a low level mechanism that must be more lenient
>>> to be usable as repair tools to recover from such a broken state,
>>> no?
>>
>> It checks the new value of HEAD, not the old one so I don't think so.
>> The commit message talks about topgit using "git symbolic-ref" to set
>> head outside "refs/heads/" - peff had previously tried to tighten it to
>> reject non-branch refs but that broke topgit. I've just had a quick look
>> at the topgit code and still sets HEAD to point to "refs/top-bases/..."
>> by default[1], although there are plans to start using
>> "refs/heads/{top-bases}/..." instead.
> 
> Ah, that name vaguely rings a bell.  Is it still in use, and now
> they prevent us from forbidding funny characters like {} in the
> refname?  Sigh...

>> ... It
>> appears topgit's rebase command is built around "git rebase"[2] so I
>> think we need to continue to support rebasing a non-branch HEAD.
> 
> Sigh, again, but OK.
> 
> Thanks.
> 

> On 29/07/2026 15:26, Junio C Hamano wrote:
>> Phillip Wood <phillip.wood123@gmail.com> writes:
>> 
>>>> But that was about a low level mechanism that must be more lenient
>>>> to be usable as repair tools to recover from such a broken state,
>>>> no?
>>>
>>> It checks the new value of HEAD, not the old one so I don't think so.
>>> The commit message talks about topgit using "git symbolic-ref" to set
>>> head outside "refs/heads/" - peff had previously tried to tighten it to
>>> reject non-branch refs but that broke topgit. I've just had a quick look
>>> at the topgit code and still sets HEAD to point to "refs/top-bases/..."
>>> by default[1], although there are plans to start using
>>> "refs/heads/{top-bases}/..." instead.
>> 
>> Ah, that name vaguely rings a bell.  Is it still in use, and now
>> they prevent us from forbidding funny characters like {} in the
>> refname?  Sigh...
>
> Yes, it still seems to be maintained, I guess they chose the funny 
> characters to try and avoid name collisions because no-one would want 
> them in a "normal" branch name.
>
> Thanks

> From: Son Luong Ngoc <sluongng@gmail.com>
> 
> A local branch symbolic ref may point outside refs/heads/. Such an alias
> cannot be skipped like a branch-to-branch alias because its concrete
> target ref is absent from the local branch decoration list.
> 
> However, queuing each alias independently can update the same target ref
> more than once and make the second compare-and-swap fail. A reservation
> from another worktree can also name either an alias or its resolved
> target ref, so checking only one form can miss an in-progress update.
> 
> Fix these cases by checking both the literal alias and its resolved
> target ref against checked-out reservations. Deduplicate updates by
> target ref. Also reserve both forms when loading another worktree's
> update-refs state. This makes different aliases honor the same
> in-progress update.
> 
> This keeps non-branch symrefs supported without allowing duplicate or
> cross-worktree ref updates.

> diff --git a/branch.c b/branch.c
> index 243db7d0fc..98a50d8368 100644
> --- a/branch.c
> +++ b/branch.c
> @@ -442,10 +442,25 @@ static void prepare_checked_out_branches(void)
>   						     &update_refs)) {
>   			struct string_list_item *item;
>   			for_each_string_list_item(item, &update_refs) {
> +				char *resolved_ref;
> +				int flags = 0;
> +
>   				old = strmap_put(&current_checked_out_branches,
>   						 item->string,
>   						 xstrdup(wt->path));
>   				free(old);
> +
> +				resolved_ref = refs_resolve_refdup(
> +					get_main_ref_store(the_repository),
> +					item->string, RESOLVE_REF_READING,
> +					NULL, &flags);
> +				if (resolved_ref && (flags & REF_ISSYMREF)) {
> +					old = strmap_put(
> +						&current_checked_out_branches,
> +						resolved_ref, xstrdup(wt->path));
> +					free(old);
> +				}
> +				free(resolved_ref);
>   			}

>   			string_list_clear(&update_refs, 1);
>   		}
> diff --git a/sequencer.c b/sequencer.c
> index 63aba60a08..040b5bf645 100644
> --- a/sequencer.c
> +++ b/sequencer.c
> @@ -6459,6 +6459,7 @@ struct todo_add_branch_context {
>   	size_t items_alloc;
>   	struct strbuf *buf;
>   	struct string_list refs_to_oids;
> +	struct string_list symref_update_targets;
>   };
>   
>   static int add_decorations_to_list(const struct commit *commit,
> @@ -6473,6 +6474,7 @@ static int add_decorations_to_list(const struct commit *commit,
>   	while (decoration) {
>   		struct todo_item *item;
>   		const char *path;
> +		const char *checked_ref;
>   		char *resolved_ref;
>   		int flags = 0;
>   		size_t base_offset = ctx->buf->len;
> @@ -6508,6 +6510,17 @@ static int add_decorations_to_list(const struct commit *commit,
>   		}
>   
>   		path = branch_checked_out(decoration->name);
> +		if (!path && resolved_ref && (flags & REF_ISSYMREF)) {
> +			checked_ref = resolved_ref;
> +			path = branch_checked_out(checked_ref);
> +		}
> +		if (!path && resolved_ref && (flags & REF_ISSYMREF) &&
> +		    string_list_has_string(&ctx->symref_update_targets,
> +					   resolved_ref)) {
> +			free(resolved_ref);
> +			decoration = decoration->next;
> +			continue;
> +		}

>   		ALLOC_GROW(ctx->items,
>   			ctx->items_nr + 1,
> @@ -6523,6 +6536,10 @@ static int add_decorations_to_list(const struct commit *commit,
>   					      decoration->name, path);
>   		} else {
>   			struct string_list_item *sti;
> +
> +			if (resolved_ref && (flags & REF_ISSYMREF))
> +				string_list_insert(&ctx->symref_update_targets,
> +						   resolved_ref);
>   			item->command = TODO_UPDATE_REF;
>   			strbuf_addf(ctx->buf, "%s\n", decoration->name);
>   
> @@ -6554,6 +6571,7 @@ static int todo_list_add_update_ref_commands(struct todo_list *todo_list)
>   	struct todo_add_branch_context ctx = {
>   		.buf = &todo_list->buf,
>   		.refs_to_oids = STRING_LIST_INIT_DUP,
> +		.symref_update_targets = STRING_LIST_INIT_DUP,
>   	};
>   
>   	ctx.items_alloc = 2 * todo_list->nr + 1;
> @@ -6579,6 +6597,7 @@ static int todo_list_add_update_ref_commands(struct todo_list *todo_list)
>   	res = write_update_refs_state(&ctx.refs_to_oids);
>   
>   	string_list_clear(&ctx.refs_to_oids, 1);
> +	string_list_clear(&ctx.symref_update_targets, 0);
>   
>   	if (res) {
>   		/* we failed, so clean up the new list. */
> diff --git a/t/t3404-rebase-interactive.sh b/t/t3404-rebase-interactive.sh
> index 11afa8be56..110ed8ae63 100755
> --- a/t/t3404-rebase-interactive.sh
> +++ b/t/t3404-rebase-interactive.sh
> @@ -2024,6 +2024,78 @@ test_expect_success '--update-refs updates refs correctly' '
>   	test_cmp expect err.trimmed
>   '
>   
> +test_expect_success '--update-refs checks resolved non-branch symref target' '
> +	test_when_finished "
> +		git worktree remove --force checked-out-target-wt &&
> +		git symbolic-ref -d refs/heads/non-branch-alias &&
> +		git tag -d checked-out-target
> +	" &&
> +	git tag checked-out-target HEAD~1 &&
> +	git symbolic-ref refs/heads/non-branch-alias refs/tags/checked-out-target &&
> +	git worktree add --detach checked-out-target-wt checked-out-target &&
> +	git -C checked-out-target-wt symbolic-ref HEAD refs/tags/checked-out-target &&
> +
> +	GIT_SEQUENCE_EDITOR="cat >todo" git rebase -i --update-refs HEAD~2 &&
> +
> +	test_grep "^# Ref refs/heads/non-branch-alias checked out at" todo &&
> +	test_write_lines refs/tags/checked-out-target >expect &&
> +	git symbolic-ref refs/heads/non-branch-alias >actual &&
> +	test_cmp expect actual
> +'
> +
> +test_expect_success '--update-refs deduplicates non-branch symref targets' '
> +	test_when_finished "
> +		git symbolic-ref -d refs/heads/non-branch-alias-one &&
> +		git symbolic-ref -d refs/heads/non-branch-alias-two &&
> +		git tag -d shared-non-branch-target
> +	" &&
> +	git tag shared-non-branch-target HEAD~1 &&
> +	git symbolic-ref refs/heads/non-branch-alias-one \
> +		refs/tags/shared-non-branch-target &&
> +	git symbolic-ref refs/heads/non-branch-alias-two \
> +		refs/tags/shared-non-branch-target &&
> +
> +	GIT_SEQUENCE_EDITOR=: git rebase -i --force-rebase --update-refs HEAD~2 &&
> +
> +	test_cmp_rev HEAD~1 refs/heads/non-branch-alias-one &&
> +	test_cmp_rev HEAD~1 refs/heads/non-branch-alias-two &&
> +	test_write_lines refs/tags/shared-non-branch-target >expect &&
> +	git symbolic-ref refs/heads/non-branch-alias-one >actual &&
> +	test_cmp expect actual &&
> +	git symbolic-ref refs/heads/non-branch-alias-two >actual &&
> +	test_cmp expect actual
> +'
> +
> +test_expect_success '--update-refs honors non-branch symref reservations' '
> +	test_when_finished "
> +		test_might_fail git worktree remove --force reserved-target-wt &&
> +		test_might_fail git symbolic-ref -d \
> +			refs/heads/reserved-non-branch-alias-one &&
> +		test_might_fail git symbolic-ref -d \
> +			refs/heads/reserved-non-branch-alias-two &&
> +		test_might_fail git tag -d reserved-non-branch-target
> +	" &&
> +	git tag reserved-non-branch-target HEAD~1 &&
> +	git symbolic-ref refs/heads/reserved-non-branch-alias-one \
> +		refs/tags/reserved-non-branch-target &&
> +	git symbolic-ref refs/heads/reserved-non-branch-alias-two \
> +		refs/tags/reserved-non-branch-target &&
> +	git worktree add --detach reserved-target-wt HEAD &&
> +	wt_gitdir=$(git -C reserved-target-wt rev-parse --absolute-git-dir) &&
> +	mkdir -p "$wt_gitdir/rebase-merge" &&
> +	old_oid=$(git rev-parse refs/heads/reserved-non-branch-alias-one) &&
> +	test_write_lines refs/heads/reserved-non-branch-alias-one \
> +		"$old_oid" "$old_oid" >"$wt_gitdir/rebase-merge/update-refs" &&
> +
> +	GIT_SEQUENCE_EDITOR="cat >todo" git rebase -i --update-refs HEAD~2 &&
> +
> +	test_grep "^# Ref refs/heads/reserved-non-branch-alias-one checked out at" \
> +		todo &&
> +	test_grep "^# Ref refs/heads/reserved-non-branch-alias-two checked out at" \
> +		todo &&
> +	test_grep ! "^update-ref refs/heads/reserved-non-branch-alias" todo
> +'
> +
>   test_expect_success 'respect user edits to update-ref steps' '
>   	git checkout -B update-refs-break no-conflict-branch &&
>   	git branch -f base HEAD~4 &&

> Phillip Wood <phillip.wood123@gmail.com> writes:
> 
>> On 29/07/2026 15:26, Junio C Hamano wrote:
>>> Phillip Wood <phillip.wood123@gmail.com> writes:
>>>
>>>>> But that was about a low level mechanism that must be more lenient
>>>>> to be usable as repair tools to recover from such a broken state,
>>>>> no?
>>>>
>>>> It checks the new value of HEAD, not the old one so I don't think so.
>>>> The commit message talks about topgit using "git symbolic-ref" to set
>>>> head outside "refs/heads/" - peff had previously tried to tighten it to
>>>> reject non-branch refs but that broke topgit. I've just had a quick look
>>>> at the topgit code and still sets HEAD to point to "refs/top-bases/..."
>>>> by default[1], although there are plans to start using
>>>> "refs/heads/{top-bases}/..." instead.
>>>
>>> Ah, that name vaguely rings a bell.  Is it still in use, and now
>>> they prevent us from forbidding funny characters like {} in the
>>> refname?  Sigh...
>>
>> Yes, it still seems to be maintained, I guess they chose the funny
>> characters to try and avoid name collisions because no-one would want
>> them in a "normal" branch name.
>>
>> Thanks
> 
> I guess I dropped the ball here.  So given that we are OK to see
> HEAD pointing outside refs/heads/, this subthread should be closed.
> 
> My understanding is that we still have an issue reported by Erik in
> <amSSYagL0jTgzElD@mbp> that needs to be addressed before this topic
> can move further?