@@ -86,9 +86,9 @@ cache/
     a marker object: while it is present, the chunks index in ``index/`` is considered
     invalid, because its fragments may be missing entries or point at deleted packs.
     It is written before deleting index fragments, before a single-object delete removes
-    the old pack, and before ``borg check --repair`` rebuilds the index after changing
-    the packs. It is removed after the last fragment is deleted or once the complete
-    current index is stored.
+    the old pack, and by ``borg check --repair`` after storing packs, before it re-reads
+    them and stores the index. It is removed after the last fragment is deleted or once
+    the complete current index is stored.
 
 Note that this ``cache/`` namespace is inside the repository (and thus shared by
 all clients); it is not the client-local cache described in
 
@@ -323,12 +323,12 @@ A deletion that could drop entries -- dropping the index entirely, or the full r
 above -- is guarded by a marker object, ``cache/chunkindex-invalid``, written before
 the first deletion and removed after the last one. A single-object delete writes the
 marker just before it removes the old pack, and ``borg check --repair`` writes it
-before rebuilding the index after changing the packs; both remove it once the index
-is stored. While the marker is present, the fragments may be missing entries or point
-at deleted packs, so they are not merged; the index is rebuilt from the pack files on
-the next load instead. A consolidation needs no marker: the entries of the small
-fragments it deletes are already contained in the merged fragments it wrote before
-deleting them.
+after storing packs, before it re-reads them and stores the index; both remove it
+once the index is stored. While the marker is present, the fragments may be missing
+entries or point at deleted packs, so they are not merged; the index is rebuilt from
+the pack files on the next load instead. A consolidation needs no marker: the entries
+of the small fragments it deletes are already contained in the merged fragments it
+wrote before deleting them.
 
 If the entire ``index/`` namespace is lost or corrupt, the ChunkIndex can be rebuilt
 by scanning pack files directly; see :ref:`pack-recovery`.
 
@@ -2237,22 +2237,25 @@ class ArchiveChecker:
     def __init__(self):
         self.error_found = False
         self.key = None
-        # True once repair wrote a pack: it stored a chunk or deleted a defect chunk.
+        # True once repair changed the packs: it stored a chunk or deleted a defect chunk.
         self.chunks_modified = False
-        # ids of the existing packs repair stored (put(), flush()) or wrote by rewriting a pack (delete()).
+        # ids of the packs repair wrote: stored by put() and flush(), or written by delete() rewriting a pack.
         self.written_packs = set()
 
     def record_stored(self, results):
         """Add the pack ids in results to written_packs.
 
-        results: the (chunk_id, pack_id, obj_offset, obj_size) tuples Repository.put() or .flush() returns
-        for the packs it stored, or None if it stored no pack.
+        results: (chunk_id, pack_id, obj_offset, obj_size) tuples of the objects in the stored packs, as
+        Repository.put() and flush() return them, or None.
         """
         if results:
             self.written_packs.update(pack_id for _, pack_id, _, _ in results)
 
     def create_archive_entry(self, name, id, ts):
-        """Store the pack writer buffer, record the packs it wrote, create the archives directory entry."""
+        """Store the pack writer buffer, record the packs it wrote, create the archives directory entry.
+
+        Archives.create() stores the pack writer buffer too, but does not return the packs it wrote.
+        """
         self.record_stored(self.repository.flush())
         self.manifest.archives.create(name, id, ts)
 
