@@ -151,15 +151,29 @@ def listen(self, port):
         self.server.bind((LOOPBACK, port))
         self.server.listen()
         self.port = self.server.getsockname()[1]
-        threading.Thread(target=self._accept, name="python-multiplatform-devagent", daemon=True).start()
+        self.accept_thread = threading.Thread(target=self._accept, name="python-multiplatform-devagent", daemon=True)
+        self.accept_thread.start()
 
     def stop(self):
+        """Stop listening and close every connection; the port is free when this returns."""
+        # On Linux, close() alone leaves a socket that another thread is blocked accepting on in LISTEN, so the
+        # port stays taken (a restarted agent's bind failed with EADDRINUSE there). shutdown() wakes accept().
+        # macOS refuses shutdown() on a listening socket (ENOTCONN), and there close() is enough.
+        try:
+            self.server.shutdown(socket.SHUT_RDWR)
+        except OSError:
+            pass
         try:
             self.server.close()
         except OSError:
             pass
-        for connection in list(self.connections):
+        connections = list(self.connections)
+        for connection in connections:
             connection.shutdown()
+        current = threading.current_thread()
+        for thread in [self.accept_thread] + [c.thread for c in connections]:
+            if thread is not None and thread is not current:
+                thread.join(timeout=5)
 
     def _accept(self):
         while True:
@@ -169,11 +183,13 @@ def _accept(self):
                 return
             connection = _Connection(self, sock)
             self.connections.append(connection)
-            threading.Thread(target=connection.serve, name="python-multiplatform-devagent-client", daemon=True).start()
+            connection.thread = threading.Thread(target=connection.serve, name="python-multiplatform-devagent-client", daemon=True)
+            connection.thread.start()
 
 
 class _Connection:
     def __init__(self, agent, sock):
+        self.thread = None
         self.agent = agent
         self.sock = sock
         self.reader = sock.makefile("r", encoding="utf-8")
@@ -298,9 +314,7 @@ def _push(self, request_id, message):
         written = []
         try:
             for relative, text in (message.get("files") or {}).items():
-                normal = os.path.normpath(relative)
-                if os.path.isabs(relative) or normal.startswith("..") or normal == "." or not normal.endswith(".py"):
-                    raise ValueError(f"{relative!r} is not a .py path inside the overlay")
+                normal = self._overlay_path(relative)
                 target = os.path.join(overlay, normal)
                 os.makedirs(os.path.dirname(target), exist_ok=True)
                 with open(target, "w", encoding="utf-8") as f:
@@ -327,6 +341,29 @@ def _push(self, request_id, message):
             reloaded.append(name)
         self._done(request_id, written=written, reloaded=reloaded)
 
+    def _overlay_path(self, relative):
+        """A pushed path, checked by the protocol's own rule rather than os.path's, as an OS path in the overlay.
+
+        os.path differs per platform: on Windows `isabs("/x")` is False (Python 3.13+) and joining such a path to
+        the overlay lands on the drive root. So a path must be `/`-separated and relative, with no backslash, no
+        drive colon, and no empty, `.` or `..` segment, and must still resolve inside the overlay.
+        """
+        segments = relative.split("/") if isinstance(relative, str) else []
+        if (
+            not segments
+            or "\\" in relative
+            or ":" in relative
+            or any(segment in ("", ".", "..") for segment in segments)
+            or not segments[-1].endswith(".py")
+        ):
+            raise ValueError(f"{relative!r} is not a relative /-separated .py path inside the overlay")
+        normal = os.path.join(*segments)
+        overlay = os.path.realpath(self.agent.overlay)
+        target = os.path.realpath(os.path.join(overlay, normal))
+        if os.path.commonpath([overlay, target]) != overlay:
+            raise ValueError(f"{relative!r} resolves outside the overlay")
+        return normal
+
     @staticmethod
     def _module_name(path):
         parts = path[: -len(".py")].replace(os.sep, "/").split("/")
 
@@ -141,7 +141,7 @@ def test_a_short_token_is_refused_before_anything_listens(self):
     def test_another_socket_cannot_take_the_port_over(self):
         agent = devagent.start(port=0, token=TOKEN, overlay=tempfile.mkdtemp())
         try:
-            options = [socket.SO_REUSEADDR] + [getattr(socket, "SO_REUSEPORT")] * hasattr(socket, "SO_REUSEPORT")
+            options = [socket.SO_REUSEADDR] + ([socket.SO_REUSEPORT] if hasattr(socket, "SO_REUSEPORT") else [])
             for option in options:
                 hijacker = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
                 try:
@@ -260,7 +260,10 @@ def test_a_reload_that_fails_keeps_the_old_module(self):
         self.assertEqual("1", self.of_type(replies, "result")[0]["data"]["text/plain"])
 
     def test_a_path_outside_the_overlay_is_refused(self):
-        for path in ["../escape.py", "/abs/escape.py", "a/../../escape.py"]:
+        # Windows forms too, on every OS: on Windows `os.path.isabs("/abs/escape.py")` is False (Python 3.13+)
+        # and joining it to the overlay lands on the drive root, so the rule cannot be os.path's.
+        for path in ["../escape.py", "/abs/escape.py", "a/../../escape.py", "C:/escape.py", "C:escape.py",
+                     "\\escape.py", "a\\..\\..\\escape.py", "//server/share/escape.py", "./a.py", "a//b.py", ""]:
             done = self.done(self.client.request("push", files={path: "X = 1\n"}))
             self.assertEqual("error", done["status"], path)
             self.assertEqual("ValueError", done["ename"], path)