@@ -61,6 +61,16 @@ adapter return an invalid remote reference, preventing angr 10.0.4.post1 from
 reporting a valid local tracking branch. A native replacement must expose Git's
 local-upstream resolution, including its validation and diagnostics.
 
+Revision path results retain the root tree's empty path so `Repo.rev_parse("HEAD:")`
+can be iterated, as required by MCP Server Git 2026.10.19. Git's `objectmode`
+atom and Gix's `RevisionSpec.path_and_mode()` omit metadata for that root;
+the adapter supplies its fixed empty path after successful tree resolution.
+Missing tree paths retain GitPython's `Tree.join()` `KeyError` diagnostics.
+Git validates the tree-ish prefix, including colons inside commit-message
+searches, and existing backend-managed tree queries identify the missing
+component. This error path uses a CLI prefix resolver; GixPython would need to
+expose compatible failed-path context and component diagnostics to replace it.
+
 `IndexFile` queries immutable entry records; it does not retain a parsed index.
 The compatibility `entries` property projects those queries into a read-only
 snapshot keyed by path and stage, preserving readers in dlt and Renku. It uses
 
@@ -51,6 +51,10 @@ Git executable and safety
 API changes
 -----------
 
+* Revision root trees such as ``Repo.rev_parse("HEAD:")`` retain their empty
+  path and can be iterated. Missing paths within a valid tree revision retain
+  ``Tree.join()``'s ``KeyError`` and missing-component message, restoring MCP
+  Server Git's directory display and path-error reporting.
 * ``Head.tracking_branch()`` returns a local ``Head`` when Git configures the
   current repository (``branch.<name>.remote=.``) as the upstream, instead of
   constructing an invalid ``refs/remotes/./...`` reference. Git resolves the
 
@@ -122,11 +122,31 @@ def to_commit(obj: AnyGitObject) -> "Commit":
     return obj
 
 
+def _tree_path(repo: "Repo", rev: str) -> Optional[tuple[str, str]]:
+    """Ask Git which colon follows a tree-ish, including message-search revisions."""
+    if rev.startswith(":"):
+        return None
+    for index, char in enumerate(rev):
+        if char != ":":
+            continue
+        try:
+            tree = repo.git._call_process_safe(
+                "rev_parse", "--verify", "--quiet", "--end-of-options", rev[:index] + "^{tree}"
+            )
+        except GitCommandError as exc:
+            if exc.status != 1:
+                raise
+            continue
+        return tree, rev[index + 1 :]
+    return None
+
+
 def rev_parse(repo: "Repo", rev: str) -> AnyGitObject:
     """Resolve a Git revision to an object using Git's native revision grammar.
 
-    Invalid or missing revisions raise :class:`gitdb.exc.BadName`. Option-like
-    revisions and embedded command delimiters are rejected before invoking Git.
+    Invalid or missing revisions raise :class:`gitdb.exc.BadName`. Missing tree
+    paths retain the tree lookup's :class:`KeyError`. Option-like revisions and
+    embedded command delimiters are rejected before invoking Git.
     """
     rev = Git._check_operand(rev, "revision")
     native = _backend.revision_info(repo.git, rev) if ":" in rev else NotImplemented
@@ -139,6 +159,12 @@ def rev_parse(repo: "Repo", rev: str) -> AnyGitObject:
     except GitCommandError as exc:
         if exc.status != 1 and "Invalid regular expression" not in exc.stderr:
             raise
+        if exc.status == 1 and ":" in rev:
+            context = _tree_path(repo, rev)
+            if context is not None and context[1]:
+                # Reuse the public, backend-managed tree query for its legacy
+                # missing-component diagnostics; do not parse Git storage here.
+                repo.tree(context[0]).join(context[1])
         raise BadName(rev) from exc
     if not repo.re_hexsha_only.fullmatch(oid):
         raise BadName(rev)
