@@ -374,7 +374,7 @@ and predate the current fallback; they do not establish native coverage.
 | Worktree inventory, `worktree list` | Main and linked worktree metadata, including bare main repositories and locks | Prunable entries; GIX-14 |
 | `Repo.merge_base`, `Repo.is_ancestor` | Native graph queries for two revisions | Octopus/fork-point and other options |
 | `Commit.count` | Reachable commit count, skip/limit/first-parent | Path filters and other revision options |
-| `Commit.iter_items`, `Repo.iter_commits` | First-parent walks and a single tip | General history ordering; GIX-8 |
+| `Commit.iter_items`, `Repo.iter_commits` | First-parent walks and a single tip | Reflog walks, general history ordering; GIX-8 |
 | Index entry reads, `ls_files` | Stage/mode/OID/path and exposed index flags | Custom and sparse indexes; GIX-3/4 |
 | `IndexFile.version`, `update_index` query | Native index version | Actual `update-index` mutations |
 | Index editing and `IndexFile.write` | Opaque byte snapshots; atomic locked publication | Private-file edits always use Git: arbitrary native index loading and strict pathname validation are missing; GIX-3/4/13/26 |
@@ -392,6 +392,25 @@ and predate the current fallback; they do not establish native coverage.
 | `Repo.untracked_files` | Native directory walk | Extra status options and non-root command directories |
 | `Repo.ignored` | Native excludes with tracked-file suppression | Symlink/submodule traversal, unsupported path normalization, and unavailable path metadata |
 
+Revision APIs preserve a reference object's validated full name. The shared
+`Git._check_revision()` first uses the exact reference reader to verify existence
+and the symbolic-reference chain; it passes the full name rather than the resolved
+object ID. Strings retain Git's name guessing, and commit objects retain their IDs.
+This prevents same-named tags from replacing branches without losing the ref
+identity needed by reflog walks, fork-point lookups and remote archives.
+`merge_base()` validates nested list/tuple operands before string conversion.
+`exact-refs.sh` covers these paths with shadowing tags and missing references in
+SHA-1/SHA-256 and files/reftable repositories on both backends.
+
+These name-sensitive operations retain CLI fallback. GixPython 0.3.0's
+`Repository.rev_walk()` has no Git-compatible reflog-walk mode,
+`Repository.merge_base()` exposes graph merge bases rather than reflog-based
+fork-point selection, and no upload-archive client API is exposed. The regressions
+compare Git 2.54.0's reflog history, old fork point after an upstream rewind,
+and default upload-archive server behavior, which rejects literal object IDs.
+Native replacements must expose matching reflog walking and fork-point selection
+and the upload-archive protocol; no Python implementation substitutes for them.
+
 Reference reads require an exact name, unlike revision APIs that intentionally
 apply Git's name guessing. `reference_info()` uses
 `Repository.try_find_reference()` and verifies the returned name for `HEAD` and
 
@@ -60,9 +60,11 @@ API changes
   APIs such as ``Repo.commit(rev)`` retain Git's name guessing for strings.
   A reference object passed as a revision, for example to ``Repo.commit()``,
   ``Repo.iter_commits()``, ``Repo.merge_base()``, ``IndexFile.from_tree()`` or
-  ``HEAD.reset()``, is read by its exact name, so a tag named like a branch or
-  remote-tracking branch no longer takes its place. A missing reference raises
-  ``ValueError``, as its ``object`` property does.
+  ``HEAD.reset()``, is validated by its exact name and passed using its full ref
+  name, so a tag named like a branch or remote-tracking branch no longer takes
+  its place. The ref name also preserves reflog walks, fork-point lookups and
+  remote archives. A missing reference raises ``ValueError``, as its ``object``
+  property does.
 * Packed tag names containing non-UTF-8 bytes are represented losslessly as
   surrogate-escaped strings. ``safe_encode()`` recovers their original bytes,
   and Gix reference validation and resolution receive those bytes directly.
 
@@ -1025,17 +1025,20 @@ def _check_operand(value: Any, label: str = "operand") -> str:
 
     @staticmethod
     def _check_revision(value: Any, label: str = "revision") -> str:
-        """Validate a revision, passing a reference object as the object ID it holds.
+        """Validate a revision, preserving a reference object's full name.
 
         A reference converts to its short name, for which Git's revision lookup tries
         other references, such as a same-named tag, before ``refs/heads/`` and
