@@ -133,6 +133,7 @@ The historical full-suite counts above predate this correction. A constant
 | `Repo.rev_parse`, `rev_parse` metadata queries | Revision lookup, common directory, object format, bare flag, worktree root, fixed `modules`/`COMMIT_EDITMSG` locations | Repository-format validation, other metadata paths, symlinked metadata leaves, message searches and describe forms; GIX-1/14/17/22 |
 | Tree enumeration, `ls_tree` | Native tree entries with modes, names, and object IDs | Other command options |
 | Reference object reads | One exact native lookup for direct, symbolic and absent references | Partial names and native decoding errors |
+| Reference-name validation | Native full-name validation without opening a repository | Standalone names outside the native grammar; GIX-20 |
 | Managed `symbolic_ref` | Nonrecursive target lookup | Mutation, command-level missing-reference diagnostics |
 | Reference enumeration, `for_each_ref` | Sorted reference names and literal prefixes, preserving symbolic aliases | Dangling symbolic refs, root refs, glob patterns, other formats/options |
 | Managed `config --get KEY` | Merged repository config snapshot | Files/streams, enumeration, mutation; GIX-12 |
@@ -420,6 +421,7 @@ below use the supplied `pygix` source and its pinned Gitoxide revision.
 | GIX-17 | 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-18 | 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 | 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 | `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. |
 | GIX-21 | Native snapshot overrides for `committer.name`, `committer.email` and `gitoxide.commit.committerDate` resolve correctly. Applying them to the retained repository would expose command-specific identity to other threads. GixPython 0.1.0 has no general independent repository clone: Python `copy`/`deepcopy` fail, while the binding's internal `RepoHandle::clone()` shares its `Arc` state. | Bind a cheap independent native clone with isolated config so native identity resolution can apply per-command overrides, including removal semantics. Reopening isolates state but repeats setup; `with_object_memory()` also changes object-write behavior and is not a general clone API. Keep native process/config identity and CLI for differing command overrides. Do not mutate process environment/shared snapshots or resolve identity fields in Python. Explicit canonical commit inputs may still be adapted to `gix.Signature`. |
 | GIX-22 | The native Git directory is sufficient for the two fixed metadata leaves used here: `modules` and `COMMIT_EDITMSG`. Git's `path.c` applies no special relocation to either, including in linked worktrees. The adapter appends only these names to the canonical native Git directory. | No new binding is needed for these ordinary paths. Other `--git-path` names and symlinked metadata leaves retain CLI resolution; a general resolver must handle config/environment overrides, common/private storage and canonical targets. `Repository.modules_path()` means `.gitmodules`, not the `modules` storage directory. |
 
@@ -453,7 +455,7 @@ while Git with `--no-textconv --numstat` reports `-\t-\tfile` (binary).
 | Checkout, reset, index checkout/merge, move/remove | No bound equivalent of checkout-index/unpack-trees preserving these worktree/index semantics. Native tree/commit merge is a different operation. |
 | Branch/tag porcelain and symbolic-ref mutation | Strict creation, reflogs, config movement, signing, message cleanup and safety contracts need more than a raw ref edit. |
 | Object enumeration and alternate-directory listing | No binding for complete ODB object iteration or alternate-store enumeration; `cat-file --batch-all-objects` / `count-objects` remain. |
-| Name-rev, check-ref-format, trailer parsing, cherry | No equivalent bound operation. Native describe is not name-rev. Existing validation and parsing remain shared by both installations. |
+| Name-rev, trailer parsing, cherry | No equivalent bound operation. Native describe is not name-rev. |
 | Config-backed remote/submodule maintenance | Missing config enumeration/multivar/removal operations (GIX-12), plus filesystem and worktree lifecycle requirements. |
 | Hook execution | Explicitly requested hooks retain the existing Git-managed behavior. Native operations retain GitPython's default hook/fsmonitor/maintenance restrictions. |
 
 
@@ -270,6 +270,21 @@ def _ls_tree(repo: Any, args: List[str], kwargs: Dict[str, Any]) -> bytes:
         )
 
 
+def check_ref_name(name: str) -> Any:
+    """Validate a full reference name without opening a repository."""
+    if gix is None:
+        return NotImplemented
+    try:
+        gix.Target.Symbolic(name)
+    except gix.Error as exc:
+        if "/" not in name:
+            return _fallback("Reference.validate", "standalone reference names (GIX-20)")
+        record("Reference.validate", "native")
+        raise ValueError("Invalid reference %r" % name) from exc
+    record("Reference.validate", "native")
+    return None
+
+
 def reference_info(command: Any, path: str) -> Any:
     """Read an exact reference target, including an absent reference, in one lookup."""
     if gix is None:
 
@@ -155,7 +155,7 @@ def dereference_recursive(cls, repo: "Repo", ref_path: Union[PathLike, None]) ->
 
     @staticmethod
     def _check_ref_name_valid(ref_path: PathLike) -> None:
-        """Validate reference names with Git, rejecting CLI control input first."""
+        """Validate reference names, rejecting CLI control input first."""
         try:
             name = Git._check_operand(os.fspath(ref_path), "reference")
         except UnsafeOptionError as exc:
@@ -167,6 +167,8 @@ def _check_ref_name_valid(ref_path: PathLike) -> None:
     def _check_ref_name_native(name: str, _refresh_token: object) -> None:
         # The grammar depends on Git's executable, not repository contents.
         # Filesystem containment remains checked separately on every operation.
+        if _backend.check_ref_name(name) is not NotImplemented:
+            return
         try:
             Git()._call_process_safe("check_ref_format", "--allow-onelevel", name)
         except GitCommandError as exc:
 
@@ -253,6 +253,23 @@ def test_native_tree_and_commit_bytes_match_cli(repo):
         assert commit.replace(message="a changed message").hexsha == native.hexsha
 
 
+def test_native_reference_name_validation_without_repository():
+    SymbolicReference._check_ref_name_native.cache_clear()
+    count = _backend.statistics().get(("Git.execute", "CLI process"), 0)
+    with patch.object(Git, "execute", side_effect=AssertionError("unexpected validation CLI call")):
+        for name in ("HEAD", "FOO", "_", "refs/heads/native-é", "valid/ref/name"):
+            SymbolicReference._check_ref_name_valid(name)
+        for name in ("refs/heads/.hidden", "refs/heads/a..b", "refs/heads/end.lock", "--help"):
+            with pytest.raises(ValueError, match="Invalid reference"):
+                SymbolicReference._check_ref_name_valid(name)
+    assert _backend.statistics().get(("Git.execute", "CLI process"), 0) == count
+    for name in ("refs", "hellothere", "valid_one_level_refname", "1", "123", "A1", "1A", "HEAD_1", "A-B", "A.B", "Ä"):
+        SymbolicReference._check_ref_name_valid(name)
+    with pytest.raises(ValueError, match="Invalid reference"):
+        SymbolicReference._check_ref_name_valid("@")
+    assert _backend.statistics().get(("Git.execute", "CLI process"), 0) > count
+
+
 def test_native_reference_reads_include_missing_and_dangling_targets(repo):
     repo.index.commit("initial", skip_hooks=True)
     repo.git.pack_refs("--all", "--prune")