@@ -149,6 +175,9 @@ def rev_parse(repo: "Repo", rev: str) -> AnyGitObject:
                 path_bytes, obj.mode = native[1]
                 path = path_bytes.decode(defenc, "surrogateescape")
                 obj.path = posixpath.normpath(path) if path else ""
+            elif obj.type == "tree":
+                # Gix omits path metadata for a successfully resolved root tree.
+                obj.path = ""
             return obj
         # Git resolves the mode, including index stages and executable/symlink
         # entries. No object storage or revision grammar is decoded in Python.
@@ -165,20 +194,13 @@ def rev_parse(repo: "Repo", rev: str) -> AnyGitObject:
                 path = rev[3:] if len(rev) > 2 and rev[1] in "0123" and rev[2] == ":" else rev[1:]
                 obj.path = posixpath.normpath(path) if path else ""
             else:
-                # Git has no path format atom. Ask it which colon follows a
-                # tree-ish; earlier colons can belong to commit-message regexes.
-                for index, char in enumerate(rev):
-                    if char != ":":
-                        continue
-                    try:
-                        repo.git._call_process_safe(
-                            "rev_parse", "--verify", "--quiet", "--end-of-options", rev[:index] + "^{tree}"
-                        )
-                    except GitCommandError as exc:
-                        if exc.status != 1:
-                            raise
-                        continue
-                    path = rev[index + 1 :]
+                context = _tree_path(repo, rev)
+                if context is not None:
+                    path = context[1]
                     obj.path = posixpath.normpath(path) if path else ""
-                    break
+        elif obj.type == "tree":
+            # Git's objectmode atom is empty for the root tree, too.
+            context = _tree_path(repo, rev)
+            if context is not None and not context[1]:
+                obj.path = ""
     return obj
@@ -10,6 +10,35 @@
 from test.lib.fixtures import fixture_repo
 
 
+@pytest.mark.parametrize("object_format", ["sha1", "sha256"])
+@pytest.mark.parametrize("ref_format", ["files", "reftable"])
+def test_revision_root_tree_retains_iterable_path_context(object_format, ref_format):
+    with fixture_repo("downstream-revision-path.sh", object_format, ref_format) as repo:
+        for revision in ("HEAD:", "HEAD^{}:", "HEAD^{/initial: with colon}:"):
+            tree = repo.rev_parse(revision)
+            assert tree.path == ""
+            assert tree.mode == 0o40000
+            assert [entry.path for entry in tree] == ["dir", "tracked"]
+            assert tree["dir/file"].data_stream.read() == b"nested"
+
+
+@pytest.mark.parametrize("object_format", ["sha1", "sha256"])
+@pytest.mark.parametrize("ref_format", ["files", "reftable"])
+def test_missing_revision_paths_retain_tree_lookup_errors(object_format, ref_format):
+    with fixture_repo("downstream-revision-path.sh", object_format, ref_format) as repo:
+        for revision, missing in (
+            ("HEAD:nope", "nope"),
+            ("HEAD:dir/nope", "nope"),
+            ("HEAD:nope/child", "nope"),
+            ("HEAD:tracked/child", "tracked/child"),
+            ("HEAD^{}:nope", "nope"),
+            ("HEAD^{/initial: with colon}:nope", "nope"),
+        ):
+            with pytest.raises(KeyError) as error:
+                repo.rev_parse(revision)
+            assert error.value.args == ("Blob or Tree named %r not found" % missing,)
+
+
 @pytest.mark.parametrize("object_format", ["sha1", "sha256"])
 @pytest.mark.parametrize("ref_format", ["files", "reftable"])
 def test_local_tracking_branch_uses_gits_upstream_location(object_format, ref_format):
 
@@ -0,0 +1,9 @@
+#!/usr/bin/env bash
+set -eu
+git init -q --object-format="$1" --ref-format="$2" repo
+cd repo
+mkdir dir
+printf tracked > tracked
+printf nested > dir/file
+git add .
+git commit -qm 'initial: with colon'