@@ -11,11 +11,9 @@ bindings to execute supported operations through Gitoxide while exposing GitPyth
 high-level repository, commit, tree and index interfaces.
 
 Supported object reads, tree traversal, reference/index queries and commit history
-can run without launching Git subprocesses. GitPython also retains and reuses a Gix
-repository handle across operations, reducing repeated initialization work. These
-changes reduce subprocess overhead, particularly for repeated repository queries;
-the [backend benchmarks](test/performance/README.md) measure results and CLI launch
-counts for both backends.
+can run without launching Git subprocesses. Each native operation opens a fresh
+Gix repository handle. The [backend benchmarks](test/performance/README.md) measure
+results and CLI launch counts for both backends.
 
 ### Activate the Gix backend
 
 
@@ -453,9 +453,9 @@ environment metadata.
 operations and their complete journey on one already-open `git.Repo`, plus
 separate direct opening and discovery from `git/objects`. Fresh high-level
 wrappers preserve the cost of actual operations; imports, fixture preparation
-and parity preflight are outside timing. Native repository refresh remains
-inside operation timing, so these measurements include the cost of keeping
-retained state current.
+and parity preflight are outside timing. Native repository opening remains inside
+operation timing. Historical retained-handle results below included refresh
+costs instead.
 
 Submodule inventory, revision path/mode lookup and raw commit/tree readback
 extend the already-open journey, each with a zero-CLI ceiling. The readback
@@ -632,8 +632,8 @@ used Gix; CLI validation used the affected selections. Repository-wide Ruff
 lint/format, mypy and basedpyright passed. The benchmark comparison independently
 checked result parity, fixture/source identity and all process ceilings.
 Generic configuration and standalone reference-name gaps remain documented
-under GIX-12/20. `Repo._get_gix_repository(recreate=True)` still explicitly
-recreates retained native state; its snapshot limitations are documented below.
+under GIX-12/20. That snapshot retained native repository state; the current
+accessor opens a fresh handle for each operation, as documented below.
 
 Raw benchmarks, comparison tables and logs from that snapshot are under
 `.cache/gix-only-audit/benchmark-*` and `.cache/gix-only-audit/pyperf-comparison.md`.
@@ -785,39 +785,34 @@ expected failure. Operation reporting counted 114,800 native operations and
 39,002 CLI fallback decisions. Those decisions are not a complete subprocess
 count: raw `repo.git` calls and subprocesses started by Git are not all counted.
 
-### Retain native repository state (implemented)
-
-Each `git.Repo` owns a native `gix.Repository`. Managed operations access it through
-`Repo._get_gix_repository()`, which reuses the instance by default.
-`Repo._get_gix_repository(recreate=True)` replaces it explicitly; this method is
-the control point for a future configurable reuse policy. Managed operations reuse it;
-`close()` releases it, and a later operation can reopen it. Pickling excludes
-native resources and restores the command's weak owner reference. Gix provides
-thread-safe handle access and automatic index/ODB snapshot refresh. A per-Repo
-lock serializes handle refresh, without serializing read operations.
-
-Retaining native state is an intentional deviation from Git's fresh process per
-command. Configuration/environment and observed CLI changes trigger best-effort
-refresh, but this is not a promise that every external filesystem change is
-immediately visible in every native cache. Explicit recreation or closing and
-reopening the `Repo` provides fresh native state. Configuration queries currently
-use a separate fresh handle because the retained execution handle overrides
-hooks, fsmonitor and automatic maintenance; those overrides must not leak into
-configuration results. The accessor itself removes no CLI calls: ten supported
-metadata queries launch zero processes before and after this refactor.
-
-Configuration and storage metadata changes, environment changes and raw CLI
-launches cause `reload()` before reuse. Configuration queries use a separate
-fresh handle so synthetic safety settings never appear as user settings.
-Configurations with includes conservatively reload on each operation because
-the binding does not expose all included source paths. Storage overrides,
-reftable and compatibility object formats retain their existing CLI guards.
+### Open fresh native repository state
+
+Managed operations access Gix through `Repo._get_gix_repository()`, which opens
+a fresh `gix.Repository` for each call. Standalone commands use the same opening
+path. No native handle, environment/file fingerprint or refresh lock is cached
+on `Repo`; configuration, includes and storage metadata are read by Gix again
+on each open. Concurrent operations therefore receive independent handles.
+
+Execution handles override hooks, fsmonitor and automatic maintenance.
+Configuration queries omit those overrides so synthetic settings do not appear
+as user settings. Storage overrides, reftable and compatibility object formats
+retain their existing CLI guards. Reopening itself adds no Git CLI calls.
+
+`Repo.close()` releases persistent CLI object readers. Native handles remain
+local to operations; callers holding separately opened handles or iterators
+must release them before deleting their repository, especially on Windows.
+Pickling restores the command's weak owner reference without native resources.
+
+This replaces the retained-handle policy and its best-effort invalidation via
+file metadata, environment changes and CLI launches. Reopening repeats native
+initialization work but avoids fingerprint construction and unconditional
+reloads for configurations with includes.
 
 An earlier 1,000-call benchmark without coverage measured an object read using
