diff --git a/tools/tools/git/git-arc.1 b/tools/tools/git/git-arc.1
index e449875c5043..5ada942d13a9 100644
--- a/tools/tools/git/git-arc.1
+++ b/tools/tools/git/git-arc.1
@@ -1,245 +1,258 @@
 .\"
 .\" SPDX-License-Identifier: BSD-2-Clause
 .\"
 .\" Copyright (c) 2021 Daniel Ebdrup Jensen
 .\"
 .\" Redistribution and use in source and binary forms, with or without
 .\" modification, are permitted provided that the following conditions
 .\" are met:
 .\" 1. Redistributions of source code must retain the above copyright
 .\"    notice, this list of conditions and the following disclaimer.
 .\" 2. Redistributions in binary form must reproduce the above copyright
 .\"    notice, this list of conditions and the following disclaimer in the
 .\"    documentation and/or other materials provided with the distribution.
 .\"
 .\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 .\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 .\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 .\" ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 .\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 .\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 .\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 .\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 .\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
 .Dd May 5, 2023
 .Dt GIT-ARC 1
 .Os
 .Sh NAME
 .Nm git arc
 .Nd a wrapper to improve integration between git and arcanist
 .Sh SYNOPSIS
 .Nm
 .Cm create
 .Op Fl l
 .Op Fl r Ar reviewer1 Ns Op Cm \&, Ns Ar reviewer2 ...
 .Op Fl s Ar subscriber1 Ns Op Cm \&, Ns Ar subscriber2 ...
 .Op Fl p Ar parent
 .Op Ar commit ... Ns | Ns Ar commit-range
 .Nm
 .Cm list Ar commit ... Ns | Ns Ar commit-range
 .Nm
 .Cm patch
 .Op Fl c
 .Ar diff1 Ns Op Cm \&, Ns Ar diff2
 .Nm
 .Cm stage
 .Op Fl b Ar branch
 .Op Ar commit ... Ns | Ns Ar commit-range
 .Nm
 .Cm update
+.Op Fl l
 .Op Fl m Ar message
 .Op Ar commit ... Ns | Ns Ar commit-range
 .Sh DESCRIPTION
 The
 .Nm
 utility creates and manages
 .Fx
 Phabricator reviews based on git commits.
 .Pp
 Git
 assumes a one-to-one relationship between git commits and
 Differential Revisions, and the Differential Revision title must match
 the summary line of the corresponding commit.
 In particular, the commit summaries must be unique across all open
 Differential Revisions authored by the submitter.
 .Pp
 The first parameter must be a verb.
 The available verbs are:
 .Bl -tag -width "create"
 .It Cm create
 Create new Differential Revisions from the specified commits.
 Accepts options:
 .Bl -tag -width subscriber
 .It Fl l
 Before processing commit(s) display list of commits to be processed
 and wait for confirmation.
 .It Fl r Ar reviewer
 Add one or more reviewers, separated by commas, to revision(s) being created.
 Argument(s) must be existing Phabricator user or group.
 .It Fl s Ar subscriber
 Add one or more subscribers, separated by commas, to revision(s) being created.
 Each argument must be an existing Phabricator user or group.
 .It Fl p Ar parent
 Specify the parent of the first commit in the list.
 This is useful when adding more commits on top of the already existing
 stack in Phabricator.
 .El
 .It Cm list
 Print the associated Differential Revisions for the specified commits.
 .It Cm patch
 Try to apply a patch from a Differential Revision to the currently
 checked out tree.
 .It Cm stage
 Prepare a series of commits to be pushed to the upstream
 .Fx
 repository.
 The commits are cherry-picked to a branch (by default the
 .Dq main
 branch), review tags are added to the commit log message, and
 the log message is opened in an editor for any last-minute
 updates.
 The commits need not have associated Differential
 Revisions.
 .It Cm update
 Synchronize the Differential Revisions associated with the
 specified commits.
 Currently only the diff is updated; the review description and other
 metadata are not synchronized.
 If a message is specified with
 .Fl m ,
 that message is added as a note to the Differential Revision.
 If no message is supplied,
 the user's editor will be opened to provide an update message for
 each revision.
 If an empty message is supplied via
 .Fl m ,
 then no notes will be added when updating Differential Revisions.
