18 files changed, 751 insertions, 153 deletions

diff --git a/subcmds/abandon.py b/subcmds/abandon.py
index 3208be6b..f1688e7b 100644
--- a/subcmds/abandon.py
+++ b/subcmds/abandon.py
@@ -48,7 +48,6 @@ It is equivalent to "git branch -D <branchname>".
     def _Options(self, p):
         p.add_option(
             "--all",
-            dest="all",
             action="store_true",
             help="delete all branches in all projects",
         )
diff --git a/subcmds/diff.py b/subcmds/diff.py
index 7bb0cbbd..fe1a5139 100644
--- a/subcmds/diff.py
+++ b/subcmds/diff.py
@@ -35,7 +35,6 @@ to the Unix 'patch' command.
         p.add_option(
             "-u",
             "--absolute",
-            dest="absolute",
             action="store_true",
             help="paths are relative to the repository root",
         )
diff --git a/subcmds/diffmanifests.py b/subcmds/diffmanifests.py
index 3eee3f94..66b3183d 100644
--- a/subcmds/diffmanifests.py
+++ b/subcmds/diffmanifests.py
@@ -67,7 +67,9 @@ synced and their revisions won't be found.
 
     def _Options(self, p):
         p.add_option(
-            "--raw", dest="raw", action="store_true", help="display raw diff"
+            "--raw",
+            action="store_true",
+            help="display raw diff",
         )
         p.add_option(
             "--no-color",
@@ -78,7 +80,6 @@ synced and their revisions won't be found.
         )
         p.add_option(
             "--pretty-format",
-            dest="pretty_format",
             action="store",
             metavar="<FORMAT>",
             help="print the log using a custom git pretty format string",
diff --git a/subcmds/download.py b/subcmds/download.py
index 4396c9e7..1c0bf5ce 100644
--- a/subcmds/download.py
+++ b/subcmds/download.py
@@ -60,7 +60,6 @@ If no project is specified try to use current directory as a project.
         p.add_option(
             "-r",
             "--revert",
-            dest="revert",
             action="store_true",
             help="revert instead of checkout",
         )
diff --git a/subcmds/forall.py b/subcmds/forall.py
index 9da0c96e..4bae46af 100644
--- a/subcmds/forall.py
+++ b/subcmds/forall.py
@@ -133,7 +133,7 @@ without iterating through the remaining projects.
 
     @staticmethod
     def _cmd_option(option, _opt_str, _value, parser):
-        setattr(parser.values, option.dest, list(parser.rargs))
+        setattr(parser.values, option.dest or "command", list(parser.rargs))
         while parser.rargs:
             del parser.rargs[0]
 
@@ -141,7 +141,6 @@ without iterating through the remaining projects.
         p.add_option(
             "-r",
             "--regex",
-            dest="regex",
             action="store_true",
             help="execute the command only on projects matching regex or "
             "wildcard expression",
@@ -149,7 +148,6 @@ without iterating through the remaining projects.
         p.add_option(
             "-i",
             "--inverse-regex",
-            dest="inverse_regex",
             action="store_true",
             help="execute the command only on projects not matching regex or "
             "wildcard expression",
@@ -157,7 +155,6 @@ without iterating through the remaining projects.
         p.add_option(
             "-g",
             "--groups",
-            dest="groups",
             help="execute the command only on projects matching the specified "
             "groups",
         )
@@ -165,14 +162,12 @@ without iterating through the remaining projects.
             "-c",
             "--command",
             help="command (and arguments) to execute",
-            dest="command",
             action="callback",
             callback=self._cmd_option,
         )
         p.add_option(
             "-e",
             "--abort-on-errors",
-            dest="abort_on_errors",
             action="store_true",
             help="abort if a command exits unsuccessfully",
         )
diff --git a/subcmds/grep.py b/subcmds/grep.py
index 918651d9..85977ce8 100644
--- a/subcmds/grep.py
+++ b/subcmds/grep.py
@@ -120,7 +120,6 @@ contain a line that matches both expressions:
         g.add_option(
             "-r",
             "--revision",
-            dest="revision",
             action="append",
             metavar="TREEish",
             help="Search TREEish, instead of the work tree",
diff --git a/subcmds/info.py b/subcmds/info.py
index ab230ddd..2fbdae05 100644
--- a/subcmds/info.py
+++ b/subcmds/info.py
@@ -43,14 +43,12 @@ class Info(PagedCommand):
         p.add_option(
             "-o",
             "--overview",
-            dest="overview",
             action="store_true",
             help="show overview of all local commits",
         )
         p.add_option(
             "-c",
             "--current-branch",
-            dest="current_branch",
             action="store_true",
             help="consider only checked out branches",
         )
@@ -104,6 +102,10 @@ class Info(PagedCommand):
         self.heading("Manifest groups: ")
         self.headtext(manifestGroups)
         self.out.nl()
+        sp = self.manifest.superproject
+        srev = sp.commit_id if sp and sp.commit_id else "None"
+        self.heading("Superproject revision: ")
+        self.headtext(srev)
 
         self.printSeparator()
 
diff --git a/subcmds/init.py b/subcmds/init.py
index fb6d3eb5..f5a3892a 100644
--- a/subcmds/init.py
+++ b/subcmds/init.py
@@ -127,6 +127,7 @@ to update the working directory files.
         return {
             "REPO_MANIFEST_URL": "manifest_url",
             "REPO_MIRROR_LOCATION": "reference",
+            "REPO_GIT_LFS": "git_lfs",
         }
 
     def _SyncManifest(self, opt):
diff --git a/subcmds/list.py b/subcmds/list.py
index 4338e1c9..df9ce5f6 100644
--- a/subcmds/list.py
+++ b/subcmds/list.py
@@ -40,7 +40,6 @@ This is similar to running: repo forall -c 'echo "$REPO_PATH : $REPO_PROJECT"'.
         p.add_option(
             "-r",
             "--regex",
-            dest="regex",
             action="store_true",
             help="filter the project list based on regex or wildcard matching "
             "of strings",
@@ -48,7 +47,6 @@ This is similar to running: repo forall -c 'echo "$REPO_PATH : $REPO_PROJECT"'.
         p.add_option(
             "-g",
             "--groups",
-            dest="groups",
             help="filter the project list based on the groups the project is "
             "in",
         )
@@ -61,21 +59,18 @@ This is similar to running: repo forall -c 'echo "$REPO_PATH : $REPO_PROJECT"'.
         p.add_option(
             "-n",
             "--name-only",
-            dest="name_only",
             action="store_true",
             help="display only the name of the repository",
         )
         p.add_option(
             "-p",
             "--path-only",
-            dest="path_only",
             action="store_true",
             help="display only the path of the repository",
         )
         p.add_option(
             "-f",
             "--fullpath",
-            dest="fullpath",
             action="store_true",
             help="display the full work tree path instead of the relative path",
         )
diff --git a/subcmds/manifest.py b/subcmds/manifest.py
index 9786580a..548bac0d 100644
--- a/subcmds/manifest.py
+++ b/subcmds/manifest.py
@@ -134,7 +134,6 @@ human-readable variations.
         p.add_option(
             "-o",
             "--output-file",
-            dest="output_file",
             default="-",
             help="file to save the manifest to. (Filename prefix for "
             "multi-tree.)",
diff --git a/subcmds/overview.py b/subcmds/overview.py
index 8ccad611..dff17623 100644
--- a/subcmds/overview.py
+++ b/subcmds/overview.py
@@ -37,7 +37,6 @@ are displayed.
         p.add_option(
             "-c",
             "--current-branch",
-            dest="current_branch",
             action="store_true",
             help="consider only checked out branches",
         )
diff --git a/subcmds/rebase.py b/subcmds/rebase.py
index db1b387c..d7e769ce 100644
--- a/subcmds/rebase.py
+++ b/subcmds/rebase.py
@@ -47,21 +47,18 @@ branch but need to incorporate new upstream changes "underneath" them.
         g.add_option(
             "-i",
             "--interactive",
-            dest="interactive",
             action="store_true",
             help="interactive rebase (single project only)",
         )
 
         p.add_option(
             "--fail-fast",
-            dest="fail_fast",
             action="store_true",
             help="stop rebasing after first error is hit",
         )
         p.add_option(
             "-f",
             "--force-rebase",
-            dest="force_rebase",
             action="store_true",
             help="pass --force-rebase to git rebase",
         )
@@ -74,27 +71,23 @@ branch but need to incorporate new upstream changes "underneath" them.
         )
         p.add_option(
             "--autosquash",
-            dest="autosquash",
             action="store_true",
             help="pass --autosquash to git rebase",
         )
         p.add_option(
             "--whitespace",
-            dest="whitespace",
             action="store",
             metavar="WS",
             help="pass --whitespace to git rebase",
         )
         p.add_option(
             "--auto-stash",
-            dest="auto_stash",
             action="store_true",
             help="stash local modifications before starting",
         )
         p.add_option(
             "-m",
             "--onto-manifest",
-            dest="onto_manifest",
             action="store_true",
             help="rebase onto the manifest version instead of upstream "
             "HEAD (this helps to make sure the local tree stays "
diff --git a/subcmds/selfupdate.py b/subcmds/selfupdate.py
index 72683097..ed333569 100644
--- a/subcmds/selfupdate.py
+++ b/subcmds/selfupdate.py
@@ -54,7 +54,6 @@ need to be performed by an end-user.
         )
         g.add_option(
             "--repo-upgraded",
-            dest="repo_upgraded",
             action="store_true",
             help=optparse.SUPPRESS_HELP,
         )
diff --git a/subcmds/stage.py b/subcmds/stage.py
index 92a00ea0..1c285fc1 100644
--- a/subcmds/stage.py
+++ b/subcmds/stage.py
@@ -46,7 +46,6 @@ The '%prog' command stages files to prepare the next commit.
         g.add_option(
             "-i",
             "--interactive",
-            dest="interactive",
             action="store_true",
             help="use interactive staging",
         )
diff --git a/subcmds/start.py b/subcmds/start.py
index 6dca7e4e..73dddf3f 100644
--- a/subcmds/start.py
+++ b/subcmds/start.py
@@ -51,7 +51,6 @@ revision specified in the manifest.
     def _Options(self, p):
         p.add_option(
             "--all",
-            dest="all",
             action="store_true",
             help="begin branch in all projects",
         )
diff --git a/subcmds/status.py b/subcmds/status.py
index cda73627..a9852b3c 100644
--- a/subcmds/status.py
+++ b/subcmds/status.py
@@ -82,7 +82,6 @@ the following meanings:
         p.add_option(
             "-o",
             "--orphans",
-            dest="orphans",
             action="store_true",
             help="include objects in working directory outside of repo "
             "projects",
diff --git a/subcmds/sync.py b/subcmds/sync.py
index 3dc74f1f..250925f4 100644
--- a/subcmds/sync.py
+++ b/subcmds/sync.py
@@ -13,6 +13,7 @@
 # limitations under the License.
 
 import collections
+import contextlib
 import functools
 import http.cookiejar as cookielib
 import io
@@ -25,7 +26,7 @@ from pathlib import Path
 import sys
 import tempfile
 import time
-from typing import List, NamedTuple, Set, Union
+from typing import List, NamedTuple, Optional, Set, Tuple, Union
 import urllib.error
 import urllib.parse
 import urllib.request
@@ -67,6 +68,7 @@ from git_config import GetUrlCookieFile
 from git_refs import HEAD
 from git_refs import R_HEADS
 import git_superproject
+from hooks import RepoHook
 import platform_utils
 from progress import elapsed_str
 from progress import jobs_str
@@ -194,6 +196,57 @@ class _CheckoutOneResult(NamedTuple):
     finish: float
 
 
+class _SyncResult(NamedTuple):
+    """Individual project sync result for interleaved mode.
+
+    Attributes:
+      project_index (int): The index of the project in the shared list.
+      relpath (str): The project's relative path from the repo client top.
+      remote_fetched (bool): True if the remote was actually queried.
+      fetch_success (bool): True if the fetch operation was successful.
+      fetch_error (Optional[Exception]): The Exception from a failed fetch,
+          or None.
+      fetch_start (Optional[float]): The time.time() when fetch started.
+      fetch_finish (Optional[float]): The time.time() when fetch finished.
+      checkout_success (bool): True if the checkout operation was
+          successful.
+      checkout_error (Optional[Exception]): The Exception from a failed
+          checkout, or None.
+      checkout_start (Optional[float]): The time.time() when checkout
+          started.
+      checkout_finish (Optional[float]): The time.time() when checkout
+          finished.
+      stderr_text (str): The combined output from both fetch and checkout.
+    """
+
+    project_index: int
+    relpath: str
+
+    remote_fetched: bool
+    fetch_success: bool
+    fetch_error: Optional[Exception]
+    fetch_start: Optional[float]
+    fetch_finish: Optional[float]
+
+    checkout_success: bool
+    checkout_error: Optional[Exception]
+    checkout_start: Optional[float]
+    checkout_finish: Optional[float]
+
+    stderr_text: str
+
+
+class _InterleavedSyncResult(NamedTuple):
+    """Result of an interleaved sync.
+
+    Attributes:
+      results (List[_SyncResult]): A list of results, one for each project
+          processed. Empty if the worker failed before creating results.
+    """
+
+    results: List[_SyncResult]
+
+
 class SuperprojectError(SyncError):
     """Superproject sync repo."""
 
@@ -359,7 +412,7 @@ later is required to fix a server side protocol bug.
             type=int,
             metavar="JOBS",
             help="number of network jobs to run in parallel (defaults to "
-            "--jobs or 1)",
+            "--jobs or 1). Ignored when --interleaved is set",
         )
         p.add_option(
             "--jobs-checkout",
@@ -367,25 +420,23 @@ later is required to fix a server side protocol bug.
             type=int,
             metavar="JOBS",
             help="number of local checkout jobs to run in parallel (defaults "
-            f"to --jobs or {DEFAULT_LOCAL_JOBS})",
+            f"to --jobs or {DEFAULT_LOCAL_JOBS}). Ignored when --interleaved "
+            "is set",
         )
 
         p.add_option(
             "-f",
             "--force-broken",
-            dest="force_broken",
             action="store_true",
             help="obsolete option (to be deleted in the future)",
         )
         p.add_option(
             "--fail-fast",
-            dest="fail_fast",
             action="store_true",
             help="stop syncing after first error is hit",
         )
         p.add_option(
             "--force-sync",
-            dest="force_sync",
             action="store_true",
             help="overwrite an existing git directory if it needs to "
             "point to a different object directory. WARNING: this "
@@ -393,7 +444,6 @@ later is required to fix a server side protocol bug.
         )
         p.add_option(
             "--force-checkout",
-            dest="force_checkout",
             action="store_true",
             help="force checkout even if it results in throwing away "
             "uncommitted modifications. "
@@ -401,7 +451,6 @@ later is required to fix a server side protocol bug.
         )
         p.add_option(
             "--force-remove-dirty",
-            dest="force_remove_dirty",
             action="store_true",
             help="force remove projects with uncommitted modifications if "
             "projects no longer exist in the manifest. "
@@ -409,7 +458,6 @@ later is required to fix a server side protocol bug.
         )
         p.add_option(
             "--rebase",
-            dest="rebase",
             action="store_true",
             help="rebase local commits regardless of whether they are "
             "published",
@@ -417,7 +465,6 @@ later is required to fix a server side protocol bug.
         p.add_option(
             "-l",
             "--local-only",
-            dest="local_only",
             action="store_true",
             help="only update working tree, don't fetch",
         )
@@ -431,9 +478,13 @@ later is required to fix a server side protocol bug.
             "(do not update to the latest revision)",
         )
         p.add_option(
+            "--interleaved",
+            action="store_true",
+            help="fetch and checkout projects in parallel (experimental)",
+        )
+        p.add_option(
             "-n",
             "--network-only",
-            dest="network_only",
             action="store_true",
             help="fetch only, don't update working tree",
         )
@@ -460,7 +511,6 @@ later is required to fix a server side protocol bug.
         p.add_option(
             "-m",
             "--manifest-name",
-            dest="manifest_name",
             help="temporary manifest to use for this sync",
             metavar="NAME.xml",
         )
@@ -479,19 +529,16 @@ later is required to fix a server side protocol bug.
             "-u",
             "--manifest-server-username",
             action="store",
-            dest="manifest_server_username",
             help="username to authenticate with the manifest server",
         )
         p.add_option(
             "-p",
             "--manifest-server-password",
             action="store",
-            dest="manifest_server_password",
             help="password to authenticate with the manifest server",
         )
         p.add_option(
             "--fetch-submodules",
-            dest="fetch_submodules",
             action="store_true",
             help="fetch submodules from server",
         )
@@ -515,7 +562,6 @@ later is required to fix a server side protocol bug.
         )
         p.add_option(
             "--optimized-fetch",
-            dest="optimized_fetch",
             action="store_true",
             help="only fetch projects fixed to sha1 if revision does not exist "
             "locally",
@@ -554,7 +600,6 @@ later is required to fix a server side protocol bug.
             p.add_option(
                 "-s",
                 "--smart-sync",
-                dest="smart_sync",
                 action="store_true",
                 help="smart sync using manifest from the latest known good "
                 "build",
@@ -562,7 +607,6 @@ later is required to fix a server side protocol bug.
             p.add_option(
                 "-t",
                 "--smart-tag",
-                dest="smart_tag",
                 action="store",
                 help="smart sync using manifest from a known tag",
             )
@@ -577,10 +621,10 @@ later is required to fix a server side protocol bug.
         )
         g.add_option(
             "--repo-upgraded",
-            dest="repo_upgraded",
             action="store_true",
             help=optparse.SUPPRESS_HELP,
         )
+        RepoHook.AddOptionGroup(p, "post-sync")
 
     def _GetBranch(self, manifest_project):
         """Returns the branch name for getting the approved smartsync manifest.
@@ -848,15 +892,7 @@ later is required to fix a server side protocol bug.
         )
 
         sync_event = _threading.Event()
-
-        def _MonitorSyncLoop():
-            while True:
-                pm.update(inc=0, msg=self._GetSyncProgressMessage())
-                if sync_event.wait(timeout=1):
-                    return
-
-        sync_progress_thread = _threading.Thread(target=_MonitorSyncLoop)
-        sync_progress_thread.daemon = True
+        sync_progress_thread = self._CreateSyncProgressThread(pm, sync_event)
 
         def _ProcessResults(pool, pm, results_sets):
             ret = True
@@ -955,25 +991,16 @@ later is required to fix a server side protocol bug.
         Returns:
             List of all projects that should be checked out.
         """
-        rp = manifest.repoProject
-
         to_fetch = []
-        now = time.time()
-        if _ONE_DAY_S <= (now - rp.LastFetch):
-            to_fetch.append(rp)
         to_fetch.extend(all_projects)
         to_fetch.sort(key=self._fetch_times.Get, reverse=True)
 
         result = self._Fetch(to_fetch, opt, err_event, ssh_proxy, errors)
         success = result.success
         fetched = result.projects
-
         if not success:
             err_event.set()
 
-        # Call self update, unless requested not to
-        if os.environ.get("REPO_SKIP_SELF_UPDATE", "0") == "0":
-            _PostRepoFetch(rp, opt.repo_verify)
         if opt.network_only:
             # Bail out now; the rest touches the working tree.
             if err_event.is_set():
@@ -1152,6 +1179,16 @@ later is required to fix a server side protocol bug.
         self._local_sync_state.Save()
         return proc_res and not err_results
 
+    def _PrintManifestNotices(self, opt):
+        """Print all manifest notices, but only once."""
+        printed_notices = set()
+        # Print all manifest notices, but only once.
+        # Sort by path_prefix to ensure consistent ordering.
+        for m in sorted(self.ManifestList(opt), key=lambda x: x.path_prefix):
+            if m.notice and m.notice not in printed_notices:
+                print(m.notice)
+                printed_notices.add(m.notice)
+
     @staticmethod
     def _GetPreciousObjectsState(project: Project, opt):
         """Get the preciousObjects state for the project.
@@ -1324,6 +1361,61 @@ later is required to fix a server side protocol bug.
             t.join()
         pm.end()
 
+    def _UpdateRepoProject(self, opt, manifest, errors):
+        """Fetch the repo project and check for updates."""
+        if opt.local_only:
+            return
+
+        rp = manifest.repoProject
+        now = time.time()
+        # If we've fetched in the last day, don't bother fetching again.
+        if (now - rp.LastFetch) < _ONE_DAY_S:
+            return
+
+        with multiprocessing.Manager() as manager:
+            with ssh.ProxyManager(manager) as ssh_proxy:
+                ssh_proxy.sock()
+                start = time.time()
+                buf = TeeStringIO(sys.stdout if opt.verbose else None)
+                sync_result = rp.Sync_NetworkHalf(
+                    quiet=opt.quiet,
+                    verbose=opt.verbose,
+                    output_redir=buf,
+                    current_branch_only=self._GetCurrentBranchOnly(
+                        opt, manifest
+                    ),
+                    force_sync=opt.force_sync,
+                    clone_bundle=opt.clone_bundle,
+                    tags=opt.tags,
+                    archive=manifest.IsArchive,
+                    optimized_fetch=opt.optimized_fetch,
+                    retry_fetches=opt.retry_fetches,
+                    prune=opt.prune,
+                    ssh_proxy=ssh_proxy,
+                    clone_filter=manifest.CloneFilter,
+                    partial_clone_exclude=manifest.PartialCloneExclude,
+                    clone_filter_for_depth=manifest.CloneFilterForDepth,
+                )
+                if sync_result.error:
+                    errors.append(sync_result.error)
+
+                finish = time.time()
+                self.event_log.AddSync(
+                    rp,
+                    event_log.TASK_SYNC_NETWORK,
+                    start,
+                    finish,
+                    sync_result.success,
+                )
+                if not sync_result.success:
+                    logger.error("error: Cannot fetch repo tool %s", rp.name)
+                    return
+
+        # After fetching, check if a new version of repo is available and
+        # restart. This is only done if the user hasn't explicitly disabled it.
+        if os.environ.get("REPO_SKIP_SELF_UPDATE", "0") == "0":
+            _PostRepoFetch(rp, opt.repo_verify)
+
     def _ReloadManifest(self, manifest_name, manifest):
         """Reload the manfiest from the file specified by the |manifest_name|.
 
@@ -1757,6 +1849,21 @@ later is required to fix a server side protocol bug.
         except (KeyboardInterrupt, Exception) as e:
             raise RepoUnhandledExceptionError(e, aggregate_errors=errors)
 
+        # Run post-sync hook only after successful sync
+        self._RunPostSyncHook(opt)
+
+    def _RunPostSyncHook(self, opt):
+        """Run post-sync hook if configured in manifest <repo-hooks>."""
+        hook = RepoHook.FromSubcmd(
+            hook_type="post-sync",
+            manifest=self.manifest,
+            opt=opt,
+            abort_if_user_denies=False,
+        )
+        success = hook.Run(repo_topdir=self.client.topdir)
+        if not success:
+            print("Warning: post-sync hook reported failure.")
+
     def _ExecuteHelper(self, opt, args, errors):
         manifest = self.outer_manifest
         if not opt.outer_manifest:
@@ -1788,8 +1895,6 @@ later is required to fix a server side protocol bug.
                         e,
                     )
 
-        err_event = multiprocessing.Event()
-
         rp = manifest.repoProject
         rp.PreSync()
         cb = rp.CurrentBranch
@@ -1828,6 +1933,9 @@ later is required to fix a server side protocol bug.
         # might be in the manifest.
         self._ValidateOptionsWithManifest(opt, mp)
 
+        # Update the repo project and check for new versions of repo.
+        self._UpdateRepoProject(opt, manifest, errors)
+
         superproject_logging_data = {}
         self._UpdateProjectsRevisionId(
             opt, args, superproject_logging_data, manifest
@@ -1841,10 +1949,6 @@ later is required to fix a server side protocol bug.
             all_manifests=not opt.this_manifest_only,
         )
 
-        err_network_sync = False
-        err_update_projects = False
-        err_update_linkfiles = False
-
         # Log the repo projects by existing and new.
         existing = [x for x in all_projects if x.Exists]
         mp.config.SetString("repo.existingprojectcount", str(len(existing)))
@@ -1854,6 +1958,185 @@ later is required to fix a server side protocol bug.
 
         self._fetch_times = _FetchTimes(manifest)
         self._local_sync_state = LocalSyncState(manifest)
+
+        if opt.interleaved:
+            sync_method = self._SyncInterleaved
+        else:
+            sync_method = self._SyncPhased
+
+        sync_method(
+            opt,
+            args,
+            errors,
+            manifest,
+            mp,
+            all_projects,
+            superproject_logging_data,
+        )
+
+        # Log the previous sync analysis state from the config.
+        self.git_event_log.LogDataConfigEvents(
+            mp.config.GetSyncAnalysisStateData(), "previous_sync_state"
+        )
+
+        # Update and log with the new sync analysis state.
+        mp.config.UpdateSyncAnalysisState(opt, superproject_logging_data)
+        self.git_event_log.LogDataConfigEvents(
+            mp.config.GetSyncAnalysisStateData(), "current_sync_state"
+        )
+
+        self._local_sync_state.PruneRemovedProjects()
+        if self._local_sync_state.IsPartiallySynced():
+            logger.warning(
+                "warning: Partial syncs are not supported. For the best "
+                "experience, sync the entire tree."
+            )
+
+        if not opt.quiet:
+            print("repo sync has finished successfully.")
+
+    def _CreateSyncProgressThread(
+        self, pm: Progress, stop_event: _threading.Event
+    ) -> _threading.Thread:
+        """Creates and returns a daemon thread to update a Progress object.
+
+        The returned thread is not yet started. The thread will periodically
+        update the progress bar with information from _GetSyncProgressMessage
+        until the stop_event is set.
+
+        Args:
+            pm: The Progress object to update.
+            stop_event: The threading.Event to signal the monitor to stop.
+
+        Returns:
+            The configured _threading.Thread object.
+        """
+
+        def _monitor_loop():
+            """The target function for the monitor thread."""
+            while True:
+                # Update the progress bar with the current status message.
+                pm.update(inc=0, msg=self._GetSyncProgressMessage())
+                # Wait for 1 second or until the stop_event is set.
+                if stop_event.wait(timeout=1):
+                    return
+
+        return _threading.Thread(target=_monitor_loop, daemon=True)
+
+    def _UpdateManifestLists(
+        self,
+        opt: optparse.Values,
+        err_event: multiprocessing.Event,
+        errors: List[Exception],
+    ) -> Tuple[bool, bool]:
+        """Updates project lists and copy/link files for all manifests.
+
+        Args:
+            opt: Program options from optparse.
+            err_event: An event to set if any error occurs.
+            errors: A list to append any encountered exceptions to.
+
+        Returns:
+            A tuple (err_update_projects, err_update_linkfiles) indicating
+                an error for each task.
+        """
+        err_update_projects = False
+        err_update_linkfiles = False
+        for m in self.ManifestList(opt):
+            if m.IsMirror or m.IsArchive:
+                continue
+
+            try:
+                self.UpdateProjectList(opt, m)
+            except Exception as e:
+                err_event.set()
+                err_update_projects = True
+                errors.append(e)
+                if isinstance(e, DeleteWorktreeError):
+                    errors.extend(e.aggregate_errors)
+                if opt.fail_fast:
+                    logger.error("error: Local checkouts *not* updated.")
+                    raise SyncFailFastError(aggregate_errors=errors)
+
+            try:
+                self.UpdateCopyLinkfileList(m)
+            except Exception as e:
+                err_event.set()
+                err_update_linkfiles = True
+                errors.append(e)
+                if opt.fail_fast:
+                    logger.error(
+                        "error: Local update copyfile or linkfile failed."
+                    )
+                    raise SyncFailFastError(aggregate_errors=errors)
+        return err_update_projects, err_update_linkfiles
+
+    def _ReportErrors(
+        self,
+        errors,
+        err_network_sync=False,
+        failing_network_repos=None,
+        err_checkout=False,
+        failing_checkout_repos=None,
+        err_update_projects=False,
+        err_update_linkfiles=False,
+    ):
+        """Logs detailed error messages and raises a SyncError."""
+
+        def print_and_log(err_msg):
+            self.git_event_log.ErrorEvent(err_msg)
+            logger.error("%s", err_msg)
+
+        print_and_log("error: Unable to fully sync the tree")
+        if err_network_sync:
+            print_and_log("error: Downloading network changes failed.")
+            if failing_network_repos:
+                logger.error(
+                    "Failing repos (network):\n%s",
+                    "\n".join(sorted(failing_network_repos)),
+                )
+        if err_update_projects:
+            print_and_log("error: Updating local project lists failed.")
+        if err_update_linkfiles:
+            print_and_log("error: Updating copyfiles or linkfiles failed.")
+        if err_checkout:
+            print_and_log("error: Checking out local projects failed.")
+            if failing_checkout_repos:
+                logger.error(
+                    "Failing repos (checkout):\n%s",
+                    "\n".join(sorted(failing_checkout_repos)),
+                )
+        logger.error(
+            'Try re-running with "-j1 --fail-fast" to exit at the first error.'
+        )
+        raise SyncError(aggregate_errors=errors)
+
+    def _SyncPhased(
+        self,
+        opt,
+        args,
+        errors,
+        manifest,
+        mp,
+        all_projects,
+        superproject_logging_data,
+    ):
+        """Sync projects by separating network and local operations.
+
+        This method performs sync in two distinct, sequential phases:
+        1.  Network Phase: Fetches updates for all projects from their remotes.
+        2.  Local Phase: Checks out the updated revisions into the local
+            worktrees for all projects.
+
+        This approach ensures that the local work-tree is not modified until
+        all network operations are complete, providing a transactional-like
+        safety net for the checkout state.
+        """
+        err_event = multiprocessing.Event()
+        err_network_sync = False
+        err_update_projects = False
+        err_update_linkfiles = False
+
         if not opt.local_only:
             with multiprocessing.Manager() as manager:
                 with ssh.ProxyManager(manager) as ssh_proxy:
@@ -1886,34 +2169,11 @@ later is required to fix a server side protocol bug.
                     )
                     raise SyncFailFastError(aggregate_errors=errors)
 
-        for m in self.ManifestList(opt):
-            if m.IsMirror or m.IsArchive:
-                # Bail out now, we have no working tree.
-                continue
-
-            try:
-                self.UpdateProjectList(opt, m)
-            except Exception as e:
-                err_event.set()
-                err_update_projects = True
-                errors.append(e)
-                if isinstance(e, DeleteWorktreeError):
-                    errors.extend(e.aggregate_errors)
-                if opt.fail_fast:
-                    logger.error("error: Local checkouts *not* updated.")
-                    raise SyncFailFastError(aggregate_errors=errors)
-
-            try:
-                self.UpdateCopyLinkfileList(m)
-            except Exception as e:
-                err_update_linkfiles = True
-                errors.append(e)
-                err_event.set()
-                if opt.fail_fast:
-                    logger.error(
-                        "error: Local update copyfile or linkfile failed."
-                    )
-                    raise SyncFailFastError(aggregate_errors=errors)
+        err_update_projects, err_update_linkfiles = self._UpdateManifestLists(
+            opt,
+            err_event,
+            errors,
+        )
 
         err_results = []
         # NB: We don't exit here because this is the last step.
@@ -1923,61 +2183,416 @@ later is required to fix a server side protocol bug.
         if err_checkout:
             err_event.set()
 
-        printed_notices = set()
-        # If there's a notice that's supposed to print at the end of the sync,
-        # print it now...  But avoid printing duplicate messages, and preserve
-        # order.
-        for m in sorted(self.ManifestList(opt), key=lambda x: x.path_prefix):
-            if m.notice and m.notice not in printed_notices:
-                print(m.notice)
-                printed_notices.add(m.notice)
+        self._PrintManifestNotices(opt)
 
         # If we saw an error, exit with code 1 so that other scripts can check.
         if err_event.is_set():
-
-            def print_and_log(err_msg):
-                self.git_event_log.ErrorEvent(err_msg)
-                logger.error("%s", err_msg)
-
-            print_and_log("error: Unable to fully sync the tree")
-            if err_network_sync:
-                print_and_log("error: Downloading network changes failed.")
-            if err_update_projects:
-                print_and_log("error: Updating local project lists failed.")
-            if err_update_linkfiles:
-                print_and_log("error: Updating copyfiles or linkfiles failed.")
-            if err_checkout:
-                print_and_log("error: Checking out local projects failed.")
-                if err_results:
-                    # Don't log repositories, as it may contain sensitive info.
-                    logger.error("Failing repos:\n%s", "\n".join(err_results))
-            # Not useful to log.
-            logger.error(
-                'Try re-running with "-j1 --fail-fast" to exit at the first '
-                "error."
+            self._ReportErrors(
+                errors,
+                err_network_sync=err_network_sync,
+                err_checkout=err_checkout,
+                failing_checkout_repos=err_results,
+                err_update_projects=err_update_projects,
+                err_update_linkfiles=err_update_linkfiles,
             )
-            raise SyncError(aggregate_errors=errors)
 
-        # Log the previous sync analysis state from the config.
-        self.git_event_log.LogDataConfigEvents(
-            mp.config.GetSyncAnalysisStateData(), "previous_sync_state"
+    @classmethod
+    def _SyncOneProject(cls, opt, project_index, project) -> _SyncResult:
+        """Syncs a single project for interleaved sync."""
+        fetch_success = False
+        remote_fetched = False
+        fetch_error = None
+        fetch_start = None
+        fetch_finish = None
+        network_output = ""
+
+        if opt.local_only:
+            fetch_success = True
+        else:
+            fetch_start = time.time()
+            network_output_capture = io.StringIO()
+            try:
+                ssh_proxy = cls.get_parallel_context().get("ssh_proxy")
+                sync_result = project.Sync_NetworkHalf(
+                    quiet=opt.quiet,
+                    verbose=opt.verbose,
+                    output_redir=network_output_capture,
+                    current_branch_only=cls._GetCurrentBranchOnly(
+                        opt, project.manifest
+                    ),
+                    force_sync=opt.force_sync,
+                    clone_bundle=opt.clone_bundle,
+                    tags=opt.tags,
+                    archive=project.manifest.IsArchive,
+                    optimized_fetch=opt.optimized_fetch,
+                    retry_fetches=opt.retry_fetches,
+                    prune=opt.prune,
+                    ssh_proxy=ssh_proxy,
+                    clone_filter=project.manifest.CloneFilter,
+                    partial_clone_exclude=project.manifest.PartialCloneExclude,
+                    clone_filter_for_depth=project.manifest.CloneFilterForDepth,
+                )
+                fetch_success = sync_result.success
+                remote_fetched = sync_result.remote_fetched
+                fetch_error = sync_result.error
+            except KeyboardInterrupt:
+                logger.error(
+                    "Keyboard interrupt while processing %s", project.name
+                )
+            except GitError as e:
+                fetch_error = e
+                logger.error("error.GitError: Cannot fetch %s", e)
+            except Exception as e:
+                fetch_error = e
+                logger.error(
+                    "error: Cannot fetch %s (%s: %s)",
+                    project.name,
+                    type(e).__name__,
+                    e,
+                )
+            finally:
+                fetch_finish = time.time()
+                network_output = network_output_capture.getvalue()
+
+        checkout_success = False
+        checkout_error = None
+        checkout_start = None
+        checkout_finish = None
+        checkout_stderr = ""
+
+        if fetch_success and not opt.network_only:
+            checkout_start = time.time()
+            stderr_capture = io.StringIO()
+            try:
+                with contextlib.redirect_stderr(stderr_capture):
+                    syncbuf = SyncBuffer(
+                        project.manifest.manifestProject.config,
+                        detach_head=opt.detach_head,
+                    )
+                    local_half_errors = []
+                    project.Sync_LocalHalf(
+                        syncbuf,
+                        force_sync=opt.force_sync,
+                        force_checkout=opt.force_checkout,
+                        force_rebase=opt.rebase,
+                        errors=local_half_errors,
+                        verbose=opt.verbose,
+                    )
+                    checkout_success = syncbuf.Finish()
+                    if local_half_errors:
+                        checkout_error = SyncError(
+                            aggregate_errors=local_half_errors
+                        )
+            except KeyboardInterrupt:
+                logger.error(
+                    "Keyboard interrupt while processing %s", project.name
+                )
+            except GitError as e:
+                checkout_error = e
+                logger.error(
+                    "error.GitError: Cannot checkout %s: %s", project.name, e
+                )
+            except Exception as e:
+                checkout_error = e
+                logger.error(
+                    "error: Cannot checkout %s: %s: %s",
+                    project.name,
+                    type(e).__name__,
+                    e,
+                )
+            finally:
+                checkout_finish = time.time()
+                checkout_stderr = stderr_capture.getvalue()
+        elif fetch_success:
+            checkout_success = True
+
+        # Consolidate all captured output.
+        captured_parts = []
+        if network_output:
+            captured_parts.append(network_output)
+        if checkout_stderr:
+            captured_parts.append(checkout_stderr)
+        stderr_text = "\n".join(captured_parts)
+
+        return _SyncResult(
+            project_index=project_index,
+            relpath=project.relpath,
+            fetch_success=fetch_success,
+            remote_fetched=remote_fetched,
+            checkout_success=checkout_success,
+            fetch_error=fetch_error,
+            checkout_error=checkout_error,
+            stderr_text=stderr_text.strip(),
+            fetch_start=fetch_start,
+            fetch_finish=fetch_finish,
+            checkout_start=checkout_start,
+            checkout_finish=checkout_finish,
         )
 
-        # Update and log with the new sync analysis state.
-        mp.config.UpdateSyncAnalysisState(opt, superproject_logging_data)
-        self.git_event_log.LogDataConfigEvents(
-            mp.config.GetSyncAnalysisStateData(), "current_sync_state"
+    @classmethod
+    def _SyncProjectList(cls, opt, project_indices) -> _InterleavedSyncResult:
+        """Worker for interleaved sync.
+
+        This function is responsible for syncing a group of projects that share
+        a git object directory.
+
+        Args:
+            opt: Program options returned from optparse.  See _Options().
+            project_indices: A list of indices into the projects list stored in
+                the parallel context.
+
+        Returns:
+            An `_InterleavedSyncResult` containing the results for each project.
+        """
+        results = []
+        context = cls.get_parallel_context()
+        projects = context["projects"]
+        sync_dict = context["sync_dict"]
+
+        assert project_indices, "_SyncProjectList called with no indices."
+
+        # Use the first project as the representative for the progress bar.
+        first_project = projects[project_indices[0]]
+        key = f"{first_project.name} @ {first_project.relpath}"
+        sync_dict[key] = time.time()
+
+        try:
+            for idx in project_indices:
+                project = projects[idx]
+                results.append(cls._SyncOneProject(opt, idx, project))
+        finally:
+            del sync_dict[key]
+
+        return _InterleavedSyncResult(results=results)
+
+    def _ProcessSyncInterleavedResults(
+        self,
+        synced_relpaths: Set[str],
+        err_event: _threading.Event,
+        errors: List[Exception],
+        opt: optparse.Values,
+        pool: Optional[multiprocessing.Pool],
+        pm: Progress,
+        results_sets: List[_InterleavedSyncResult],
+    ):
+        """Callback to process results from interleaved sync workers."""
+        ret = True
+        projects = self.get_parallel_context()["projects"]
+        for result_group in results_sets:
+            for result in result_group.results:
+                pm.update()
+                project = projects[result.project_index]
+
+                if opt.verbose and result.stderr_text:
+                    pm.display_message(result.stderr_text)
+
+                if result.fetch_start:
+                    self._fetch_times.Set(
+                        project,
+                        result.fetch_finish - result.fetch_start,
+                    )
+                    self._local_sync_state.SetFetchTime(project)
+                    self.event_log.AddSync(
+                        project,
+                        event_log.TASK_SYNC_NETWORK,
+                        result.fetch_start,
+                        result.fetch_finish,
+                        result.fetch_success,
+                    )
+                if result.checkout_start:
+                    if result.checkout_success:
+                        self._local_sync_state.SetCheckoutTime(project)
+                    self.event_log.AddSync(
+                        project,
+                        event_log.TASK_SYNC_LOCAL,
+                        result.checkout_start,
+                        result.checkout_finish,
+                        result.checkout_success,
+                    )
+
+                if result.fetch_success and result.checkout_success:
+                    synced_relpaths.add(result.relpath)
+                else:
+                    ret = False
+                    err_event.set()
+                    if result.fetch_error:
+                        errors.append(result.fetch_error)
+                        self._interleaved_err_network = True
+                        self._interleaved_err_network_results.append(
+                            result.relpath
+                        )
+                    if result.checkout_error:
+                        errors.append(result.checkout_error)
+                        self._interleaved_err_checkout = True
+                        self._interleaved_err_checkout_results.append(
+                            result.relpath
+                        )
+
+            if not ret and opt.fail_fast:
+                if pool:
+                    pool.close()
+                break
+        return ret
+
+    def _SyncInterleaved(
+        self,
+        opt,
+        args,
+        errors,
+        manifest,
+        mp,
+        all_projects,
+        superproject_logging_data,
+    ):
+        """Sync projects by performing network and local operations in parallel.
+
+        This method processes each project (or groups of projects that share git
+        objects) independently. For each project, it performs the fetch and
+        checkout operations back-to-back. These independent tasks are run in
+        parallel.
+
+        It respects two constraints for correctness:
+        1.  Projects in nested directories (e.g. 'foo' and 'foo/bar') are
+            processed in hierarchical order.
+        2.  Projects that share git objects are processed serially to prevent
+            race conditions.
+        """
+        # Temporary state for tracking errors in interleaved mode.
+        self._interleaved_err_network = False
+        self._interleaved_err_network_results = []
+        self._interleaved_err_checkout = False
+        self._interleaved_err_checkout_results = []
+
+        err_event = multiprocessing.Event()
+        synced_relpaths = set()
+        project_list = list(all_projects)
+        pm = Progress(
+            "Syncing",
+            len(project_list),
+            delay=False,
+            quiet=opt.quiet,
+            show_elapsed=True,
+            elide=True,
         )
+        previously_pending_relpaths = set()
 
-        self._local_sync_state.PruneRemovedProjects()
-        if self._local_sync_state.IsPartiallySynced():
-            logger.warning(
-                "warning: Partial syncs are not supported. For the best "
-                "experience, sync the entire tree."
-            )
+        sync_event = _threading.Event()
+        sync_progress_thread = self._CreateSyncProgressThread(pm, sync_event)
 
-        if not opt.quiet:
-            print("repo sync has finished successfully.")
+        with multiprocessing.Manager() as manager, ssh.ProxyManager(
+            manager
+        ) as ssh_proxy:
+            ssh_proxy.sock()
+            with self.ParallelContext():
+                self.get_parallel_context()["ssh_proxy"] = ssh_proxy
+                # TODO(gavinmak): Use multprocessing.Queue instead of dict.
+                self.get_parallel_context()[
+                    "sync_dict"
+                ] = multiprocessing.Manager().dict()
+                sync_progress_thread.start()
+
+                try:
+                    # Outer loop for dynamic project discovery. This continues
+                    # until no unsynced projects remain.
+                    while True:
+                        projects_to_sync = [
+                            p
+                            for p in project_list
+                            if p.relpath not in synced_relpaths
+                        ]
+                        if not projects_to_sync:
+                            break
+
+                        pending_relpaths = {p.relpath for p in projects_to_sync}
+                        if previously_pending_relpaths == pending_relpaths:
+                            logger.error(
+                                "Stall detected in interleaved sync, not all "
+                                "projects could be synced."
+                            )
+                            err_event.set()
+                            break
+                        previously_pending_relpaths = pending_relpaths
+
+                        self.get_parallel_context()[
+                            "projects"
+                        ] = projects_to_sync
+                        project_index_map = {
+                            p: i for i, p in enumerate(projects_to_sync)
+                        }
+
+                        # Inner loop to process projects in a hierarchical
+                        # order. This iterates through levels of project
+                        # dependencies (e.g. 'foo' then 'foo/bar'). All projects
+                        # in one level can be processed in parallel, but we must
+                        # wait for a level to complete before starting the next.
+                        for level_projects in _SafeCheckoutOrder(
+                            projects_to_sync
+                        ):
+                            if not level_projects:
+                                continue
+
+                            objdir_project_map = collections.defaultdict(list)
+                            for p in level_projects:
+                                objdir_project_map[p.objdir].append(
+                                    project_index_map[p]
+                                )
+
+                            work_items = list(objdir_project_map.values())
+                            if not work_items:
+                                continue
+
+                            jobs = max(1, min(opt.jobs, len(work_items)))
+                            callback = functools.partial(
+                                self._ProcessSyncInterleavedResults,
+                                synced_relpaths,
+                                err_event,
+                                errors,
+                                opt,
+                            )
+                            if not self.ExecuteInParallel(
+                                jobs,
+                                functools.partial(self._SyncProjectList, opt),
+                                work_items,
+                                callback=callback,
+                                output=pm,
+                                chunksize=1,
+                            ):
+                                err_event.set()
+
+                            if err_event.is_set() and opt.fail_fast:
+                                raise SyncFailFastError(aggregate_errors=errors)
+
+                        self._ReloadManifest(None, manifest)
+                        project_list = self.GetProjects(
+                            args,
+                            missing_ok=True,
+                            submodules_ok=opt.fetch_submodules,
+                            manifest=manifest,
+                            all_manifests=not opt.this_manifest_only,
+                        )
+                finally:
+                    sync_event.set()
+                    sync_progress_thread.join()
+
+        pm.end()
+
+        err_update_projects, err_update_linkfiles = self._UpdateManifestLists(
+            opt, err_event, errors
+        )
+        if not self.outer_client.manifest.IsArchive:
+            self._GCProjects(project_list, opt, err_event)
+
+        self._PrintManifestNotices(opt)
+        if err_event.is_set():
+            self._ReportErrors(
+                errors,
+                err_network_sync=self._interleaved_err_network,
+                failing_network_repos=self._interleaved_err_network_results,
+                err_checkout=self._interleaved_err_checkout,
+                failing_checkout_repos=self._interleaved_err_checkout_results,
+                err_update_projects=err_update_projects,
+                err_update_linkfiles=err_update_linkfiles,
+            )
 
 
 def _PostRepoUpgrade(manifest, quiet=False):
diff --git a/subcmds/upload.py b/subcmds/upload.py
index bac2f8ac..4f817ddf 100644
--- a/subcmds/upload.py
+++ b/subcmds/upload.py
@@ -267,7 +267,6 @@ Gerrit Code Review:  https://www.gerritcodereview.com/
             "--cc",
             type="string",
             action="append",
-            dest="cc",
             help="also send email to these email addresses",
         )
         p.add_option(
@@ -281,7 +280,6 @@ Gerrit Code Review:  https://www.gerritcodereview.com/
         p.add_option(
             "-c",
             "--current-branch",
-            dest="current_branch",
             action="store_true",
             help="upload current git branch",
         )
@@ -310,7 +308,6 @@ Gerrit Code Review:  https://www.gerritcodereview.com/
             "-p",
             "--private",
             action="store_true",
-            dest="private",
             default=False,
             help="upload as a private change (deprecated; use --wip)",
         )
@@ -318,7 +315,6 @@ Gerrit Code Review:  https://www.gerritcodereview.com/
             "-w",
             "--wip",
             action="store_true",
-            dest="wip",
             default=False,
             help="upload as a work-in-progress change",
         )
@@ -628,6 +624,16 @@ Gerrit Code Review:  https://www.gerritcodereview.com/
                 branch.uploaded = False
                 return
 
+        # If using superproject, add the root repo as a push option.
+        manifest = branch.project.manifest
+        push_options = list(opt.push_options)
+        if manifest.manifestProject.use_superproject:
+            sp = manifest.superproject
+            if sp:
+                r_id = sp.repo_id
+                if r_id:
+                    push_options.append(f"custom-keyed-value=rootRepo:{r_id}")
+
         branch.UploadForReview(
             people,
             dryrun=opt.dryrun,
@@ -640,7 +646,7 @@ Gerrit Code Review:  https://www.gerritcodereview.com/
             ready=opt.ready,
             dest_branch=destination,
             validate_certs=opt.validate_certs,
-            push_options=opt.push_options,
+            push_options=push_options,
             patchset_description=opt.patchset_description,
         )