@@ -2311,7 +2314,8 @@ def check(
         self.repo_objs = RepoObj(self.key)
         validate = object_validator(self.repo_objs)
         # store the chunks buffered in the pack writer, so the index below has their pack locations
-        # (pack id, offset and size in the pack).
+        # (pack id, offset and size in the pack). The result is ignored: written_packs holds only the packs
+        # the repair writes.
         self.repository.flush()
         if not repair and self.repository.is_chunk_index_loaded:
             # without --repair, use the loaded index.
@@ -2440,11 +2444,11 @@ def verify_data(self):
                         # keeping the other chunks, and removes it from self.chunks, so rebuild_archives
                         # reports the file it belongs to. update_index=False: finish() stores the index
                         # and clears the invalid marker delete() writes.
-                        # new_pack_id holds the other objects of the old pack, None if there were none.
                         old_pack_id = self.chunks[defect_chunk].pack_id
+                        # new_pack_id: the pack holding the other objects of the old pack, None if there were none.
                         new_pack_id, _ = self.repository.delete(defect_chunk, update_index=False, validate=validate)
                         self.chunks_modified = True
-                        self.written_packs.discard(old_pack_id)
+                        self.written_packs.discard(old_pack_id)  # delete() removed the old pack
                         if new_pack_id is not None:
                             self.written_packs.add(new_pack_id)
                     else:
@@ -2813,48 +2817,61 @@ def valid_item(obj):
     def verify_written_packs(self):
         """Read the object headers of the packs in written_packs and make the chunks index match them.
 
-        put() and delete() compute the index entries of the packs they write without reading the packs.
+        put() and delete() compute the index entries of the packs they write from the data they write.
         This compares the (chunk_id, obj_offset, obj_size) of each object header in a written pack, read
-        with a validator, with the index entries that name the pack. Each difference is a check finding,
-        logged and fixed in the index:
+        with a validator, with the index entries that name the pack. Each difference sets error_found, is
+        logged and is fixed in the index:
 
         - an index entry names an object the pack does not hold: the entry is removed.
         - the pack holds an object whose chunk id is not indexed: the object is indexed.
         - the pack does not exist: its index entries are removed.
 
-        An object whose chunk id is indexed at another location is a superseded duplicate, not a finding: a
-        pack delete() wrote can hold one, in a byte range compact_pack copied with no index entry covering it.
+        A superseded duplicate is an object whose chunk id is indexed at another location. It is logged at
+        debug level. A pack delete() wrote holds one if compact_pack copied a byte range that no index entry
+        covers.
         """
         pack_ids = sorted(self.written_packs)
         if not pack_ids:
             return
-        logger.info(f"Re-reading the packs written by the repair: {len(pack_ids)}.")
+        logger.info(f"Re-reading {len(pack_ids)} pack(s) written by the repair.")
         # (chunk_id, obj_offset, obj_size) of the index entries, per written pack.
         indexed = {pack_id: set() for pack_id in pack_ids}
         for chunk_id, entry in self.chunks.iteritems():
             entries = indexed.get(entry.pack_id)
             if entries is not None:
                 entries.add((chunk_id, entry.obj_offset, entry.obj_size))
         validate = object_validator(self.repo_objs)
+        # pass 1 removes the index entries of every pack before pass 2 indexes any object, so whether an object
+        # is unindexed does not depend on the order the packs are read in.
+        found_in = {}  # pack_id -> (chunk_id, obj_offset, obj_size) of the objects in the pack
+        not_found_in = {}  # pack_id -> sorted index entries naming an object the pack does not hold
         for pack_id in pack_ids:
             # PackReader reads from the store, which does not refresh the repository lock.
             self.repository._lock_refresh()
-            pack_hex = bin_to_hex(pack_id)
-            expected = indexed.pop(pack_id)
-            reader = PackReader(self.repository.store, pack_id)
-            # iter_headers() yields nothing for a missing pack: the store reports size 0 for it.
-            if not self.repository.store.info(reader.key).exists:
+            expected = indexed[pack_id]
+            key = "packs/" + bin_to_hex(pack_id)
+            info = self.repository.store.info(key)
+            if not info.exists:
                 self.error_found = True
-                logger.error(f"pack {pack_hex}: written by the repair, but it is missing. Removing its index entries.")
+                logger.error(
+                    f"pack {bin_to_hex(pack_id)}: written by the repair, but it is missing. Removing its index entries."
+                )
                 for chunk_id, _, _ in expected:
                     del self.chunks[chunk_id]
                 continue
+            reader = PackReader(self.repository.store, pack_id, pack_size=info.size)
             found = list(reader.iter_headers(validate=validate, on_drop=self.note_dropped_objects))
             not_found = sorted(expected.difference(found))
             for chunk_id, _, _ in not_found:
                 del self.chunks[chunk_id]
-            # the loop indexes each unindexed object, so of several unindexed copies of a chunk, the first
-            # is indexed and the others are superseded duplicates.
+            found_in[pack_id] = found
+            not_found_in[pack_id] = not_found
+        # pass 2 indexes each unindexed object, so of several unindexed copies of a chunk, the first in pack id and
+        # offset order is indexed and the others are superseded duplicates.
+        for pack_id, found in found_in.items():
+            pack_hex = bin_to_hex(pack_id)
+            expected = indexed[pack_id]
+            not_found = not_found_in[pack_id]
             unindexed = []
             for obj in found:
                 chunk_id, obj_offset, obj_size = obj
@@ -2874,6 +2891,8 @@ def verify_written_packs(self):
             if not (not_found or unindexed):
                 continue
             self.error_found = True
+            # an object the pack holds whose index entry has a wrong offset or size counts in both numbers,
+            # unless pass 2 indexed another copy of it first.
             logger.error(
                 f"pack {pack_hex}: the chunks index does not match the pack. Indexed objects not in the pack: "
                 f"{len(not_found)}, objects in the pack with an unindexed chunk id: {len(unindexed)}. "
@@ -2892,13 +2911,13 @@ def finish(self):
         if self.repair:
             # store the pack writer buffer before the index is written (close() requires an empty buffer, #10055).
             self.record_stored(self.repository.flush())
-            if self.chunks_modified:
-                # the index/ fragments do not have the chunks this repair stored.
+            if self.chunks_modified or self.written_packs:
+                # the index/ fragments lack the pack changes of this repair.
                 write_chunkindex_invalid(self.repository)
                 # Runs to completion, also after a Ctrl-C: delete_chunkindex_invalid() below declares the
                 # stored index to match the packs, which holds only once every written pack was re-read.
                 self.verify_written_packs()
-            logger.info("Writing the rebuilt repository chunks index.")
+            logger.info("Writing the repository chunks index.")
             write_chunkindex_to_repo(
                 self.repository, self.chunks, incremental=False, clear=False, force_write=True, delete_other=True
             )
 
@@ -609,7 +609,7 @@ def write_chunkindex_invalid(repository):
     """Store the invalid marker, cache/chunkindex-invalid.
 
     Store it before deleting index/ fragments whose entries no other fragment holds, before deleting a pack
-    the fragments point at, and before rebuilding the index after pack changes the fragments do not record.
+    the fragments point at, and after storing packs the fragments do not record.
     While it is present, build_chunkindex_from_repo rebuilds the index from the packs instead of merging the
     fragments.
     """
 
@@ -406,14 +406,16 @@ def flush(self):
 class PackReader:
     """Reads pack files, the read-side counterpart to PackWriter.
 
-    Pass pack_id to read from the store, or pack_contents for a pack already in memory.
+    Pass pack_id to read from the store, or pack_contents for a pack already in memory. pack_size, if given,
+    is the size of the pack in the store, so size() does not look it up.
     """
 
-    def __init__(self, store=None, pack_id=None, pack_contents=None):
+    def __init__(self, store=None, pack_id=None, pack_contents=None, pack_size=None):
         self.store = store
         self.pack_id = pack_id
         self.key = "packs/" + bin_to_hex(pack_id) if pack_id is not None else None
         self.pack_contents = pack_contents
+        self.pack_size = pack_size
         self.headers_parsed = 0  # headers _parse_header accepted in the last iter_headers walk
 
     def read(self, offset, size):
@@ -423,9 +425,11 @@ def read(self, offset, size):
         return self.store.load(self.key, offset=offset, size=size)
 
     def size(self):
-        """Return the pack size in bytes (a store metadata lookup, unless the pack is in memory)."""
+        """Return the pack size in bytes (a store metadata lookup, unless the pack is in memory or pack_size is set)."""
         if self.pack_contents is not None:
             return len(self.pack_contents)
+        if self.pack_size is not None:
+            return self.pack_size
         return self.store.info(self.key).size
 
     @staticmethod
@@ -498,8 +502,8 @@ def iter_headers(self, validate=None, on_drop=None):
         """Yield (chunk_id, offset, size) for each object by walking the fixed object headers.
 
         The walk reads one range per object (or a slice, for a pack in memory), plus one store
-        metadata lookup for the pack size. Fewer than a header's bytes left ends the walk: that is
-        the end of the pack.
+        metadata lookup for the pack size unless pack_size is set. Fewer than a header's bytes left
+        ends the walk: that is the end of the pack.
 
         validate(chunk_id, obj) tells whether obj - an object's header and metadata slot - is the
         repo object with id chunk_id. Given one, the walk validates every header, reading the
@@ -1381,10 +1385,12 @@ def check(self, repair=False, max_duration=0, max_age=0, repo_only=False, valida
         continuing. A read-only check never rebuilds the index: reading every pack to do so would be
         far too slow and expensive for a routine (e.g. cron) check. With repair=True and a corrupt
         index, and if every pack is intact, the index is rebuilt from the packs' object headers and
-        persisted. Packs are verified by the store hash, which is content-addressing rather than a MAC, so
-        that check detects accidental corruption but not tampering; the rebuild therefore checks every
-        object with validate, see below, refs #9901, #10026. If any pack is corrupt the index is left
-        unchanged, refs #8572, #10026. Pack ids found corrupt are kept in cache/checked-packs, refs #9696.
+        persisted; on a full check the archives phase rebuilds and re-persists it afterwards, see
+        ArchiveChecker.finish. Packs are verified by the store hash, which is content-addressing rather
+        than a MAC, so that check detects accidental corruption but not tampering; the rebuild therefore
+        checks every object with validate, see below, refs #9901, #10026. If any pack is corrupt the index
+        is left unchanged, refs #8572, #10026. Pack ids found corrupt are kept in cache/checked-packs,
+        refs #9696.
 
         A pack recorded corrupt fails the check, also on a partial run that stops before re-reaching
         it. The record clears at the check that finds the pack intact again or gone (removed by