@@ -57,7 +57,12 @@ API changes
 * Reference reads require the exact name. A missing branch no longer resolves to
   a similarly named tag, so an unborn branch's initial commit has no parent.
   A tag named ``REBASE_HEAD`` no longer reports a rebase in progress. Revision
-  APIs such as ``Repo.commit(rev)`` retain Git's name guessing.
+  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.
 * 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.
 
@@ -1023,6 +1023,21 @@ def _check_operand(value: Any, label: str = "operand") -> str:
             raise UnsafeOptionError(f"Invalid {label}: {value!r}")
         return value
 
+    @staticmethod
+    def _check_revision(value: Any, label: str = "revision") -> str:
+        """Validate a revision, passing a reference object as the object ID it holds.
+
+        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.
+        """
+        from git.refs.symbolic import SymbolicReference
+
+        if isinstance(value, SymbolicReference):
+            value = value.dereference_recursive(value.repo, value.path)
+        return Git._check_operand(value, label)
+
     def _require_version(self) -> None:
         key = None
         if self._version_info_token is not self._refresh_token:
 
@@ -261,8 +261,10 @@ def diff(
                 clusterable_short_options="46abceflmnpqrstuvwzBCDMNRW",
             )
 
-        if isinstance(other, str):
-            other = self.repo.rev_parse(Git._check_operand(other, "revision")).hexsha
+        from git.refs.symbolic import SymbolicReference
+
+        if isinstance(other, (str, SymbolicReference)):
+            other = self.repo.rev_parse(Git._check_revision(other)).hexsha
         native = _backend.tree_diff(self.repo, self, other, paths, create_patch, kwargs)
         if native is not NotImplemented:
             return native
 
@@ -280,8 +280,7 @@ def _tree_oid(self, tree: Treeish) -> str:
             tree = tree[0]
         if isinstance(tree, bytes):
             tree = tree.hex() if len(tree) == self.repo._oid_size else tree.decode("ascii")
-        value = str(tree)
-        Git._check_operand(value, "tree revision")
+        value = Git._check_revision(tree, "tree revision")
         return self.repo.git._call_process_safe("rev_parse", "--verify", "--end-of-options", value + "^{tree}")
 
     def _index_path(self) -> PathLike:
 
@@ -9,6 +9,7 @@
 
 import gitdb.typ as dbtyp
 
+from git.cmd import Git
 from git.compat import force_text
 from git.exc import WorkTreeRepositoryUnsupported
 from git.util import LazyMixin, bin_to_hex, join_path_native, stream_copy
@@ -138,7 +139,7 @@ def new(cls, repo: "Repo", id: Union[str, "Reference"]) -> AnyGitObject:
             This cannot be a ``__new__`` method as it would always call :meth:`__init__`
             with the input id which is not necessarily a binsha.
         """
-        return repo.rev_parse(str(id))
+        return repo.rev_parse(Git._check_revision(id))
 
     @classmethod
     def new_from_sha(cls, repo: "Repo", sha1: bytes) -> AnyGitObject:
 
@@ -465,8 +465,8 @@ def iter_items(
             args_list.extend(paths_tup)
         # END if paths
 
-        Git._check_operand(str(rev), "revision")
-        native = _backend.history(repo.git, str(rev), paths, kwargs)
+        rev = Git._check_revision(rev)
+        native = _backend.history(repo.git, rev, paths, kwargs)
         if native is not NotImplemented:
             return (cls(repo, hex_to_bin(oid)) for oid in native)
         proc = repo.git._call_process_safe("rev_list", rev, args_list, as_process=True, **kwargs)
 
@@ -121,7 +121,7 @@ def reset(
         # END working tree handling
 
         try:
-            oid = self.repo.rev_parse(Git._check_operand(commit, "revision")).hexsha
+            oid = self.repo.rev_parse(Git._check_revision(commit)).hexsha
             self.repo.git._call_process_safe("reset", mode, oid, "--", paths, **kwargs)
         except GitCommandError as e:
             # git nowadays may use 1 as status to indicate there are still unstaged
 
@@ -575,7 +575,7 @@ def _create(
     ) -> T_References:
         full_path = cls.to_full_path(path)
         cls._get_validated_ref_path(repo, full_path)
-        target = repo.rev_parse(str(reference)) if resolve else reference
+        target = repo.rev_parse(Git._check_revision(reference)) if resolve else reference
         ref = cls(repo, full_path)
         if force:
             ref.set_reference(target, logmsg)
 
@@ -170,7 +170,7 @@ def create(
 
         name = Git._check_operand(path, "tag")
         cls._get_validated_ref_path(repo, cls.to_full_path(name))
-        reference = Git._check_operand(reference, "revision")
+        reference = Git._check_revision(reference)
         oid = repo.rev_parse(reference).hexsha
         options = [] if allow_unsafe_options else ["--no-sign"]
         repo.git._call_process_safe("tag", *options, "--", name, oid, **kwargs)
 
@@ -909,7 +909,7 @@ def commit(self, rev: Union[str, Commit_ish, None] = None) -> Commit:
         """
         if rev is None:
             return self.head.commit
-        return to_commit(self.rev_parse(str(rev)))
+        return to_commit(self.rev_parse(Git._check_revision(rev)))
 
     def iter_trees(self, *args: Any, **kwargs: Any) -> Iterator["Tree"]:
         """:return: Iterator yielding :class:`~git.objects.tree.Tree` objects
@@ -939,7 +939,7 @@ def tree(self, rev: Union[Tree_ish, str, None] = None) -> "Tree":
         """
         if rev is None:
             return self.head.commit.tree
-        obj = self.rev_parse(str(rev))
+        obj = self.rev_parse(Git._check_revision(rev))
         if obj.type == "tree":
             obj.path = getattr(obj, "path", "")
             return obj
@@ -1029,10 +1029,12 @@ 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]
         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(rev)), **kwargs
+                "merge_base", "--", *(Git._check_operand(item, "revision") for item in Git._unpack_args(revs)), **kwargs
             ).splitlines()
         except GitCommandError as err:
             if err.status != 1:
@@ -1065,8 +1067,8 @@ def is_ancestor(self, ancestor_rev: Commit, rev: Commit) -> bool:
                 "merge_base",
                 "--is-ancestor",
                 "--",
-                Git._check_operand(ancestor_rev, "revision"),
-                Git._check_operand(rev, "revision"),
+                Git._check_revision(ancestor_rev),
+                Git._check_revision(rev),
             )
         except GitCommandError as err:
             if err.status == 1:
@@ -1303,7 +1305,7 @@ def blame_incremental(
 
         data: bytes = self.git._call_process_safe(
             "blame",
-            Git._check_operand(rev, "revision") if rev is not None else None,
+            Git._check_revision(rev) if rev is not None else None,
             "--no-textconv" if not allow_unsafe_options else None,
             "--",
             file,
@@ -1424,7 +1426,7 @@ def blame(
             )
         data: bytes = self.git._call_process_safe(
             "blame",
-            Git._check_operand(rev, "revision") if rev is not None else None,
+            Git._check_revision(rev) if rev is not None else None,
             *rev_opts_list,
             "--no-textconv" if not allow_unsafe_options else None,
             "--",
@@ -1925,7 +1927,7 @@ def archive(
         self.git._call_process_safe(
             "archive",
             "--",
-            Git._check_operand(treeish, "revision"),
+            Git._check_revision(treeish),
             *path,
             _allow_network=bool(kwargs.get("remote")),
             _config=()