@@ -392,6 +392,19 @@ 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 |
 
+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
+fully qualified refs. Other root names, including `REBASE_HEAD`, retain the CLI
+fallback: GixPython's lookup accepts partial names, and its Git-compatible root
+reference existence and error behavior has not been verified. A native conversion
+needs that behavior, including Git's distinction between an absent and an invalid
+reference. `Repo.currently_rebasing_on()` probes `git show-ref --exists` and then
+uses the shared exact reference reader; the existence probe remains CLI on both
+backends. `exact-refs.sh` tests missing names beside fetched tags with both object
+and reference formats. Reftable still uses GIX-1; this change claims no new native
+coverage and demonstrates no new Gix compatibility mismatch.
+
 Reference names and revisions are encoded with `surrogateescape` before calling
 GixPython's byte-capable `Target.Symbolic`, `Repository.try_find_reference`,
 `Repository.rev_parse_single`, `Repository.rev_parse` and `RefEdit` APIs.
@@ -935,7 +948,7 @@ identify the historical fixture where needed.
 | GIX-14 | Bug; missing API | For a linked worktree of a bare main repository, `is_bare()` returns true while `git rev-parse --is-bare-repository` returns false; `workdir()` does expose the worktree. Initial gitfile opening can retain a noncanonical target and use an arbitrary gitfile's location as the worktree, unlike Git. Discovery accepts undecodable HEADs until explicit `head()` decoding and ignores dangling `commondir` symlinks that Git rejects. Bindings flatten failure kinds into `gix.Error`. Windows also exposes adapter path-formatting differences and a worker panic on an undecodable `commondir`; see the Windows reproduction below. | Provide Git-compatible classification, canonical gitfile locations and layout validation, plus typed errors instead of panics. Format native locations compatibly with Git's command output. The adapter combines Gix metadata, reopens through Gix and forces HEAD decoding, retaining CLI for remaining validation/diagnostic gaps. Those workarounds do not close these compatibility bugs. A Git-strict mode must cover these cases; strict config and trust settings alone do not. |
 | GIX-15 | Bug | Native blame disagrees with Git even with Myers and rewrite tracking selected. In the fixture's `README.md`, lines 150 and 158 are attributed to the opposite commits. Incremental order also differs. | Attribution and incremental-output parity before replacing `Repo.blame` / `blame_incremental`. |
 | GIX-16 | Bug; missing API | Native archive streaming takes a tree rather than a commit. Its TAR omits Git's global PAX commit comment, leaves `export-subst` placeholders literal, and writes ordinary modes as `0644` where Git uses `0664`. | Commit-aware export substitution, metadata and permission parity. Both engines respected `export-ignore` in the probe. |
