fix(sync/git[remote]) Drop git remote show to avoid ref enumeration hang

why: `GitSync.remote()` relied on `git remote show -n <name>`, whose output
begins with the fetch/push URLs but then enumerates every remote-tracking ref
in the repository. Repositories like openai/codex (2,400+ branches) ship that
list as ~2,500 lines through libvcs's real-time progress callback, which
read stderr in 128-byte chunks inside a busy-poll loop. On WSL2 the
combination stalled vcspull sync for long enough to look like a hang.

The URL lookup itself only needs the two URL lines, so reading from the
cached remote manager (`git remote -v`, O(remotes)) is enough.

what:
- Replace the `cmd.remotes.show(..., log_in_real_time=True)` call with
  `self.cmd.remotes.get(remote_name=name)`, using the fetch_url / push_url
  already populated by `git remote -v` parsing.
- Fall back to the fetch URL when no explicit pushurl is configured, matching
  git's own behaviour.
- Add `test_remote_is_fast_for_repos_with_many_refs` seeding 500 synthetic
  refs/remotes/origin/* refs and asserting `remote("origin")` returns in
  under 5 seconds. This would have been pathological on the old path.

Author: tony

src/libvcs/sync/git.py

@@ -673,25 +673,34 @@ def remote(self, name: str, **kwargs: t.Any) -> GitRemote | None:
         Returns
         -------
         Remote name and url in tuple form
+
+        Notes
+        -----
+        Uses ``git remote -v`` (via the cached remote manager) instead of
+        ``git remote show -n``. ``git remote show`` also enumerates every
+        remote-tracking ref, which pipes thousands of lines through the
+        subprocess progress callback for repositories with large branch
+        counts (e.g. ``openai/codex`` at 2,400+ refs) and can appear to
+        hang. ``git remote -v`` is O(remotes) and cannot block on ref
+        enumeration.
         """
-        try:
-            ret = self.cmd.remotes.show(
-                name=name,
-                no_query_remotes=True,
-                log_in_real_time=True,
-            )
-            lines = ret.split("\n")
-            remote_fetch_url = lines[1].replace("Fetch URL: ", "").strip()
-            remote_push_url = lines[2].replace("Push  URL: ", "").strip()
-            if name not in {remote_fetch_url, remote_push_url}:
-                return GitRemote(
-                    name=name,
-                    fetch_url=remote_fetch_url,
-                    push_url=remote_push_url,
-                )
-        except exc.LibVCSException:
-            pass
-        return None
+        remote_cmd = self.cmd.remotes.get(remote_name=name, default=None)
+        if remote_cmd is None:
+            return None
+
+        fetch_url = (remote_cmd.fetch_url or "").strip()
+        if not fetch_url:
+            return None
+
+        # When no explicit ``remote.<name>.pushurl`` is set, git itself falls
+        # back to the fetch URL -- mirror that so callers always see a URL.
+        push_url = (remote_cmd.push_url or fetch_url).strip()
+
+        return GitRemote(
+            name=name,
+            fetch_url=fetch_url,
+            push_url=push_url,
+        )
 
     def set_remote(
         self,

tests/sync/test_git.py

@@ -1666,3 +1666,46 @@ def test_sync_result_multiple_errors() -> None:
     assert len(result.errors) == 2
     assert result.errors[0].step == "fetch"
     assert result.errors[1].step == "checkout"
+
+
+def test_remote_is_fast_for_repos_with_many_refs(
+    git_repo: GitSync,
+    tmp_path: pathlib.Path,
+) -> None:
+    """``GitSync.remote`` stays O(1) even when the repo has thousands of refs.
+
+    The prior implementation called ``git remote show -n origin`` whose output
+    enumerates every remote-tracking ref. For repositories like openai/codex
+    (2,400+ branches) that stream of lines piped through the subprocess
+    progress callback produced the appearance of a hang during vcspull sync.
+
+    This test seeds synthetic refs/remotes/origin/branch-N entries and asserts
+    that ``remote('origin')`` returns promptly. A generous 5-second budget is
+    enough to catch the pathological old path (many seconds on WSL2) without
+    flaking on slow CI.
+    """
+    import time
+
+    # Point origin at a commit we already have so fake refs don't dangle.
+    head_sha = run(["git", "rev-parse", "HEAD"], cwd=git_repo.path).strip()
+
+    # Seed 500 fake remote-tracking refs. ``git update-ref`` is quick but the
+    # cumulative count is what would blow up ``git remote show -n``.
+    for i in range(500):
+        run(
+            [
+                "git",
+                "update-ref",
+                f"refs/remotes/origin/fake-branch-{i:04d}",
+                head_sha,
+            ],
+            cwd=git_repo.path,
+        )
+
+    started = time.monotonic()
+    remote = git_repo.remote("origin")
+    elapsed = time.monotonic() - started
+
+    assert remote is not None
+    assert remote.fetch_url, "fetch URL must be populated"
+    assert elapsed < 5.0, f"remote() too slow: {elapsed:.2f}s with 500 fake refs"