+.Pp
+If
+.Fl l
+is used, display list of commits to be updated and wait for confirmation
+of the list rather than prompting for each commit.
 .El
 .Sh CONFIGURATION
 These are manipulated by
 .Nm git-config :
 .Bl -tag -width "arc.assume_yes"
 .It Va arc.assume_yes
 Assume a
 .Dq yes
 answer to all prompts instead of
 prompting the user.
 Equivalent to the
 .Fl y
 flag.
 Defaults to false.
 .It Va arc.browse
 Try to open newly created reviews in a browser tab.
 Defaults to false.
 .It Va arc.list
 Always use
 .Dq list mode
 .Pq Fl l
-with create.
-In this mode, the list of git revisions to create reviews for
-is listed with a single prompt before creating reviews.
+with create and update.
+In this mode, the list of git revisions to use
+is listed with a single prompt before creating or updating reviews.
 The diffs for individual commits are not shown.
 Defaults to false.
 .It Va arc.verbose
 Always use verbose output.
 Equivalent to the
 .Fl v
 flag.
 Defaults to false.
 .El
 .Sh EXAMPLES
 The typical end-to-end usage looks something like this.
 .Pp
 Commit changes with a message and create a Differential Review:
 .Bd -literal -offset indent
 $ git commit -m "kern: Rewrite in Rust"
 $ git arc create HEAD
 .Ed
 .Pp
 Make changes to the diff based on review feedback, then amend the
 changes to the existing commit and update the Differential Review:
 .Bd -literal -offset indent
 $ git commit --amend
 $ git arc update HEAD
 .Ed
 .Pp
 Now that all reviewers are happy, it is time to stage the commit and
 push it:
 .Bd -literal -offset indent
 $ git arc stage HEAD
 $ git push freebsd HEAD:main
 .Ed
 .Pp
 Create a Phabricator review using the contents of the most recent
 commit in your git checkout:
 .Bd -literal -offset indent
 $ git arc create -r markj HEAD
 .Ed
 .Pp
 The commit title is used as the review title, the commit log
 message is used as the review description, and
 .Aq Mt markj@FreeBSD.org
 is added as a reviewer.
 .Pp
 Create a series of Phabricator reviews for each of HEAD~2, HEAD~ and
 HEAD:
 .Bd -literal -offset indent
 $ git arc create HEAD~3..HEAD
 .Ed
 .Pp
 Pairs of consecutive commits are linked into a patch stack.
 Note that the first commit in the specified range is excluded.
 .Pp
 Create a series of separate reviews for each of the following commits:
 .Bd -literal -offset indent
 $ git arc create b409afcfedcdda ca03ed1345aff0
 .Ed
 .Pp
 Update the review corresponding to commit b409afcfedcdda:
 .Bd -literal -offset indent
 $ git arc update b409afcfedcdda
 .Ed
 .Pp
 The title of the commit must be the same as it was when the review
 was created.
 Note that the review description is not automatically updated.
 .Pp
 Apply the patch in review D12345 to the currently checked-out tree,
 and stage it:
 .Bd -literal -offset indent
 $ git arc patch D12345
 .Ed
 .Pp
 Apply the patch in review D23456 to the currently checked-out tree,
 and commit it to the tree with the commit message in the review and
 make the best guess for what to use for author.
 If the guess is considered unreliable, the user is prompted to see
 if they wish to use it (or abort).
 .Bd -literal -offset indent
 $ git arc patch -c D23456
 .Ed
 .Pp
 List the status of reviews for all the commits in the branch
 .Dq feature :
 .Bd -literal -offset indent
 $ git arc list main..feature
 .Ed
+.Pp
+Update reviews for all commits in the branch
+.Dq feature
+after rebasing:
+.Bd -literal -offset indent
+$ git arc update -lm "Rebase" main..feature
+.Ed
 .Sh SEE ALSO
 .Xr build 7 ,
 .Xr development 7
 .Sh HISTORY
 The
 .Nm
 utility appeared in the src tools collection in
 .Fx 14.0 .
 .Sh AUTHORS
 The
 .Nm
 utility was written by
 .An -nosplit
 .An Mark Johnston Aq Mt markj@FreeBSD.org
 and the manual page was written by
 .An Daniel Ebdrup Jensen Aq Mt debdrup@FreeBSD.org .