-one native handle at 0.046 ms per call, compared with 0.635 ms through the
-fresh-open stream adapter. Opening and validating a native repository alone
-took 0.418 ms per call. These small repeated-read measurements do not estimate
-whole-suite speedup.
+one retained native handle at 0.046 ms per call, compared with 0.635 ms through
+the fresh-open stream adapter. Opening and validating a native repository alone
+took 0.418 ms per call. Those historical measurements do not describe the current
+accessor or estimate whole-suite speedup; rerun the backend harness to measure it.
 
 ### Reuse prepared test fixtures (implemented)
 
@@ -1230,8 +1225,7 @@ can use Git to preserve its public diagnostics. Once `_write()` begins,
 `gix.Error` failures become `GitCommandError`; other exceptions propagate.
 Neither may trigger a second CLI mutation.
 Access native repository state through `Repo._get_gix_repository()` for bound
-commands. Reuse is the default, with explicit recreation available; keep the
-snapshot deviation and refresh behavior above documented. Close native iterators
+commands. Each access opens a fresh handle through Gix. Close native iterators
 when partially consumed.
 
 Add each conversion with a no-subprocess check and a Git parity check where
 
@@ -144,56 +144,17 @@ def _open_repository(command: Any, env: Dict[str, Any], *, query_config: bool =
         options = options.config_overrides(
             ["core.fsmonitor=false", "gc.auto=0", "maintenance.auto=false", "core.hooksPath=" + os.devnull]
         )
-    owner = command._repo() if command._repo is not None else None
-    state = None
-    repo = None
-    if owner is not None and not query_config:
-        # Gix refreshes index/ODB snapshots itself; configuration is loaded at open.
-        paths = [
-            path,
-            os.fspath(owner.common_dir),
-            os.path.join(owner.common_dir, "config"),
-            os.path.join(path, "config.worktree"),
-        ]
-        paths += [
-            effective.get("GIT_CONFIG_SYSTEM", "/etc/gitconfig"),
-            effective.get("GIT_CONFIG_GLOBAL", os.path.expanduser("~/.gitconfig")),
-            os.path.join(effective.get("XDG_CONFIG_HOME", os.path.expanduser("~/.config")), "git", "config"),
-            os.path.join(owner.common_dir, "objects", "info", "alternates"),
-            os.path.join(path, "commondir"),
-            os.path.join(path, "gitdir"),
-        ]
-        stamps: List[Any] = []
-        for filename in paths:
-            try:
-                info = os.stat(filename)
-                stamps.append((info.st_dev, info.st_ino, info.st_size, info.st_mtime_ns, info.st_ctime_ns))
-            except FileNotFoundError:
-                stamps.append(None)
-        state = (path, tuple(sorted(effective.items())), tuple(stamps))
-        repo = owner._gix_repository
-        if repo is not None and os.path.realpath(repo.git_dir()) != os.path.realpath(path):
-            repo = None
-        if repo is not None and state != owner._gix_state:
-            repo.reload()
-    if repo is None:
-        repo = gix.open_opts(path, options)
+    repo = gix.open_opts(path, options)
     snapshot = repo.config_snapshot()
     if snapshot.string("extensions.refStorage") == b"reftable":
         raise _Unsupported("reftable (GIX-1)")
     if snapshot.string("extensions.compatObjectFormat") is not None:
         raise _Unsupported("compatibility object format (GIX-19)")
-    if effective.get("GIT_WORK_TREE") and (owner is None or query_config or state != owner._gix_state):
+    if effective.get("GIT_WORK_TREE"):
         workdir = effective["GIT_WORK_TREE"]
         if not os.path.isabs(workdir):
             workdir = os.path.join(command.working_dir or os.getcwd(), workdir)
         repo.set_workdir(workdir)
-    if owner is not None and not query_config:
-        owner._gix_repository = repo
-        # ponytail: includes can load arbitrary files; reopen until Gix exposes their source paths.
-        if state != owner._gix_state:
-            included = re.search(rb"\[include(?:if)?[\s\]]", repo.config_snapshot().plumbing().to_bstring(), re.I)
-            owner._gix_state = None if included else state
     return repo
 
 
 
@@ -1166,7 +1166,7 @@ def __init__(self, working_dir: Union[None, PathLike] = None) -> None:
         # Extra environment variables to pass to git commands
         self._environment: Dict[str, Optional[str]] = {}
         self._repository_environment: Dict[str, Optional[str]] = {}
-        self._repo: Any = None  # Weak reference; the Repo owns native resources.
+        self._repo: Any = None  # Weak reference to the Repo's native repository accessor.
 
         # Cached version slots
         self._version_info = None
@@ -1587,9 +1587,6 @@ def execute(
             raise GitCommandNotFound(redacted_command, err) from err
         else:
             _backend.record("Git.execute", "CLI process")
-            owner = self._repo() if self._repo is not None else None
-            if owner is not None:
-                owner._gix_state = None
             # Replace with a typeguard for Popen[bytes]?
             proc.stdout = cast(BinaryIO, proc.stdout)
             proc.stderr = cast(BinaryIO, proc.stderr)
 
@@ -16,7 +16,6 @@
 import shlex
 import sys
 import tempfile
-from threading import RLock
 import weakref
 
 import gitdb
@@ -125,8 +124,6 @@ class Repo:
 
     # Must exist, or  __del__  will fail in case we raise on `__init__()`.
     git = cast("Git", None)
-    _gix_repository: Any = None
-    _gix_state: Any = None
 
     working_dir: PathLike
     """The working directory of the git command."""
@@ -460,7 +457,6 @@ def __init__(
                     break
 
         self.working_dir = self._working_tree_dir or self.common_dir
-        self._gix_lock = RLock()
         self.git = self.GitCommandWrapperType(self.working_dir)
         self.git._repo = weakref.ref(self)
         self.git._environment.update(GIT_DIR=git_dir, **environment)
@@ -471,7 +467,6 @@ def __init__(
             if "GIT_WORK_TREE" not in environment:
                 self.git._repository_environment["GIT_WORK_TREE"] = os.fspath(self._working_tree_dir)
         if native is not NotImplemented:
-            self._gix_repository = native
             self._empty_tree_hexsha = str(native.empty_tree().id)
         else:
             with tempfile.TemporaryFile() as empty:
@@ -494,32 +489,18 @@ def _get_gix_repository(
         command: Optional[Git] = None,
         env: Optional[Dict[str, Any]] = None,
         query_config: bool = False,
-        recreate: bool = False,
     ) -> Any:
-        """Access native state, reusing the repository unless recreation is requested.
+        """Open a fresh native repository for each operation.
 
-        This method owns the reuse policy so it can later become configurable.
-        Configuration queries currently open a separate handle without the execution
-        restrictions applied to the retained handle. Other operations retain the
-        existing best-effort refresh of configuration, environment and CLI changes.
+        Configuration queries omit execution restrictions so synthetic settings
+        do not appear in configuration results.
         """
-        with self._gix_lock:
-            if recreate:
-                self._gix_repository = self._gix_state = None
-            return _backend._open_repository(
-                command if command is not None else self.git, env or {}, query_config=query_config
-            )
-
-    def __getstate__(self) -> Dict[str, Any]:
-        return {
-            key: value
-            for key, value in self.__dict__.items()
-            if key not in ("_gix_repository", "_gix_state", "_gix_lock")
-        }
+        return _backend._open_repository(
+            command if command is not None else self.git, env or {}, query_config=query_config
+        )
 
     def __setstate__(self, state: Dict[str, Any]) -> None:
         self.__dict__.update(state)
-        self._gix_lock = RLock()
         self.git._repo = weakref.ref(self)
 
     def __enter__(self) -> "Repo":
@@ -535,14 +516,14 @@ def __del__(self) -> None:
             pass
 
     def close(self) -> None:
-        """Release native repository state and persistent Git object readers.
+        """Release persistent Git object readers.
 
         Use ``with Repo(path) as repo:`` to close automatically, including on errors.
-        Close every repository instance and any separately opened readers before
-        removing its directory, especially on Windows where open handles prevent
-        deletion. :func:`git.util.rmtree` also handles Git's read-only files.
+        Close every repository instance and release any separately opened native
+        handles or readers before removing its directory, especially on Windows
+        where open handles prevent deletion. :func:`git.util.rmtree` also handles
+        Git's read-only files.
         """
-        self._gix_repository = self._gix_state = None
         if self.git:
             self.git.clear_cache()
             # Tempfiles objects on Windows are holding references to open files until
 
@@ -7,8 +7,8 @@ instance open per worker, but creates fresh commit/tree/index wrappers per
 invocation so their cached properties cannot turn the measurement into a no-op.
 The CLI's persistent `cat-file` processes and the filesystem cache are warmed.
 Repository creation, imports, preflight and result hashing are outside timing.
-Native handle refresh and compatibility checks remain inside timing, exposing
-the benefit of retaining a Gix repository across operations. Opening and
+Native repository opening and compatibility checks remain inside operation
+timing; each native operation opens a fresh Gix handle. Opening and
 discovery retain explicit CLI fallbacks tracked in `cli-budget.json`.
 `open_repository` and `discover_repository` instead create and close a new
 `Repo` in each timed invocation; they do not join the already-open journey.
 
@@ -229,7 +229,7 @@ def case(self, *resources):
         assert (directory / "locked").exists()
         assert not (directory / "removable").exists()
     for repo in repositories:
-        assert repo._gix_repository is None
+        assert repo.git.cat_file_header is repo.git.cat_file_all is None
 
 
 def test_directory_decorator_preserves_failed_test_artifacts(tmp_path, monkeypatch):
 
@@ -24,7 +24,6 @@ def test_repo_context_releases_resources_before_removal():
             assert repo.head.commit.tree["file"].data_stream.read() == b"contents\n"
             processes = [reader.proc for reader in (repo.git.cat_file_header, repo.git.cat_file_all) if reader]
 
-        assert repo._gix_repository is None
         assert repo.git.cat_file_header is repo.git.cat_file_all is None
         assert all(process.poll() is not None for process in processes)
         # [remove-repo-directory]
 
@@ -32,7 +32,6 @@ def test_scripted_writable_fixture_copies_and_closes_repository():
         (root / "file").write_text("private")
         repo.index.add(["file"])
         repo.index.commit("Private change", skip_hooks=True)
-    assert repo._gix_repository is None
     assert not root.exists()
     assert (baseline / "repo/file").read_text() == "initial"