@@ -130,6 +130,7 @@ The historical full-suite counts above predate this correction. A constant
 | `Git.stream_object_data`, ODB `stream` | Object bytes in an independent stream | Objects larger than 8 MiB; GIX-2 |
 | Commit/tree serialization readback | Existing ODB stream; no separate `cat-file` process | The same storage and large-object fallbacks as ODB reads |
 | `Repo` opening/discovery | Native storage, worktree, object format and empty-tree metadata | Repository-format validation, unsupported layouts/environment and native validation gaps; GIX-1/14/19 |
+| Standalone discovery helpers | Native storage directories and gitfiles reopened at their canonical native Git directory | Rejected candidates and the same layout/environment guards as `Repo` opening; GIX-14 |
 | `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 |
@@ -415,7 +416,7 @@ below use the supplied `pygix` source and its pinned Gitoxide revision.
 | GIX-11 | Inexact and ambiguous rename pairing/scores have not been established as Git-compatible. This is a conservative guard, not a claimed native bug. | Verified pairing, scoring, tie-breaking and option parity. Exact unambiguous renames are native. |
 | GIX-12 | Config bindings lack standalone parsing, ordered section/key enumeration, multivars, unset/remove-section and source-scoped queries. | Those operations for `GitConfigParser` and remote/branch configuration. Native merged getters cannot replace repository-only config readers. |
 | GIX-13 | Native index writing normalizes v4 to v2, offers no version setter, and expands split indexes. | Version and split-index preservation. Tests now assert that a split index remains split after an update. |
-| GIX-14 | Gix correctly exposes linked worktree paths, including those of bare main repositories. Its documented `is_bare()` reflects configuration and can be true alongside a worktree; opening and inventory now use both pieces of native metadata. Actual gaps remain: discovery tolerates undecodable HEADs and ignores dangling `commondir` symlinks, while Python flattens native failure kinds into `gix.Error`. | Opening forces native HEAD decoding and retains CLI validation for remaining layout/diagnostic gaps. Strict trust checks do not replace layout validation. Canonical inputs can be reopened through Gix, as already done for the inventory's main repository; no classification fix is required upstream. Do not fabricate rejection from Python `HEAD` existence checks or infer a missing worktree root. |
+| GIX-14 | Gix correctly exposes linked worktree paths, including those of bare main repositories. Its documented `is_bare()` reflects configuration and can be true alongside a worktree; opening and inventory use both pieces of native metadata. Gitfiles are reopened at the canonical native Git directory, which also prevents an arbitrary gitfile location from becoming the worktree. Actual gaps remain: discovery tolerates undecodable HEADs and ignores dangling `commondir` symlinks, while Python flattens native failure kinds into `gix.Error`. | Opening forces native HEAD decoding and retains CLI validation for remaining layout/diagnostic gaps. Strict trust checks do not replace layout validation. Reopening uses the same strict options and returns actual native metadata; no upstream classification fix or Python worktree inference is needed. A native canonical-opening option could avoid the extra open later. |
 | GIX-15 | 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 | 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 | 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. |
 
@@ -70,6 +70,10 @@ def discover_repository(path: str, environment: Dict[str, Any]) -> Any:
     )
     try:
         repo = gix.open_opts(path, options)
+        if os.path.isfile(path):
+            # Reopening also makes Gix derive the worktree from its Git directory,
+            # rather than retaining an arbitrary gitfile's location as a worktree.
+            repo = gix.open_opts(os.path.realpath(repo.git_dir()), options)
         snapshot = repo.config_snapshot()
         if snapshot.string("extensions.refStorage") == b"reftable":
             return _fallback("Repo.open", "reftable (GIX-1)")
 
@@ -25,6 +25,7 @@
 
 from gitdb.exc import BadName, BadObject
 
+from git import _backend
 from git.cmd import Git
 from git.compat import defenc
 from git.exc import GitCommandError
@@ -47,11 +48,14 @@ def touch(filename: str) -> str:
 
 
 def find_submodule_git_dir(d: PathLike) -> Optional[PathLike]:
-    """Resolve a repository directory or gitfile using Git."""
+    """Resolve a repository directory or gitfile using the selected backend."""
     path = osp.abspath(os.fspath(d))
     if not osp.exists(path):
         return None
     try:
+        native = _backend.discover_repository(path, {})
+        if native is not NotImplemented:
+            return to_native_path_linux(os.fspath(native.git_dir()))
         return Git()._call_process_safe("rev_parse", "--resolve-git-dir", to_native_path_linux(path))
     except GitCommandError:
         return None
 
@@ -11,6 +11,7 @@
 
 from git import Actor, Commit, Git, Reference, Repo, SymbolicReference, _backend
 from git.exc import GitCommandError, InvalidGitRepositoryError
+from git.repo.fun import find_submodule_git_dir, find_worktree_git_dir, is_git_dir
 from gitdb import IStream
 
 gix = pytest.importorskip("gix")
@@ -122,6 +123,18 @@ def test_opening_and_discovery_use_gix_with_explicit_fallbacks(repo, tmp_path):
     bare_linked_native = gix.open(bare_linked)
     assert bare_linked_native.is_bare()
     assert bare_linked_native.workdir() == bare_linked
+    gitfile = tmp_path / "gitfile"
+    gitfile.write_text("gitdir: repo/.git\n")
+    candidates = [repo.git_dir, bare.git_dir, linked / ".git", linked_admin, gitfile]
+    with patch.object(_backend, "gix", None):
+        expected = [find_submodule_git_dir(path) for path in candidates]
+    with patch.object(Git, "execute", side_effect=AssertionError("unexpected CLI call")):
+        assert [find_submodule_git_dir(path) for path in candidates] == expected
+        assert find_worktree_git_dir(gitfile) == expected[-1]
+        assert is_git_dir(repo.git_dir)
+    with patch.object(Git, "execute", autospec=True, side_effect=Git.execute) as cli:
+        assert find_submodule_git_dir(nested) is None
+        assert sum("--resolve-git-dir" in call.args[1] for call in cli.call_args_list) == 1
     for path, search, expected_bare, rejected_candidates in [
         (root, False, False, 0),
         (repo.git_dir, False, False, 0),
@@ -165,6 +178,45 @@ def test_discovery_asks_gix_before_falling_back(tmp_path):
         native_open.assert_called_once()
 
 
+@pytest.mark.parametrize("target", ["repo/.git", "repo/../repo/.git", "alias/.git"])
+def test_gitfile_reopens_canonical_native_repository(repo, tmp_path, target):
+    if target == "alias/.git":
+        try:
+            (tmp_path / "alias").symlink_to(repo.working_dir, target_is_directory=True)
+        except OSError as exc:
+            pytest.skip(f"symlinks unavailable: {exc}")
+    gitfile = tmp_path / "gitfile"
+    gitfile.write_text(f"gitdir: {target}\n")
+    with patch.object(_backend, "gix", None), Repo(gitfile) as control:
+        expected = (control.git_dir, control.working_tree_dir, control.bare)
+        expected_git_path = repo.git.rev_parse("--resolve-git-dir", str(gitfile))
+    with patch.object(Git, "execute", side_effect=AssertionError("unexpected CLI call")):
+        with patch.object(gix, "open_opts", wraps=gix.open_opts) as native_open:
+            native = _backend.discover_repository(str(gitfile), {})
+            assert (str(native.git_dir()), str(native.workdir()), native.is_bare()) == expected
+            assert native_open.call_count == 2
+            assert native_open.call_args.args[0] == expected[0]
+            assert native_open.call_args.args[1] is native_open.call_args_list[0].args[1]
+        assert find_submodule_git_dir(gitfile) == expected_git_path
+        assert find_worktree_git_dir(gitfile) == expected_git_path
+    with patch.object(Git, "execute", autospec=True, side_effect=Git.execute) as cli:
+        with Repo(gitfile) as opened:
+            assert (opened.git_dir, str(opened.working_tree_dir), opened.bare) == expected
+            assert isinstance(opened._gix_repository, gix.Repository)
+        assert all("version" in call.args[1] or "--show-ref-format" in call.args[1] for call in cli.call_args_list)
+
+
+def test_gitfile_reopen_failure_selects_fallback(repo, tmp_path):
+    gitfile = tmp_path / "gitfile"
+    gitfile.write_text("gitdir: repo/.git\n")
+    outcomes = [gix.open(repo.git_dir), gix.Error("canonical reopen failed")]
+    before = _backend.statistics().get(("Repo.open", "native"), 0)
+    with patch.object(gix, "open_opts", side_effect=outcomes) as native_open:
+        assert _backend.discover_repository(str(gitfile), {}) is NotImplemented
+        assert native_open.call_count == 2
+    assert _backend.statistics().get(("Repo.open", "native"), 0) == before
+
+
 def test_native_objects_trees_commits_and_index_reads(repo):
     actor = Actor("Example", "example@example.invalid")
     paths = ["file", "dir/with space", "dir/unicode-é", "--option"]