diff --git a/tools/tools/git/git-arc.sh b/tools/tools/git/git-arc.sh
index 1c828f3194af..e8da1f1ed32a 100644
--- a/tools/tools/git/git-arc.sh
+++ b/tools/tools/git/git-arc.sh
@@ -1,789 +1,808 @@
 #!/bin/sh
 #
 # SPDX-License-Identifier: BSD-2-Clause
 #
 # Copyright (c) 2019-2021 Mark Johnston <markj@FreeBSD.org>
 # Copyright (c) 2021 John Baldwin <jhb@FreeBSD.org>
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 # 1. Redistributions of source code must retain the above copyright
 #    notice, this list of conditions and the following disclaimer.
 # 2. Redistributions in binary form must reproduce the above copyright
 #    notice, this list of conditions and the following disclaimer in
 #    the documentation and/or other materials provided with the distribution.
 #
 # THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 # ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 # IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 # ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 # FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 # DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 # OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 # HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 # LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 # OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 # SUCH DAMAGE.
 #
 
 # TODO:
 # - roll back after errors or SIGINT
 #   - created revs
 #   - main (for git arc stage)
 
 warn()
 {
     echo "$(basename "$0"): $1" >&2
 }
 
 err()
 {
     warn "$1"
     exit 1
 }
 
 err_usage()
 {
     cat >&2 <<__EOF__
 Usage: git arc [-vy] <command> <arguments>
 
 Commands:
   create [-l] [-r <reviewer1>[,<reviewer2>...]] [-s subscriber[,...]] [<commit>|<commit range>]
   list <commit>|<commit range>
   patch [-c] <diff1> [<diff2> ...]
   stage [-b branch] [<commit>|<commit range>]
-  update [-m message] [<commit>|<commit range>]
+  update [-l] [-m message] [<commit>|<commit range>]
 
 Description:
   Create or manage FreeBSD Phabricator reviews based on git commits.  There
   is a one-to one relationship between git commits and Differential revisions,
   and the Differential revision title must match the summary line of the
   corresponding commit.  In particular, commit summaries must be unique across
   all open Differential revisions authored by you.
 
   The first parameter must be a verb.  The available verbs are:
 
     create -- Create new Differential revisions from the specified commits.
     list   -- Print the associated Differential revisions for the specified
               commits.
     patch  -- Try to apply a patch from a Differential revision to the
               currently checked out tree.
     stage  -- Prepare a series of commits to be pushed to the upstream FreeBSD
               repository.  The commits are cherry-picked to a branch (main by
               default), review tags are added to the commit log message, and
               the log message is opened in an editor for any last-minute
               updates.  The commits need not have associated Differential
               revisions.
     update -- Synchronize the Differential revisions associated with the
               specified commits.  Currently only the diff is updated; the
               review description and other metadata is not synchronized.
 
   The typical end-to-end usage looks something like this:
 
     $ git commit -m "kern: Rewrite in Rust"
     $ git arc create HEAD
     <Make changes to the diff based on reviewer feedback.>
     $ git commit --amend
     $ git arc update HEAD
     <Now that all reviewers are happy, it's time to push.>
     $ git arc stage HEAD
     $ git push freebsd HEAD:main
 
 Config Variables:
   These are manipulated by git-config(1).
 
     arc.assume_yes [bool]
                        -- Assume a "yes" answer to all prompts instead of
                           prompting the user.  Equivalent to the -y flag.
 
     arc.browse [bool]  -- Try to open newly created reviews in a browser tab.
                           Defaults to false.
 
-    arc.list [bool]    -- Always use "list mode" (-l) with create.  In this
-                          mode, the list of git revisions to create reviews for
-                          is listed with a single prompt before creating
-                          reviews.  The diffs for individual commits are not
-                          shown.
+    arc.list [bool]    -- Always use "list mode" (-l) with create and update.
+			  In this mode, the list of git revisions to use
+                          is listed with a single prompt before creating or
+                          updating reviews.  The diffs for individual commits
+			  are not shown.
 
     arc.verbose [bool] -- Verbose output.  Equivalent to the -v flag.
 
 Examples:
   Create a Phabricator review using the contents of the most recent commit in
   your git checkout.  The commit title is used as the review title, the commit
   log message is used as the review description, markj@FreeBSD.org is added as
   a reviewer.
 
   $ git arc create -r markj HEAD
 
   Create a series of Phabricator reviews for each of HEAD~2, HEAD~ and HEAD.
   Pairs of consecutive commits are linked into a patch stack.  Note that the
   first commit in the specified range is excluded.
 
   $ git arc create HEAD~3..HEAD
 
   Update the review corresponding to commit b409afcfedcdda.  The title of the
   commit must be the same as it was when the review was created.  The review
   description is not automatically updated.
 
   $ git arc update b409afcfedcdda
 
   Apply the patch in review D12345 to the currently checked-out tree, and stage
   it.
 
   $ git arc patch D12345
 
   Apply the patch in review D12345 to the currently checked-out tree, and
   commit it using the review's title, summary and author.
 
   $ git arc patch -c D12345
 
   List the status of reviews for all the commits in the branch "feature":
 
   $ git arc list main..feature
 
 __EOF__
 
     exit 1
 }
 
 #
 # Filter the output of call-conduit to remove the warnings that are generated
 # for some installations where openssl module is mysteriously installed twice so
 # a warning is generated. It's likely a local config error, but we should work
 # in the face of that.
 #
 arc_call_conduit()
 {
     arc call-conduit "$@" | grep -v '^Warning: '
 }
 
 #
 # Filter the output of arc list to remove the warnings as above, as well as
 # the bolding sequence (the color sequence remains intact).
 #
 arc_list()
 {
     arc list "$@" | grep -v '^Warning: ' | sed -E 's/\x1b\[1m//g;s/\x1b\[m//g'
 }
 
 diff2phid()
 {
     local diff
 
     diff=$1
     if ! expr "$diff" : 'D[1-9][0-9]*$' >/dev/null; then
         err "invalid diff ID $diff"
     fi
 
     echo '{"names":["'"$diff"'"]}' |
         arc_call_conduit -- phid.lookup |
         jq -r "select(.response != []) | .response.${diff}.phid"
 }
 
 diff2status()
 {
     local diff tmp status summary
 
     diff=$1
     if ! expr "$diff" : 'D[1-9][0-9]*$' >/dev/null; then
         err "invalid diff ID $diff"
     fi
 
     tmp=$(mktemp)
     echo '{"names":["'"$diff"'"]}' |
         arc_call_conduit -- phid.lookup > "$tmp"
     status=$(jq -r "select(.response != []) | .response.${diff}.status" < "$tmp")
     summary=$(jq -r "select(.response != []) |
          .response.${diff}.fullName" < "$tmp")
     printf "%-14s %s\n" "${status}" "${summary}"
 }
 
 log2diff()
 {
     local diff
 
     diff=$(git show -s --format=%B "$commit" |
         sed -nE '/^Differential Revision:[[:space:]]+(https:\/\/reviews.freebsd.org\/)?(D[0-9]+)$/{s//\2/;p;}')
     if [ -n "$diff" ] && [ "$(echo "$diff" | wc -l)" -eq 1 ]; then
         echo "$diff"
     else
         echo
     fi
 }
 
 # Look for an open revision with a title equal to the input string.  Return
 # a possibly empty list of Differential revision IDs.
 title2diff()
 {
     local title
 
     title=$(echo $1 | sed 's/"/\\"/g')
     arc_list --no-ansi |
         awk -F': ' '{
             if (substr($0, index($0, FS) + length(FS)) == "'"$title"'") {
                 print substr($1, match($1, "D[1-9][0-9]*"))
             }
         }'
 }
 
 commit2diff()
 {
     local commit diff title
 
     commit=$1
 
     # First, look for a valid differential reference in the commit
     # log.
     diff=$(log2diff "$commit")
     if [ -n "$diff" ]; then
         echo "$diff"
         return
     fi
 
     # Second, search the open reviews returned by 'arc list' looking
     # for a subject match.
     title=$(git show -s --format=%s "$commit")
     diff=$(title2diff "$title")
     if [ -z "$diff" ]; then
         err "could not find review for '${title}'"
     elif [ "$(echo "$diff" | wc -l)" -ne 1 ]; then
         err "found multiple reviews with the same title"
     fi
 
     echo "$diff"
 }
 
 create_one_review()
 {
     local childphid commit doprompt msg parent parentphid reviewers
     local subscribers
 
     commit=$1
     reviewers=$2
     subscribers=$3
     parent=$4
     doprompt=$5
 
     if [ "$doprompt" ] && ! show_and_prompt "$commit"; then
         return 1
     fi
 
     msg=$(mktemp)
     git show -s --format='%B' "$commit" > "$msg"
     printf "\nTest Plan:\n" >> "$msg"
     printf "\nReviewers:\n" >> "$msg"
     printf "%s\n" "${reviewers}" >> "$msg"
     printf "\nSubscribers:\n" >> "$msg"
     printf "%s\n" "${subscribers}" >> "$msg"
 
     yes | env EDITOR=true \
         arc diff --message-file "$msg" --never-apply-patches --create \
         --allow-untracked $BROWSE --head "$commit" "${commit}~"
     [ $? -eq 0 ] || err "could not create Phabricator diff"
 
     if [ -n "$parent" ]; then
         diff=$(commit2diff "$commit")
         [ -n "$diff" ] || err "failed to look up review ID for $commit"
 
         childphid=$(diff2phid "$diff")
         parentphid=$(diff2phid "$parent")
         echo '{
             "objectIdentifier": "'"${childphid}"'",
             "transactions": [
                 {
                     "type": "parents.add",
                     "value": ["'"${parentphid}"'"]
                 }
              ]}' |
             arc_call_conduit -- differential.revision.edit >&3
     fi
     rm -f "$msg"
     return 0
 }
 
 # Get a list of reviewers who accepted the specified diff.
 diff2reviewers()
 {
     local diff reviewid userids
 
     diff=$1
     reviewid=$(diff2phid "$diff")
     userids=$( \
         echo '{
                   "constraints": {"phids": ["'"$reviewid"'"]},
                   "attachments": {"reviewers": true}
               }' |
         arc_call_conduit -- differential.revision.search |
         jq '.response.data[0].attachments.reviewers.reviewers[] | select(.status == "accepted").reviewerPHID')
     if [ -n "$userids" ]; then
         echo '{
                   "constraints": {"phids": ['"$(echo -n "$userids" | tr '[:space:]' ',')"']}
               }' |
             arc_call_conduit -- user.search |
             jq -r '.response.data[].fields.username'
     fi
 }
 
 prompt()
 {
     local resp
 
     if [ "$ASSUME_YES" ]; then
         return 0
     fi
 
     printf "\nDoes this look OK? [y/N] "
     read -r resp
 
     case $resp in
     [Yy])
         return 0
         ;;
     *)
         return 1
         ;;
     esac
 }
 
 show_and_prompt()
 {
     local commit
 
     commit=$1
 
     git show "$commit"
     prompt
 }
 
 build_commit_list()
 {
     local chash _commits commits
 
     for chash in "$@"; do
         _commits=$(git rev-parse "${chash}")
         if ! git cat-file -e "${chash}"'^{commit}' >/dev/null 2>&1; then
             # shellcheck disable=SC2086
             _commits=$(git rev-list --reverse $_commits)
         fi
         [ -n "$_commits" ] || err "invalid commit ID ${chash}"
         commits="$commits $_commits"
     done
     echo "$commits"
 }
 
 gitarc__create()
 {
     local commit commits doprompt list o prev reviewers subscribers
 
     list=
     prev=""
     if [ "$(git config --bool --get arc.list 2>/dev/null || echo false)" != "false" ]; then
         list=1
     fi
     doprompt=1
     while getopts lp:r:s: o; do
         case "$o" in
         l)
             list=1
             ;;
         p)
             prev="$OPTARG"
             ;;
         r)
             reviewers="$OPTARG"
             ;;
         s)
             subscribers="$OPTARG"
             ;;
         *)
             err_usage
             ;;
         esac
     done
     shift $((OPTIND-1))
 
     commits=$(build_commit_list "$@")
 
     if [ "$list" ]; then
         for commit in ${commits}; do
             git --no-pager show --oneline --no-patch "$commit"
         done | git_pager
         if ! prompt; then
             return
         fi
         doprompt=
     fi
 
     for commit in ${commits}; do
         if create_one_review "$commit" "$reviewers" "$subscribers" "$prev" \
                              "$doprompt"; then
             prev=$(commit2diff "$commit")
         else
             prev=""
         fi
     done
 }
 
 gitarc__list()
 {
     local chash commit commits diff openrevs title
 
     commits=$(build_commit_list "$@")
     openrevs=$(arc_list --ansi)
 
     for commit in $commits; do
         chash=$(git show -s --format='%C(auto)%h' "$commit")
         echo -n "${chash} "
 
         diff=$(log2diff "$commit")
         if [ -n "$diff" ]; then
                 diff2status "$diff"
                 continue
         fi
 
         # This does not use commit2diff as it needs to handle errors
         # differently and keep the entire status.
         title=$(git show -s --format=%s "$commit")
         diff=$(echo "$openrevs" | \
             awk -F'D[1-9][0-9]*: ' \
                 '{if ($2 == "'"$(echo $title | sed 's/"/\\"/g')"'") print $0}')
         if [ -z "$diff" ]; then
             echo "No Review            : $title"
         elif [ "$(echo "$diff" | wc -l)" -ne 1 ]; then
             echo -n "Ambiguous Reviews: "
             echo "$diff" | grep -E -o 'D[1-9][0-9]*:' | tr -d ':' \
                 | paste -sd ',' - | sed 's/,/, /g'
         else
             echo "$diff" | sed -e 's/^[^ ]* *//'
         fi
     done
 }
 
 # Try to guess our way to a good author name. The DWIM is strong in this
 # function, but these heuristics seem to generally produce the right results, in
 # the sample of src commits I checked out.
 find_author()
 {
     local addr name email author_addr author_name
 
     addr="$1"
     name="$2"
     author_addr="$3"
     author_name="$4"
 
     # The Phabricator interface doesn't have a simple way to get author name and
     # address, so we have to try a number of heuristics to get the right result.
 
     # Choice 1: It's a FreeBSD committer. These folks have no '.' in their phab
     # username/addr. Sampled data in phab suggests that there's a high rate of
     # these people having their local config pointing at something other than
     # freebsd.org (which isn't surprising for ports committers getting src
     # commits reviewed).
     case "${addr}" in
     *.*) ;;		# external user
     *)
 	echo "${name} <${addr}@FreeBSD.org>"
 	return
 	;;
     esac
 
     # Choice 2: author_addr and author_name were set in the bundle, so use
     # that. We may need to filter some known bogus ones, should they crop up.
     if [ -n "$author_name" -a -n "$author_addr" ]; then
 	echo "${author_name} <${author_addr}>"
 	return
     fi
 
     # Choice 3: We can find this user in the FreeBSD repo. They've submited
     # something before, and they happened to use an email that's somewhat
     # similar to their phab username.
     email=$(git log -1 --author "$(echo ${addr} | tr _ .)" --pretty="%aN <%aE>")
     if [ -n "${email}" ]; then
 	echo "${email}"
 	return
     fi
 
     # Choice 4: We know this user. They've committed before, and they happened
     # to use the same name, unless the name has the word 'user' in it. This
     # might not be a good idea, since names can be somewhat common (there
     # are two Andrew Turners that have contributed to FreeBSD, for example).
     if ! (echo "${name}" | grep -w "[Uu]ser" -q); then
 	email=$(git log -1 --author "${name}" --pretty="%aN <%aE>")
 	if [ -n "$email" ]; then
 	    echo "$email"
 	    return
 	fi
     fi
 
     # Choice 5: Wing it as best we can. In this scenario, we replace the last _
     # with a @, and call it the email address...
     # Annoying fun fact: Phab replaces all non alpha-numerics with _, so we
     # don't know if the prior _ are _ or + or any number of other characters.
     # Since there's issues here, prompt
     a=$(printf "%s <%s>\n" "${name}" $(echo "$addr" | sed -e 's/\(.*\)_/\1@/'))
     echo "Making best guess: Truning ${addr} to ${a}"
     if ! prompt; then
        echo "ABORT"
        return
     fi
     echo "${a}"
 }
 
 patch_commit()
 {
     local diff reviewid review_data authorid user_data user_addr user_name author
     local tmp author_addr author_name
 
     diff=$1
     reviewid=$(diff2phid "$diff")
     # Get the author phid for this patch
     review_data=$(echo '{
                   "constraints": {"phids": ["'"$reviewid"'"]}
 		}' |
         arc_call_conduit -- differential.revision.search)
     authorid=$(echo "$review_data" | jq -r '.response.data[].fields.authorPHID' )
     # Get metadata about the user that submitted this patch
     user_data=$(echo '{
                   "constraints": {"phids": ["'"$authorid"'"]}
 		}' |
             arc call-conduit -- user.search | grep -v ^Warning: |
             jq -r '.response.data[].fields')
     user_addr=$(echo "$user_data" | jq -r '.username')
     user_name=$(echo "$user_data" | jq -r '.realName')
     # Dig the data out of querydiffs api endpoint, although it's deprecated,
     # since it's one of the few places we can get email addresses. It's unclear
     # if we can expect multiple difference ones of these. Some records don't
     # have this data, so we remove all the 'null's. We sort the results and
     # remove duplicates 'just to be sure' since we've not seen multiple
     # records that match.
     diff_data=$(echo '{
 		"revisionIDs": [ '"${diff#D}"' ]
 		}' | arc_call_conduit -- differential.querydiffs |
 	     jq -r '.response | flatten | .[]')
     author_addr=$(echo "$diff_data" | jq -r ".authorEmail?" | sort -u)
     author_name=$(echo "$diff_data" | jq -r ".authorName?" | sort -u)
     author=$(find_author "$user_addr" "$user_name" "$author_addr" "$author_name")
 
     # If we had to guess, and the user didn't want to guess, abort
     if [ "${author}" = "ABORT" ]; then
 	warn "Not committing due to uncertainty over author name"
 	exit 1
     fi
 
     tmp=$(mktemp)
     echo "$review_data" | jq -r '.response.data[].fields.title' > $tmp
     echo >> $tmp
     echo "$review_data" | jq -r '.response.data[].fields.summary' >> $tmp
     echo >> $tmp
     # XXX this leaves an extra newline in some cases.
     reviewers=$(diff2reviewers "$diff" | sed '/^$/d' | paste -sd ',' - | sed 's/,/, /g')
     if [ -n "$reviewers" ]; then
         printf "Reviewed by:\t%s\n" "${reviewers}" >> "$tmp"
     fi
     # XXX TODO refactor with gitarc__stage maybe?
     printf "Differential Revision:\thttps://reviews.freebsd.org/%s\n" "${diff}" >> "$tmp"
     git commit --author "${author}" --file "$tmp"
     rm "$tmp"
 }
 
 gitarc__patch()
 {
     local rev commit
 
     if [ $# -eq 0 ]; then
         err_usage
     fi
 
     commit=false
     while getopts c o; do
         case "$o" in
         c)
 	    require_clean_work_tree "patch -c"
             commit=true
             ;;
         *)
             err_usage
             ;;
         esac
     done
     shift $((OPTIND-1))
 
     for rev in "$@"; do
         arc patch --skip-dependencies --nocommit --nobranch --force "$rev"
         echo "Applying ${rev}..."
         [ $? -eq 0 ] || break
 	if ${commit}; then
 	    patch_commit $rev
 	fi
     done
 }
 
 gitarc__stage()
 {
     local author branch commit commits diff reviewers title tmp
 
     branch=main
     while getopts b: o; do
         case "$o" in
         b)
             branch="$OPTARG"
             ;;
         *)
             err_usage
             ;;
         esac
     done
     shift $((OPTIND-1))
 
     commits=$(build_commit_list "$@")
 
     if [ "$branch" = "main" ]; then
         git checkout -q main
     else
         git checkout -q -b "${branch}" main
     fi
 
     tmp=$(mktemp)
     for commit in $commits; do
         git show -s --format=%B "$commit" > "$tmp"
         title=$(git show -s --format=%s "$commit")
         diff=$(title2diff "$title")
         if [ -n "$diff" ]; then
             # XXX this leaves an extra newline in some cases.
             reviewers=$(diff2reviewers "$diff" | sed '/^$/d' | paste -sd ',' - | sed 's/,/, /g')
             if [ -n "$reviewers" ]; then
                 printf "Reviewed by:\t%s\n" "${reviewers}" >> "$tmp"
             fi
             printf "Differential Revision:\thttps://reviews.freebsd.org/%s" "${diff}" >> "$tmp"
         fi
         author=$(git show -s --format='%an <%ae>' "${commit}")
         if ! git cherry-pick --no-commit "${commit}"; then
             warn "Failed to apply $(git rev-parse --short "${commit}").  Are you staging patches in the wrong order?"
             git checkout -f
             break
         fi
         git commit --edit --file "$tmp" --author "${author}"
     done
 }
 
 gitarc__update()
 {
-    local commit commits diff have_msg msg
+    local commit commits diff doprompt have_msg list o msg
 
-    while getopts m: o; do
+    list=
+    if [ "$(git config --bool --get arc.list 2>/dev/null || echo false)" != "false" ]; then
+        list=1
+    fi
+    doprompt=1
+    while getopts lm: o; do
         case "$o" in
+        l)
+            list=1
+            ;;
         m)
             msg="$OPTARG"
             have_msg=1
             ;;
         *)
             err_usage
             ;;
         esac
     done
     shift $((OPTIND-1))
 
     commits=$(build_commit_list "$@")