-        ``refs/remotes/``. Read the exact reference instead, as
-        ``SymbolicReference.object`` does.
+        ``refs/remotes/``. Verify the exact reference exists before passing its full
+        name, retaining its identity for reflog walks and remote archives.
         """
         from git.refs.symbolic import SymbolicReference
 
         if isinstance(value, SymbolicReference):
-            value = value.dereference_recursive(value.repo, value.path)
+            value.dereference_recursive(value.repo, value.path)
+            value = value.path
+        if isinstance(value, os.PathLike):
+            value = os.fsdecode(value)
         return Git._check_operand(value, label)
 
     def _require_version(self) -> None:
 
@@ -1029,12 +1029,18 @@ def merge_base(self, *rev: TBD, allow_unsafe_options: bool = False, **kwargs: An
                 options=Git._option_candidates(rev, kwargs), unsafe_options=self.unsafe_git_revision_options
             )
 
-        # Resolve reference objects before flattening turns them into short names.
-        revs = [item if isinstance(item, (list, tuple)) else Git._check_revision(item) for item in rev]
+        def checked_revisions(items: Sequence[Any]) -> Iterator[str]:
+            # Preserve reference objects until each flattened operand is validated.
+            for item in items:
+                if isinstance(item, (list, tuple)):
+                    yield from checked_revisions(item)
+                else:
+                    yield Git._check_revision(item)
+
         res: List[Commit] = []
         try:
             lines: List[str] = self.git._call_process_safe(
-                "merge_base", "--", *(Git._check_operand(item, "revision") for item in Git._unpack_args(revs)), **kwargs
+                "merge_base", "--", *checked_revisions(rev), **kwargs
             ).splitlines()
         except GitCommandError as err:
             if err.status != 1:
 
@@ -259,6 +259,102 @@ def test_reference_arguments_do_not_resolve_same_named_tags(object_format, ref_f
             assert repo.index.write_tree() == local.tree
 
 
+@pytest.mark.parametrize("object_format", ["sha1", "sha256"])
+@pytest.mark.parametrize("ref_format", ["files", "reftable"])
+def test_merge_base_preserves_nested_reference_arguments(object_format, ref_format):
+    with fixture_repo("exact-refs.sh", object_format, ref_format, "shadowed") as repo:
+        for ref in (repo.heads.main, RemoteReference(repo, "refs/remotes/origin/main")):
+            for left, right in (([ref], ref), (([ref],), ref), (ref, [ref]), ([ref.path], (ref.path,))):
+                assert repo.merge_base(left, right) == [ref.commit]
+
+
+@pytest.mark.parametrize("object_format", ["sha1", "sha256"])
+@pytest.mark.parametrize("ref_format", ["files", "reftable"])
+@pytest.mark.parametrize("path_type", [Path, PathLikeMock])
+def test_revision_arguments_preserve_pathlike_paths(object_format, ref_format, path_type):
+    with fixture_repo("exact-refs.sh", object_format, ref_format, "shadowed") as repo:
+        local = repo.head.commit
+        for name in ("HEAD", "refs/heads/main", "refs/remotes/origin/main"):
+            path = path_type(name)
+            ref = SymbolicReference(repo, path)
+            assert repo.commit(ref) == ref.object == local
+            assert repo.merge_base(ref, local) == [local]
+            assert repo.merge_base(path, local) == [local]
+            assert repo.merge_base(([path],), [local]) == [local]
+
+
+@pytest.mark.parametrize("revision", ["HEAD", "--all", "HEAD\0", "HEAD\r", "HEAD\n"])
+@pytest.mark.parametrize("as_bytes", [False, True])
+def test_check_revision_normalizes_pathlike_before_validation(revision, as_bytes):
+    path = Mock(spec=os.PathLike, __fspath__=Mock(return_value=os.fsencode(revision) if as_bytes else revision))
+    if revision == "HEAD":
+        assert Git._check_revision(path) == revision
+    else:
+        with pytest.raises(UnsafeOptionError, match="Invalid revision"):
+            Git._check_revision(path)
+
+
+@pytest.mark.parametrize("object_format", ["sha1", "sha256"])
+@pytest.mark.parametrize("ref_format", ["files", "reftable"])
+def test_revision_arguments_validate_missing_references(object_format, ref_format):
+    with fixture_repo("exact-refs.sh", object_format, ref_format) as repo:
+        for path in ("refs/heads/unborn", "REBASE_HEAD"):
+            ref = SymbolicReference(repo, path)
+            foreign = repo.tags[path].commit
+            assert repo.git.rev_parse("--verify", path) == foreign.hexsha
+            with pytest.raises(ValueError, match="does not exist or is invalid"):
+                repo.commit(ref)
+            with pytest.raises(ValueError, match="does not exist or is invalid"):
+                repo.merge_base([ref], foreign)
+
+
+@pytest.mark.parametrize("object_format", ["sha1", "sha256"])
+@pytest.mark.parametrize("ref_format", ["files", "reftable"])
+def test_reflog_walk_preserves_reference_names(object_format, ref_format):
+    with fixture_repo("exact-refs.sh", object_format, ref_format, "reflog") as repo:
+        for ref in (repo.heads.main, RemoteReference(repo, "refs/remotes/origin/main"), repo.head):
+            expected = repo.git.rev_list("--walk-reflogs", ref.path, "--").splitlines()
+            assert len(expected) >= 2
+            for options in ({"walk_reflogs": True}, {"walk-reflogs": True}):
+                assert [commit.hexsha for commit in repo.iter_commits(ref, **options)] == expected
+                assert [commit.hexsha for commit in Commit.iter_items(repo, ref, max_count=1, **options)] == expected[
+                    :1
+                ]
+        with pytest.raises(ValueError, match="does not exist or is invalid"):
+            list(repo.iter_commits(SymbolicReference(repo, "REBASE_HEAD"), walk_reflogs=True))
+
+
+@pytest.mark.parametrize("object_format", ["sha1", "sha256"])
+@pytest.mark.parametrize("ref_format", ["files", "reftable"])
+def test_fork_point_preserves_upstream_reference_name(object_format, ref_format):
+    with fixture_repo("exact-refs.sh", object_format, ref_format, "reflog") as repo:
+        topic = repo.heads.topic
+        old_tip = topic.commit.parents[0]
+        for upstream in (repo.heads.main, RemoteReference(repo, "refs/remotes/origin/main")):
+            assert repo.merge_base(upstream, topic) == [upstream.commit]
+            assert repo.git.merge_base("--fork-point", upstream.path, topic.path) == old_tip.hexsha
+            for options in ({"fork_point": True}, {"fork_p": True}):
+                assert repo.merge_base(upstream, topic, **options) == [old_tip]
+        with pytest.raises(ValueError, match="does not exist or is invalid"):
+            repo.merge_base(SymbolicReference(repo, "REBASE_HEAD"), topic, fork_point=True)
+
+
+@pytest.mark.parametrize("object_format", ["sha1", "sha256"])
+@pytest.mark.parametrize("ref_format", ["files", "reftable"])
+def test_remote_archive_preserves_reference_name(object_format, ref_format):
+    with fixture_repo("exact-refs.sh", object_format, ref_format, "shadowed") as repo:
+        for ref in (repo.heads.main, RemoteReference(repo, "refs/remotes/origin/main"), repo.head):
+            expected = io.BytesIO()
+            repo.git.archive("--remote=" + repo.git_dir, ref.path, output_stream=expected)
+            stream = io.BytesIO()
+            repo.archive(stream, ref, remote=repo.git_dir)
+            assert stream.getvalue() == expected.getvalue()
+            with tarfile.open(fileobj=io.BytesIO(stream.getvalue())) as archive:
+                assert archive.getnames() == ["file"]
+        with pytest.raises(ValueError, match="does not exist or is invalid"):
+            repo.archive(io.BytesIO(), SymbolicReference(repo, "REBASE_HEAD"), remote=repo.git_dir)
+
+
 @pytest.mark.parametrize("object_format", ["sha1", "sha256"])
 @pytest.mark.parametrize("ref_format", ["files", "reftable"])
 def test_rebase_detection_ignores_tag_named_rebase_head(object_format, ref_format):
 
@@ -15,7 +15,7 @@ git -C repo fetch ../source 'refs/tags/*:refs/tags/*'
 if [ "${3-}" = symbolic ]; then
     git -C repo symbolic-ref refs/tags/REBASE_HEAD refs/tags/refs/heads/unborn
 fi
-if [ "${3-}" = shadowed ]; then
+if [ "${3-}" = shadowed ] || [ "${3-}" = reflog ]; then
     # Fetched tags share the short names of a local branch and a remote-tracking branch.
     git -C repo fetch ../source 'refs/heads/main:refs/tags/main' 'refs/heads/main:refs/tags/origin/main'
     blob=$(printf 'local\n' | git -C repo hash-object -w --stdin)
@@ -25,6 +25,16 @@ if [ "${3-}" = shadowed ]; then
         git -C repo update-ref "$path" "$commit"
     done
     git -C repo symbolic-ref HEAD refs/heads/main
+    if [ "${3-}" = reflog ]; then
+        old_tip=$(git -C repo commit-tree -p "$commit" -m 'Old tip' "$tree")
+        topic=$(git -C repo commit-tree -p "$old_tip" -m 'Topic history' "$tree")
+        git -C repo update-ref refs/heads/topic "$topic"
+        git -C repo tag topic refs/tags/main
+        for path in refs/heads/main refs/remotes/origin/main; do
+            git -C repo update-ref --create-reflog -m 'Advance upstream' "$path" "$old_tip"
+            git -C repo update-ref -m 'Rewind upstream' "$path" "$commit"
+        done
+    fi
 fi
 if [ "${3-}" = existing ]; then
     commit=$(git -C source rev-parse HEAD)