diff --git a/‎git/cmd.py‎
Lines changed: 9 additions & 6 deletions b/‎git/cmd.py‎
Lines changed: 9 additions & 6 deletions
diff --git a/‎git/remote.py‎
Lines changed: 4 additions & 8 deletions b/‎git/remote.py‎
Lines changed: 4 additions & 8 deletions
diff --git a/‎test/test_command_guards.py‎
Lines changed: 84 additions & 1 deletion b/‎test/test_command_guards.py‎
Lines changed: 84 additions & 1 deletion
@@ -962,6 +962,14 @@ def check_unsafe_protocols(cls, url: str) -> None:
                 f"The `{protocol}` protocol looks suspicious, use `allow_unsafe_protocols=True` to allow it."
             )
 
+    def _check_unsafe_protocols_in_args(self, args: Sequence[Any], kwargs: Mapping[str, Any]) -> None:
+        """Check positional operands and standalone values in rendered command options.
+
+        A short flag's split value can become the repository operand before ``--``.
+        """
+        for arg in self._unpack_args(args) + self.transform_kwargs(**kwargs):
+            self.check_unsafe_protocols(arg)
+
     @classmethod
     def _canonicalize_option_name(cls, option: str) -> str:
         """Return the option name used for unsafe-option checks.
@@ -1148,12 +1156,7 @@ def ls_remote(
             candidate_options = self._option_candidates(args, kwargs)
             Git.check_unsafe_options(options=candidate_options, unsafe_options=self.unsafe_git_ls_remote_options)
         if not allow_unsafe_protocols:
-            protocol_args = list(args)
-            if kwargs.get("split_single_char_options", True):
-                # Split short-option values can become the URL after parsing earlier options.
-                protocol_args.extend(value for key, value in kwargs.items() if len(key) == 1)
-            for arg in self._unpack_args(protocol_args):
-                self.check_unsafe_protocols(arg)
+            self._check_unsafe_protocols_in_args(args, kwargs)
         return self._call_process("ls_remote", *args, **kwargs)
 
     @property
 
@@ -1073,9 +1073,7 @@ def fetch(
             args = [refspec]
 
         if not allow_unsafe_protocols:
-            for ref in args:
-                if ref:
-                    Git.check_unsafe_protocols(ref)
+            self.repo.git._check_unsafe_protocols_in_args([self, *args], kwargs)
 
         if not allow_unsafe_options:
             Git.check_unsafe_options(
@@ -1084,7 +1082,7 @@ def fetch(
             )
 
         proc = self.repo.git.fetch(
-            "--", self, *args, as_process=True, with_stdout=False, universal_newlines=True, v=verbose, **kwargs
+            "--", self, *args, as_process=True, with_stdout=False, universal_newlines=True, v=bool(verbose), **kwargs
         )
         res = self._get_fetch_info_from_stderr(proc, progress, kill_after_timeout=kill_after_timeout)
         if hasattr(self.repo.odb, "update_cache"):
@@ -1138,8 +1136,7 @@ def pull(
             if operand.startswith("-"):
                 raise UnsafeOptionError("Remote names and pull refspecs must not start with '-'.")
         if not allow_unsafe_protocols:
-            for ref in refspec:
-                Git.check_unsafe_protocols(ref)
+            self.repo.git._check_unsafe_protocols_in_args([self, *refspec], kwargs)
 
         if not allow_unsafe_options:
             Git.check_unsafe_options(
@@ -1214,8 +1211,7 @@ def push(
 
         refspec = Git._unpack_args(refspec or [])
         if not allow_unsafe_protocols:
-            for ref in refspec:
-                Git.check_unsafe_protocols(ref)
+            self.repo.git._check_unsafe_protocols_in_args([self, *refspec], kwargs)
 
         if not allow_unsafe_options:
             Git.check_unsafe_options(
 
@@ -5,7 +5,7 @@
 
 import pytest
 
-from git import Actor, Git, GitCommandError, Repo
+from git import Actor, Git, GitCommandError, Remote, Repo
 from git.exc import UnsafeOptionError, UnsafeProtocolError
 
 
@@ -103,6 +103,89 @@ def test_ls_remote_unsafe_opt_ins_are_independent():
         run.assert_called_once_with([Git.GIT_PYTHON_GIT_EXECUTABLE, "ls-remote", "--upload-pack=helper", "ext::helper"])
 
 
+@pytest.mark.parametrize("method", ["fetch", "pull", "push"])
+@pytest.mark.parametrize("allow_unsafe_options", [False, True])
+@pytest.mark.parametrize(
+    "name, kwargs",
+    [
+        ("origin", {"q": "ext::helper"}),
+        ("origin", {"q": "ext://helper"}),
+        ("origin", {"q": [True, "ext::helper"]}),
+        ("origin", {"q": (None, False, True, "custom::address")}),
+        ("origin", {"-": "ext::helper"}),
+        ("ext::helper", {}),
+        ("ext://helper", {}),
+    ],
+)
+def test_remote_protocol_guards_check_rendered_operands(tmp_path, method, allow_unsafe_options, name, kwargs):
+    with Repo.init(tmp_path) as repo:
+        remote = Remote(repo, name)
+        with mock.patch.object(Git, "execute", side_effect=AssertionError("Git must not run")) as run:
+            with pytest.raises(UnsafeProtocolError):
+                getattr(remote, method)("HEAD", allow_unsafe_options=allow_unsafe_options, **kwargs)
+            run.assert_not_called()
+
+
+@pytest.mark.parametrize("method", ["fetch", "pull", "push"])
+@pytest.mark.parametrize(
+    "kwargs, token",
+    [
+        ({"q": True}, "-q"),
+        ({"q": [None, False, True]}, "-q"),
+        ({"q": "https://[::1]/repo.git"}, "https://[::1]/repo.git"),
+        ({"o": "ext::literal", "split_single_char_options": False}, "-oext::literal"),
+        ({"server_option": "ext::literal"}, "--server-option=ext::literal"),
+    ],
+)
+def test_remote_protocol_guards_preserve_safe_rendered_arguments(tmp_path, method, kwargs, token):
+    with Repo.init(tmp_path) as repo:
+        remote = Remote(repo, "origin")
+        error = GitCommandError("captured command", 128)
+        with mock.patch.object(Git, "execute", side_effect=error) as run:
+            with pytest.raises(GitCommandError) as raised:
+                getattr(remote, method)("HEAD", **kwargs)
+            assert raised.value is error
+            run.assert_called_once()
+            argv = run.call_args[0][0]
+            assert token in argv
+            assert argv[-3:] == ["--", "origin", "HEAD"]
+
+
+@pytest.mark.parametrize("method", ["fetch", "pull", "push"])
+def test_remote_protocol_and_option_opt_ins_are_independent(tmp_path, method):
+    with Repo.init(tmp_path) as repo:
+        remote = Remote(repo, "origin")
+        kwargs = {"q": "ext::helper"}
+        option = "receive_pack" if method == "push" else "upload_pack"
+        error = GitCommandError("captured command", 128)
+        with mock.patch.object(Git, "execute", side_effect=error) as run:
+            with pytest.raises(UnsafeOptionError):
+                getattr(remote, method)("HEAD", allow_unsafe_protocols=True, **kwargs, **{option: "helper"})
+            run.assert_not_called()
+
+            with pytest.raises(GitCommandError) as raised:
+                getattr(remote, method)("HEAD", allow_unsafe_protocols=True, **kwargs)
+            assert raised.value is error
+            run.assert_called_once()
+            argv = run.call_args[0][0]
+            assert argv[argv.index("-q") + 1] == "ext::helper"
+            assert argv[-3:] == ["--", "origin", "HEAD"]
+            assert not any(arg.startswith("--allow-unsafe") for arg in argv)
+
+
+@pytest.mark.parametrize("verbose", ["ext::helper", "--upload-pack=helper"])
+def test_fetch_verbose_cannot_introduce_operands_or_options(tmp_path, verbose):
+    with Repo.init(tmp_path) as repo:
+        remote = Remote(repo, "origin")
+        error = GitCommandError("captured command", 128)
+        with mock.patch.object(Git, "execute", side_effect=error) as run:
+            with pytest.raises(GitCommandError) as raised:
+                remote.fetch("HEAD", verbose=verbose)
+            assert raised.value is error
+            run.assert_called_once()
+            assert run.call_args[0][0] == [Git.GIT_PYTHON_GIT_EXECUTABLE, "fetch", "-v", "--", "origin", "HEAD"]
+
+
 @pytest.mark.parametrize("allow_unsafe_options", [False, True])
 @pytest.mark.parametrize(
     "revs, kwargs",