+
+    if [ "$list" ]; then
+        for commit in ${commits}; do
+            git --no-pager show --oneline --no-patch "$commit"
+        done | git_pager
+        if ! prompt; then
+            return
+        fi
+        doprompt=
+    fi
+
     for commit in ${commits}; do
         diff=$(commit2diff "$commit")
 
-        if ! show_and_prompt "$commit"; then
+        if [ "$doprompt" ] && ! show_and_prompt "$commit"; then
             break
         fi
 
         # The linter is stupid and applies patches to the working copy.
         # This would be tolerable if it didn't try to correct "misspelled" variable
         # names.
         if [ -n "$have_msg" ]; then
             arc diff --message "$msg" --allow-untracked --never-apply-patches \
                 --update "$diff" --head "$commit" "${commit}~"
         else
             arc diff --allow-untracked --never-apply-patches --update "$diff" \
                 --head "$commit" "${commit}~"
         fi
     done
 }
 
 set -e
 
 ASSUME_YES=
 if [ "$(git config --bool --get arc.assume-yes 2>/dev/null || echo false)" != "false" ]; then
     ASSUME_YES=1
 fi
 
 VERBOSE=
 while getopts vy o; do
     case "$o" in
     v)
         VERBOSE=1
         ;;
     y)
         ASSUME_YES=1
         ;;
     *)
         err_usage
         ;;
     esac
 done
 shift $((OPTIND-1))
 
 [ $# -ge 1 ] || err_usage
 
 which arc >/dev/null 2>&1 || err "arc is required, install devel/arcanist"
 which jq >/dev/null 2>&1 || err "jq is required, install textproc/jq"
 
 if [ "$VERBOSE" ]; then
     exec 3>&1
 else
     exec 3> /dev/null
 fi
 
 case "$1" in
 create|list|patch|stage|update)
     ;;
 *)
     err_usage
     ;;
 esac
 verb=$1
 shift
 
 # All subcommands require at least one parameter.
 if [ $# -eq 0 ]; then
     err_usage
 fi
 
 # Pull in some git helper functions.
 git_sh_setup=$(git --exec-path)/git-sh-setup
 [ -f "$git_sh_setup" ] || err "cannot find git-sh-setup"
 SUBDIRECTORY_OK=y
 USAGE=
 # shellcheck disable=SC1090
 . "$git_sh_setup"
 
 # git commands use GIT_EDITOR instead of EDITOR, so try to provide consistent
 # behaviour.  Ditto for PAGER.  This makes git-arc play nicer with editor
 # plugins like vim-fugitive.
 if [ -n "$GIT_EDITOR" ]; then
     EDITOR=$GIT_EDITOR
 fi
 if [ -n "$GIT_PAGER" ]; then
     PAGER=$GIT_PAGER
 fi
 
 # Bail if the working tree is unclean, except for "list" and "patch"
 # operations.
 case $verb in
 list|patch)
     ;;
 *)
     require_clean_work_tree "$verb"
     ;;
 esac
 
 if [ "$(git config --bool --get arc.browse 2>/dev/null || echo false)" != "false" ]; then
     BROWSE=--browse
 fi
 
 gitarc__"${verb}" "$@"