-| GIX-17 | Bug | Revision parsing accepts abbreviated IDs with `-dirty`, prefers the OID suffix over an exact describe-shaped tag, and treats escaped braces in message searches differently. | Git-compatible revision grammar and regex semantics. Existing `test_rev_parse.py` cases reproduce all three. |
+| GIX-17 | Bug (open) | Revision parsing accepts abbreviated IDs with `-dirty`, prefers the OID suffix over an exact describe-shaped tag, and treats escaped braces in message searches differently. With GixPython 0.3.0 and Git 2.54.0, `2313-supersede` resolves to blob `23136a1d1dd1f02de7cde0f7b55f49d76ac77d55` through Gix while Git resolves the existing branch's commit. The deterministic `rev-parse.sh hex-prefix-collision` fixture creates a branch named `<blob-prefix>-topic`: Gix returns the blob and also accepts `<blob-prefix>-missing`, which Git rejects. | Provide Git-compatible revision grammar and regex semantics. `_check_revision_grammar()` retains CLI for hexadecimal prefixes followed by a dash, as well as the existing guarded forms; this adapter workaround does not close the upstream bug. `test_rev_parse.py` reproduces these differences, including `test_rev_parse_hex_prefix_with_arbitrary_suffix`. |
 | GIX-18 | Bug; missing API | The tree-diff resource cache reads attributes from the index; Git also consults worktree attributes. Native binary classification with textconv configured can also differ even in `to_git` mode. | Independent attribute-source control and `--no-textconv` parity. Statistics currently fall back for any effective `diff` attribute. |
 | GIX-19 | Unverified | GixPython opens repositories with `extensions.compatObjectFormat`, but translation and object-write compatibility have not been validated. The installed Git reports `compatibility hash algorithm support requires Rust` when asked to translate an ID. This is an unvalidated capability guard, not evidence of missing native object mappings. | Verify compatibility-format reads, writes and OID translation against a Git build that supports them. All operations use CLI in the meantime. |
 | GIX-20 | Bug; missing API | `Target.Symbolic(name)` validates full names but rejects standalone names accepted by `git check-ref-format --allow-onelevel`. Four of 430 audited calls differed: `refs` twice, `hellothere`, and `valid_one_level_refname`. Further probes include digits, punctuation and Unicode (`1`, `A1`, `HEAD_1`, `A-B`, `A.B`, `Ä`). | Expose Git-compatible partial/one-level name validation, or correct the native restriction where appropriate. This is a binding/behavior shortcoming to revisit upstream; standalone names rejected natively retain CLI validation. |
 
@@ -54,6 +54,10 @@ Git executable and safety
 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.
 * 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.
 
@@ -166,7 +166,7 @@ def _canonical_repository(repo: Any) -> Any:
 
 
 def _check_revision_grammar(ref: str) -> None:
-    if ref.startswith(":/") or "^{/" in ref or "-dirty" in ref or re.search(r"-\d+-g[0-9a-fA-F]+", ref):
+    if ref.startswith(":/") or "^{/" in ref or "-dirty" in ref or re.search(r"-\d+-g[0-9a-fA-F]+|^[0-9a-fA-F]+-", ref):
         raise _Unsupported("revision grammar differences (GIX-17)")
 
 
 
@@ -198,7 +198,8 @@ def _get_ref_info_helper(
             if exc.status != 1:
                 raise ValueError("Invalid symbolic reference %r" % path) from exc
         try:
-            oid = repo.git._call_process_safe("rev_parse", "--verify", "--end-of-options", path)
+            # Revision parsing can guess a tag when the exact reference is absent.
+            oid = repo.git._call_process_safe("show_ref", "--verify", "--hash", "--", path)
         except GitCommandError as exc:
             raise ValueError("Reference at %r does not exist or is invalid" % path) from exc
         if not repo.re_hexsha_only.fullmatch(oid):
 
@@ -35,7 +35,7 @@
 )
 from git.index import IndexFile
 from git.objects import Submodule, RootModule, Commit
-from git.refs import HEAD, Head, Reference, TagReference
+from git.refs import HEAD, Head, Reference, SymbolicReference, TagReference
 from git.remote import Remote, _T_RemoteName, add_progress, to_progress_instance
 from git.util import (
     Actor,
@@ -88,7 +88,6 @@
 if TYPE_CHECKING:
     from git.objects import Tree
     from git.objects.submodule.base import UpdateProgress
-    from git.refs.symbolic import SymbolicReference
     from git.remote import RemoteProgress
     from git.util import IterableList
 
@@ -1964,11 +1963,11 @@ def currently_rebasing_on(self) -> Commit | None:
         """
         if not self.git_dir:
             return None
-        status, oid, stderr = self.git._call_process_safe(
-            "rev_parse", "--verify", "--quiet", "REBASE_HEAD", with_extended_output=True, with_exceptions=False
+        status, stdout, stderr = self.git._call_process_safe(
+            "show_ref", "--exists", "--", "REBASE_HEAD", with_extended_output=True, with_exceptions=False
         )
-        if status == 1:
+        if status == 2:
             return None
         if status:
-            raise GitCommandError("git rev-parse", status, stderr, oid)
-        return self.commit(oid)
+            raise GitCommandError("git show-ref", status, stderr, stdout)
+        return self.commit(SymbolicReference.dereference_recursive(self, "REBASE_HEAD"))
@@ -163,6 +163,99 @@ def test_head_rename_retains_literal_prefixed_branch_name(object_format):
         assert repo.heads.topic.commit == original_topic
 
 
+@pytest.mark.parametrize("object_format", ["sha1", "sha256"])
+@pytest.mark.parametrize("ref_format", ["files", "reftable"])
+@pytest.mark.parametrize("force_cli", [False, True])
+def test_reference_lookup_does_not_guess_missing_names(object_format, ref_format, force_cli):
+    with fixture_repo("exact-refs.sh", object_format, ref_format) as repo:
+        status, _, _ = repo.git.rev_parse(
+            "--verify", "--quiet", "HEAD", with_extended_output=True, with_exceptions=False
+        )
+        assert status == 1
+        with patch.object(_backend, "gix", None) if force_cli else contextlib.nullcontext():
+            for path in (
+                "refs/heads/unborn",
+                "REBASE_HEAD",
+                "ORIG_HEAD",
+                "refs/tags/missing",
+                "refs/remotes/origin/missing",
+            ):
+                tag = TagReference(repo, "refs/tags/" + path)
+                assert tag.commit == repo.commit(tag.path)
+                status, _, _ = repo.git.show_ref(
+                    "--exists", "--", path, with_extended_output=True, with_exceptions=False
+                )
+                assert status == 2
+                with pytest.raises(ValueError, match="does not exist or is invalid"):
+                    SymbolicReference(repo, path).object
+            assert not repo.head.is_valid()
+            with pytest.raises(ValueError):
+                repo.head.commit
+            # Revision APIs deliberately retain Git's name guessing.
+            assert repo.commit("REBASE_HEAD") == repo.tags.REBASE_HEAD.commit
+            assert repo.tags["nested/release"].object.type == "tag"
+
+
+@pytest.mark.parametrize("object_format", ["sha1", "sha256"])
+@pytest.mark.parametrize("ref_format", ["files", "reftable"])
+def test_initial_commit_does_not_inherit_lookalike_tag_history(object_format, ref_format):
+    with fixture_repo("exact-refs.sh", object_format, ref_format, write=True) as repo:
+        foreign = repo.tags["refs/heads/unborn"].commit
+        initial = repo.index.commit("Local initial commit")
+        assert initial.parents == []
+        assert repo.head.commit == initial
+        assert repo.tags["refs/heads/unborn"].commit == foreign
+        assert repo.git.rev_list("--count", "HEAD") == "1"
+
+
+@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):
+    with fixture_repo("exact-refs.sh", object_format, ref_format, write=True) as repo:
+        assert repo.currently_rebasing_on() is None
+        replayed = repo.tags.REBASE_HEAD.commit
+        repo.git.update_ref("REBASE_HEAD", replayed.hexsha)
+        assert repo.currently_rebasing_on() == replayed
+        repo.git.update_ref("-d", "REBASE_HEAD")
+        assert repo.currently_rebasing_on() is None
+
+
+@pytest.mark.parametrize("object_format", ["sha1", "sha256"])
+@pytest.mark.parametrize("ref_format", ["files", "reftable"])
+def test_rebase_detection_peels_nested_annotated_tags(object_format, ref_format):
+    with fixture_repo("exact-refs.sh", object_format, ref_format, "nested", write=True) as repo:
+        tag = repo.tags["nested/outer"].object
+        assert tag.object.type == "tag"
+        repo.git.update_ref("REBASE_HEAD", tag.hexsha)
+        expected = repo.tags.REBASE_HEAD.commit
+        assert repo.git.rev_parse("REBASE_HEAD^{commit}") == expected.hexsha
+        assert repo.currently_rebasing_on() == expected
+
+
+@pytest.mark.parametrize("object_format", ["sha1", "sha256"])
+@pytest.mark.parametrize("ref_format", ["files", "reftable"])
+def test_exact_reference_reads_preserve_existing_targets(object_format, ref_format):
+    with fixture_repo("exact-refs.sh", object_format, ref_format, "existing", write=True) as repo:
+        commit = repo.tags.REBASE_HEAD.commit
+        paths = [
+            "HEAD",
+            "refs/heads/unborn",
+            "FETCH_HEAD",
+            "refs/tags/nested/release",
+            "refs/stash",
+            "ORIG_HEAD",
+            "MERGE_HEAD",
+            "REBASE_HEAD",
+        ]
+        repo.git.pack_refs("--all")
+        for path in paths:
+            expected = repo.git.rev_parse("--verify", path)
+            assert SymbolicReference(repo, path).object.hexsha == expected
+        repo.git.update_ref("--no-deref", "HEAD", commit.hexsha)
+        assert repo.head.is_detached
+        assert repo.head.commit == commit
+
+
 class TestRefs(TestBase):
     def test_from_path(self):
         # Should be able to create any reference directly.
 
@@ -80,6 +80,18 @@ def test_rev_parse_names_hex_and_describe_forms(rev_parse_repo):
         assert collision.rev_parse(describe_name).hexsha == release.hexsha
 
 
+def test_rev_parse_hex_prefix_with_arbitrary_suffix():
+    with fixture_repo("rev-parse.sh", "hex-prefix-collision") as repo:
+        prefix = (Path(repo.working_tree_dir).parent / "hex-prefix").read_text().strip()
+        name = prefix + "-topic"
+        assert repo.rev_parse(name).hexsha == repo.git.rev_parse("--verify", name)
+        missing = prefix + "-missing"
+        with pytest.raises(GitCommandError):
+            repo.git.rev_parse("--verify", missing)
+        with pytest.raises(BadName):
+            repo.rev_parse(missing)
+
+
 def test_rev_parse_navigation_and_peeling(rev_parse_repo):
     repo = rev_parse_repo["repo"]
     root = rev_parse_repo["root"]
 
@@ -0,0 +1,21 @@
+#!/usr/bin/env bash
+set -eu
+
+git init --object-format="$1" --ref-format="$2" --initial-branch=main source
+git -C source commit --allow-empty -m 'Remote history'
+for name in refs/heads/unborn REBASE_HEAD ORIG_HEAD refs/tags/missing refs/remotes/origin/missing; do
+    git -C source tag "$name"
+done
+git -C source tag -a nested/release -m 'Annotated release'
+if [ "${3-}" = nested ]; then
+    git -C source tag -a nested/outer nested/release -m 'Nested annotated release'
+fi
+git init --object-format="$1" --ref-format="$2" --initial-branch=unborn repo
+git -C repo fetch ../source 'refs/tags/*:refs/tags/*'
+if [ "${3-}" = existing ]; then
+    commit=$(git -C source rev-parse HEAD)
+    for path in refs/heads/unborn refs/stash ORIG_HEAD REBASE_HEAD; do
+        git -C repo update-ref "$path" "$commit"
+    done
+    printf '%s\n' "$commit" >repo/.git/MERGE_HEAD
+fi
@@ -40,6 +40,12 @@ describe-collision)
     abbrev=$(git rev-parse --short=7 "$merge")
     git tag "anything-9-g$abbrev" "$release"
     ;;
+hex-prefix-collision)
+    blob=$(git rev-parse HEAD:README.md)
+    prefix=$(git rev-parse --short=7 "$blob")
+    git branch "$prefix-topic" "$release"
+    printf '%s\n' "$prefix" > ../hex-prefix
+    ;;
 rev_parse_preserves_path_metadata_with_colons)
     blob=$(git rev-parse HEAD:dir/file.txt)
     subtree=$(printf '100644 blob %s\tname:with:colons\n' "$blob" | git mktree)