From 1b1e92f927d1a4a39ef5daae2dde9a73de067029 Mon Sep 17 00:00:00 2001
From: Yiyi Xu <xuyiyi0516@gmail.com>
Date: Tue, 23 Jun 2026 17:03:52 +0200
Subject: [PATCH 1/7] Fix drone emergency stop on deployment interrupt

---
 swarm_gpt/core/backend.py      | 12 ++++++-
 swarm_gpt/core/drone_swarm.py  | 16 ++++++++--
 tests/unit/test_backend.py     | 58 ++++++++++++++++++++++++++++++++++
 tests/unit/test_drone_swarm.py | 41 ++++++++++++++++++++++++
 4 files changed, 124 insertions(+), 3 deletions(-)

diff --git a/swarm_gpt/core/backend.py b/swarm_gpt/core/backend.py
index e34c9e2..6dc6f27 100644
--- a/swarm_gpt/core/backend.py
+++ b/swarm_gpt/core/backend.py
@@ -378,9 +378,19 @@ def deploy(self, drone_ids: list[int] | None = None) -> bool:
                     )
             self.music_manager.stop()
             swarm.goto(final_pos_dict, duration=2.0)  # Transition from ideal point to hover pos
-            if self.settings["land_on_docks"]: # Commented out for demo
+            if self.settings["land_on_docks"]:  # Commented out for demo
                 swarm.goto(final_pos_dict, duration=3.0)  # Hovering
             swarm.land(duration=1.5)  # Landing
+        except BaseException:
+            try:
+                swarm.emergency_stop()
+            except Exception as e:
+                logger.error(f"Emergency stop after deployment interrupt failed: {e}")
+            try:
+                self.music_manager.stop()
+            except Exception as e:
+                logger.error(f"Stopping music after deployment interrupt failed: {e}")
+            raise
         finally:
             swarm.close()
         logger.info("Deployment successful")
diff --git a/swarm_gpt/core/drone_swarm.py b/swarm_gpt/core/drone_swarm.py
index eebfbf0..e732d8e 100644
--- a/swarm_gpt/core/drone_swarm.py
+++ b/swarm_gpt/core/drone_swarm.py
@@ -348,8 +348,20 @@ async def _close() -> None:
     def _run(self, coroutine: Awaitable[Any]) -> Any:
         """Run a cflib2 coroutine on the swarm event loop."""
         if self._loop_thread is not None:
-            return asyncio.run_coroutine_threadsafe(coroutine, self._loop).result()
-        return self._loop.run_until_complete(coroutine)
+            future = asyncio.run_coroutine_threadsafe(coroutine, self._loop)
+            try:
+                return future.result()
+            except BaseException:
+                future.cancel()
+                raise
+
+        task = self._loop.create_task(coroutine)
+        try:
+            return self._loop.run_until_complete(task)
+        except BaseException:
+            task.cancel()
+            self._loop.run_until_complete(asyncio.gather(task, return_exceptions=True))
+            raise
 
     def _start_estimator_updater(self) -> None:
         """Start continuous mocap updates after the radio links are connected."""
diff --git a/tests/unit/test_backend.py b/tests/unit/test_backend.py
index 8a33cb0..749c335 100644
--- a/tests/unit/test_backend.py
+++ b/tests/unit/test_backend.py
@@ -1,7 +1,10 @@
 from pathlib import Path
 
+import numpy as np
+import pytest
 from conftest import virtual_crazyswarm_config
 
+import swarm_gpt.core.drone_swarm as drone_swarm
 from swarm_gpt.core.backend import AppBackend
 
 
@@ -46,3 +49,58 @@ def test_preset_metadata_and_delete(tmp_path: Path):
 
     app.delete_preset(preset_id)
     assert not (preset_dir / preset_id).exists()
+
+
+def test_deploy_emergency_stops_before_close_on_keyboard_interrupt(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    class InterruptingSwarm:
+        instances = []
+
+        def __init__(self, drones: dict, *, lighthouse: bool) -> None:
+            self.drones_by_uri = {drone["uri"]: drone for drone in drones.values()}
+            self.calls: list[str] = []
+            self.instances.append(self)
+
+        def get_obs(self, uri: str) -> dict[str, np.ndarray]:
+            pos = np.asarray(self.drones_by_uri[uri]["pos"], dtype=float)
+            if "goto" in self.calls:
+                pos = pos + np.array([0.0, 0.0, 0.5])
+            return {"pos": pos, "quat": np.array([0.0, 0.0, 0.0, 1.0])}
+
+        def goto(self, target: dict[str, np.ndarray], duration: float = 3.0) -> None:
+            self.calls.append("goto")
+
+        def is_active(self, uri: str) -> bool:
+            return uri in self.drones_by_uri
+
+        def execute_choreography(self, *args: object, **kwargs: object) -> None:
+            self.calls.append("execute_choreography")
+            raise KeyboardInterrupt
+
+        def emergency_stop(self) -> None:
+            self.calls.append("emergency_stop")
+
+        def land(self, height: float = 0.0, duration: float = 3.0) -> None:
+            self.calls.append("land")
+
+        def close(self) -> None:
+            self.calls.append("close")
+
+    config_path = virtual_crazyswarm_config(n_drones=1)
+    app = AppBackend(config_file=config_path)
+    app.settings["lighthouse"] = True
+    app.settings["land_on_docks"] = False
+    app.music_manager.song = "Crazyflie Drones Theme"
+    app.music_manager.verify_libvlc = lambda: True
+    app.music_manager.play = lambda *, wait, start_s, end_s: True
+    app.music_manager.stop = lambda: None
+    app.waypoints = {"time": np.array([[0.0, 1.0]])}
+    app.splines[0] = lambda t: np.array([0.0, 0.0, 1.0])
+    monkeypatch.setattr(drone_swarm, "DroneSwarm", InterruptingSwarm)
+
+    with pytest.raises(KeyboardInterrupt):
+        app.deploy()
+
+    swarm = InterruptingSwarm.instances[0]
+    assert swarm.calls == ["goto", "execute_choreography", "emergency_stop", "close"]
diff --git a/tests/unit/test_drone_swarm.py b/tests/unit/test_drone_swarm.py
index d96394a..dc46132 100644
--- a/tests/unit/test_drone_swarm.py
+++ b/tests/unit/test_drone_swarm.py
@@ -93,6 +93,47 @@ def make_swarm(uris: list[str]) -> DroneSwarm:
     return swarm
 
 
+def test_run_cancels_threadsafe_command_when_keyboard_interrupt_escapes(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    class InterruptingFuture:
+        def __init__(self) -> None:
+            self.cancelled = False
+
+        def result(self) -> None:
+            raise KeyboardInterrupt
+
+        def cancel(self) -> None:
+            self.cancelled = True
+
+    future = InterruptingFuture()
+    captured: dict[str, Any] = {}
+    swarm = make_swarm([])
+    swarm._loop_thread = threading.Thread()
+
+    async def command() -> None:
+        return None
+
+    def run_coroutine_threadsafe(
+        coroutine: Any, loop: asyncio.AbstractEventLoop
+    ) -> InterruptingFuture:
+        captured["coroutine"] = coroutine
+        captured["loop"] = loop
+        return future
+
+    monkeypatch.setattr(asyncio, "run_coroutine_threadsafe", run_coroutine_threadsafe)
+
+    try:
+        with pytest.raises(KeyboardInterrupt):
+            swarm._run(command())
+    finally:
+        captured["coroutine"].close()
+        swarm._loop.close()
+
+    assert captured["loop"] is swarm._loop
+    assert future.cancelled
+
+
 def test_setpoint_sends_once_and_returns():
     uris = ["radio://0/80/2M/E7E7E7E701", "radio://0/80/2M/E7E7E7E702"]
     swarm = make_swarm(uris)

From 98cee043542d3e7000a42ffc3dbf710b9387f679 Mon Sep 17 00:00:00 2001
From: Yiyi Xu <xuyiyi0516@gmail.com>
Date: Tue, 23 Jun 2026 17:40:58 +0200
Subject: [PATCH 2/7] attempt to estop again and adding it to frontend

---
 swarm_gpt/api/server.py        | 13 ++++++
 swarm_gpt/core/backend.py      | 15 ++++++-
 swarm_gpt/core/drone_swarm.py  | 31 ++++++++++----
 tests/unit/test_api.py         | 74 ++++++++++++++++++++++++++++++++++
 tests/unit/test_backend.py     | 21 ++++++++++
 tests/unit/test_drone_swarm.py | 38 +++++++++++++++++
 web/src/App.tsx                | 39 ++++++++++++++++++
 web/src/api.ts                 |  7 ++++
 web/src/styles.css             | 12 +++++-
 web/tests/player.spec.js       | 48 ++++++++++++++++++++++
 10 files changed, 289 insertions(+), 9 deletions(-)

diff --git a/swarm_gpt/api/server.py b/swarm_gpt/api/server.py
index 568cc9a..bd6987b 100644
--- a/swarm_gpt/api/server.py
+++ b/swarm_gpt/api/server.py
@@ -472,6 +472,19 @@ def deploy(job_id: str) -> dict[str, Any]:
         _start_thread(job, lambda: _run_deploy_job(store, job))
         return {"jobId": job.id}
 
+    @app.post("/api/jobs/{job_id}/emergency-stop")
+    def emergency_stop(job_id: str) -> dict[str, Any]:
+        try:
+            job = store.get(job_id)
+        except KeyError:
+            raise HTTPException(status_code=404, detail="Job not found") from None
+        try:
+            job.backend.emergency_stop_active_swarm()
+        except RuntimeError as exc:
+            raise HTTPException(status_code=409, detail=str(exc)) from exc
+        store.emit(job, "emergency_stop_sent", {})
+        return {"jobId": job.id, "emergencyStopped": True}
+
     @app.post("/api/jobs/{job_id}/preset")
     def save_preset(job_id: str) -> dict[str, Any]:
         try:
diff --git a/swarm_gpt/core/backend.py b/swarm_gpt/core/backend.py
index 6dc6f27..8a8e012 100644
--- a/swarm_gpt/core/backend.py
+++ b/swarm_gpt/core/backend.py
@@ -119,6 +119,7 @@ def __init__(
         self._preset: None | str = None
         self._strict_processing = strict_processing
         self._strict_drone_match = strict_drone_match
+        self._active_swarm: Any | None = None
         if set(self.songs) & set(self.presets):
             raise ValueError("Songs and presets must have unique names")
 
@@ -299,6 +300,7 @@ def deploy(self, drone_ids: list[int] | None = None) -> bool:
             return False
 
         swarm = DroneSwarm(self.choreographer.drones, lighthouse=self.settings["lighthouse"])
+        self._active_swarm = swarm
         logger.info("Swarm connected...")
 
         # generate references
@@ -392,10 +394,21 @@ def deploy(self, drone_ids: list[int] | None = None) -> bool:
                 logger.error(f"Stopping music after deployment interrupt failed: {e}")
             raise
         finally:
-            swarm.close()
+            try:
+                swarm.close()
+            finally:
+                self._active_swarm = None
         logger.info("Deployment successful")
         return True
 
+    def emergency_stop_active_swarm(self) -> None:
+        """Emergency-stop the currently active deployment swarm, if one exists."""
+        swarm = self._active_swarm
+        if swarm is None:
+            raise RuntimeError("No active deployment swarm to emergency stop.")
+        swarm.emergency_stop()
+        self.music_manager.stop()
+
     def load_preset(self, preset_id: str) -> str:
         """Load a preset response.
 
diff --git a/swarm_gpt/core/drone_swarm.py b/swarm_gpt/core/drone_swarm.py
index e732d8e..da3c62b 100644
--- a/swarm_gpt/core/drone_swarm.py
+++ b/swarm_gpt/core/drone_swarm.py
@@ -34,6 +34,7 @@
 _DISCONNECT_ERRORS = (DisconnectedError, LinkError, TimeoutError)
 _LIGHTHOUSE_DECK_PARAM = "deck.bcLighthouse4"
 _POWER_CYCLE_BOOT_WAIT = 3.0
+_EMERGENCY_STOP_TIMEOUT = 0.5
 _CommanderLevel = Literal["low", "high"]
 
 
@@ -268,7 +269,7 @@ def emergency_stop(self, uri: str | None = None):
         else:
             self._validate_known_uris("uri", {uri: None})
             uris = [uri]
-        self._run(self._parallel_by_uri("Emergency stop", uris, self._emergency_stop, timeout=0.5))
+        self._run(self._emergency_stop_many(uris))
 
     def reset(self):
         """Reset all active drones."""
@@ -312,12 +313,10 @@ async def _shutdown_leds(uri: str) -> None:
             await self._apply_drone_color(uri, np.zeros(4), "both")
 
         async def _close() -> None:
-            active_uris = [uri for uri in self.uris if uri in self.active_uris]
+            active_uris = [uri for uri in self.uris if uri in self.cfs]
             if active_uris:
                 try:
-                    await self._parallel_by_uri(
-                        "Emergency stop", active_uris, self._emergency_stop, timeout=0.5
-                    )
+                    await self._emergency_stop_many(active_uris)
                     await asyncio.sleep(0.1)
                     await self._parallel_by_uri(
                         "Shutdown LEDs", active_uris, _shutdown_leds, timeout=0.5
@@ -347,7 +346,7 @@ async def _close() -> None:
 
     def _run(self, coroutine: Awaitable[Any]) -> Any:
         """Run a cflib2 coroutine on the swarm event loop."""
-        if self._loop_thread is not None:
+        if self._loop_thread is not None or self._loop.is_running():
             future = asyncio.run_coroutine_threadsafe(coroutine, self._loop)
             try:
                 return future.result()
@@ -489,8 +488,26 @@ async def _parallel_by_uri(
                 logger.error(f"{action_name} failed for {uri}: {result}")
         return results
 
+    async def _emergency_stop_many(self, uris: Iterable[str]) -> None:
+        """Best-effort emergency stop for every connected URI without cross-drone blocking."""
+        target_uris = [uri for uri in uris if uri in self.cfs]
+
+        async def _stop_one(uri: str) -> None:
+            try:
+                await asyncio.wait_for(self._emergency_stop(uri), timeout=_EMERGENCY_STOP_TIMEOUT)
+                self._commander_levels[uri] = None
+            except Exception as exc:
+                if isinstance(exc, _DISCONNECT_ERRORS):
+                    self.active_uris.discard(uri)
+                    self._commander_levels[uri] = None
+                    logger.error(f"{uri} disconnected or unreachable. Emergency stop failed: {exc}")
+                else:
+                    logger.error(f"Emergency stop failed for {uri}: {exc}")
+
+        await asyncio.gather(*[_stop_one(uri) for uri in target_uris])
+
     async def _emergency_stop(self, uri: str) -> None:
-        await self._cf(uri).localization().emergency().send_emergency_stop()
+        await self.cfs[uri].localization().emergency().send_emergency_stop()
 
     async def _change_commander_level(self, uri: str, level: _CommanderLevel) -> None:
         """Switch commander level only when local state expects a different mode."""
diff --git a/tests/unit/test_api.py b/tests/unit/test_api.py
index efeb997..c7b629e 100644
--- a/tests/unit/test_api.py
+++ b/tests/unit/test_api.py
@@ -1,3 +1,6 @@
+import threading
+import time
+from collections.abc import Generator
 from pathlib import Path
 from types import SimpleNamespace
 from urllib.parse import quote
@@ -6,6 +9,7 @@
 import pytest
 from fastapi.testclient import TestClient
 
+import swarm_gpt.api.server as server
 from swarm_gpt.api.server import ApiConfig, _backend_from_config, create_app, normalize_playback
 from swarm_gpt.utils.llm_providers import DEFAULT_OPENAI_MODEL_CHOICES
 
@@ -79,3 +83,73 @@ def test_library_returns_preset_display_metadata_and_delete(tmp_path: Path):
     delete_response.raise_for_status()
     assert delete_response.json() == {"deleted": preset_id}
     assert not (preset_dir / preset_id).exists()
+
+
+def test_emergency_stop_endpoint_runs_while_deploy_is_active(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    class DeployingBackend:
+        def __init__(self) -> None:
+            self.songs = ["Test Song"]
+            self.presets: list[str] = []
+            self.settings = {"axswarm": {"pos_min": [-1, -1, 0], "pos_max": [1, 1, 2]}}
+            self.music_manager = SimpleNamespace(song="Test Song")
+            self.splines: dict[int, object] = {}
+            self.deploy_entered = threading.Event()
+            self.stop_requested = threading.Event()
+            self.emergency_stop_calls = 0
+
+        def initial_prompt(self, selection: str) -> list[dict[str, str]]:
+            return []
+
+        def simulate(self) -> Generator[None, None, dict[str, object]]:
+            self.splines[0] = object()
+            states = np.zeros((1, 1, 13))
+            states[:, :, 3:7] = [0, 0, 0, 1]
+            if False:
+                yield None
+            return {"timestamps": np.array([0.0]), "states": states, "num_drones": 1}
+
+        def crop_window(self, song: str) -> tuple[float, float]:
+            return (0.0, 60.0)
+
+        def deploy(self) -> bool:
+            self.deploy_entered.set()
+            self.stop_requested.wait(timeout=2.0)
+            return True
+
+        def emergency_stop_active_swarm(self) -> None:
+            self.emergency_stop_calls += 1
+            self.stop_requested.set()
+
+    backends: list[DeployingBackend] = []
+
+    def backend_from_config(config: ApiConfig, provider: str, model_id: str) -> DeployingBackend:
+        backend = DeployingBackend()
+        backends.append(backend)
+        return backend
+
+    (tmp_path / "Test Song.mp3").write_bytes(b"")
+    monkeypatch.setattr(server, "_backend_from_config", backend_from_config)
+    client = TestClient(create_app(ApiConfig(music_dir=tmp_path)))
+
+    create_response = client.post(
+        "/api/jobs", json={"selection": "Test Song", "provider": "openai", "modelId": "gpt"}
+    )
+    create_response.raise_for_status()
+    job_id = create_response.json()["jobId"]
+    backend = backends[0]
+    for _ in range(50):
+        if client.get(f"/api/jobs/{job_id}").json()["status"] == "ready":
+            break
+        time.sleep(0.01)
+
+    deploy_response = client.post(f"/api/jobs/{job_id}/deploy")
+    deploy_response.raise_for_status()
+    assert backend.deploy_entered.wait(timeout=1.0)
+
+    stop_response = client.post(f"/api/jobs/{job_id}/emergency-stop")
+    stop_response.raise_for_status()
+
+    assert stop_response.json() == {"jobId": job_id, "emergencyStopped": True}
+    assert backend.emergency_stop_calls == 1
diff --git a/tests/unit/test_backend.py b/tests/unit/test_backend.py
index 749c335..111cffb 100644
--- a/tests/unit/test_backend.py
+++ b/tests/unit/test_backend.py
@@ -104,3 +104,24 @@ def close(self) -> None:
 
     swarm = InterruptingSwarm.instances[0]
     assert swarm.calls == ["goto", "execute_choreography", "emergency_stop", "close"]
+
+
+def test_emergency_stop_active_swarm_stops_live_swarm_and_music() -> None:
+    class ActiveSwarm:
+        def __init__(self) -> None:
+            self.calls: list[str] = []
+
+        def emergency_stop(self) -> None:
+            self.calls.append("emergency_stop")
+
+    config_path = virtual_crazyswarm_config(n_drones=1)
+    app = AppBackend(config_file=config_path)
+    swarm = ActiveSwarm()
+    music_calls: list[str] = []
+    app._active_swarm = swarm
+    app.music_manager.stop = lambda: music_calls.append("stop")
+
+    app.emergency_stop_active_swarm()
+
+    assert swarm.calls == ["emergency_stop"]
+    assert music_calls == ["stop"]
diff --git a/tests/unit/test_drone_swarm.py b/tests/unit/test_drone_swarm.py
index dc46132..4a79966 100644
--- a/tests/unit/test_drone_swarm.py
+++ b/tests/unit/test_drone_swarm.py
@@ -134,6 +134,24 @@ def run_coroutine_threadsafe(
     assert future.cancelled
 
 
+def test_run_schedules_threadsafe_when_loop_is_already_running():
+    swarm = make_swarm([])
+    swarm._loop_thread = None
+
+    async def command() -> str:
+        return "stopped"
+
+    thread = threading.Thread(target=swarm._loop.run_forever)
+    thread.start()
+
+    try:
+        assert swarm._run(command()) == "stopped"
+    finally:
+        swarm._loop.call_soon_threadsafe(swarm._loop.stop)
+        thread.join()
+        swarm._loop.close()
+
+
 def test_setpoint_sends_once_and_returns():
     uris = ["radio://0/80/2M/E7E7E7E701", "radio://0/80/2M/E7E7E7E702"]
     swarm = make_swarm(uris)
@@ -150,6 +168,26 @@ def test_setpoint_sends_once_and_returns():
         assert cf.fake_param.values == [("commander.enHighLevel", 0)]
 
 
+def test_emergency_stop_one_hung_drone_does_not_block_others():
+    uris = ["radio://0/80/2M/E7E7E7E701", "radio://0/80/2M/E7E7E7E702"]
+    swarm = make_swarm(uris)
+    stopped: list[str] = []
+
+    async def emergency_stop(uri: str) -> None:
+        if uri == uris[0]:
+            await asyncio.sleep(1)
+        stopped.append(uri)
+
+    swarm._emergency_stop = emergency_stop
+
+    try:
+        swarm.emergency_stop()
+    finally:
+        swarm._loop.close()
+
+    assert stopped == [uris[1]]
+
+
 def test_estimator_updater_copies_batch_and_skips_inactive_drones():
     uris = [
         "radio://0/80/2M/E7E7E7E701",
diff --git a/web/src/App.tsx b/web/src/App.tsx
index dc48d4c..1f5b72a 100644
--- a/web/src/App.tsx
+++ b/web/src/App.tsx
@@ -16,6 +16,7 @@ import {
   createJob,
   deletePreset,
   deployJob,
+  emergencyStopJob,
   getLibrary,
   getLlm,
   getPlayback,
@@ -67,6 +68,7 @@ export function App() {
   const [presetNotice, setPresetNotice] = useState<string | null>(null);
   const [savingPreset, setSavingPreset] = useState(false);
   const [deletingPreset, setDeletingPreset] = useState<string | null>(null);
+  const [emergencyStopping, setEmergencyStopping] = useState(false);
   const socketRef = useRef<WebSocket | null>(null);
 
   const providerInfo = llm?.providers.find((entry) => entry.id === provider);
@@ -141,8 +143,13 @@ export function App() {
       if (event.type === "deploy_complete") {
         setStage("ready");
       }
+      if (event.type === "emergency_stop_sent") {
+        setPresetNotice("Emergency stop sent.");
+        setEmergencyStopping(false);
+      }
       if (event.type === "failed") {
         setStage((current) => (current === "deploying" ? "ready" : "failed"));
+        setEmergencyStopping(false);
         setError(String(event.payload.message ?? "Job failed"));
       }
     };
@@ -158,6 +165,7 @@ export function App() {
     setPlayback(null);
     setError(null);
     setPresetNotice(null);
+    setEmergencyStopping(false);
     setProgress(0);
     setStage("thinking");
     setDetailsOpen(false);
@@ -195,6 +203,8 @@ export function App() {
       return;
     }
     setError(null);
+    setPresetNotice(null);
+    setEmergencyStopping(false);
     setStage("deploying");
     try {
       await deployJob(jobId);
@@ -204,6 +214,21 @@ export function App() {
     }
   };
 
+  const emergencyStop = async () => {
+    if (!jobId) {
+      return;
+    }
+    setError(null);
+    setPresetNotice(null);
+    setEmergencyStopping(true);
+    try {
+      await emergencyStopJob(jobId);
+      setPresetNotice("Emergency stop sent.");
+    } finally {
+      setEmergencyStopping(false);
+    }
+  };
+
   const saveSafePreset = async () => {
     if (!jobId) {
       return;
@@ -255,6 +280,7 @@ export function App() {
     setRefineText("");
     setError(null);
     setPresetNotice(null);
+    setEmergencyStopping(false);
   };
 
   if (stage === "playing" && playback) {
@@ -463,6 +489,19 @@ export function App() {
               </div>
             )}
 
+            {stage === "deploying" && (
+              <div className="ready-actions">
+                <button
+                  className="danger-action"
+                  disabled={emergencyStopping}
+                  onClick={() => emergencyStop().catch((err: Error) => setError(err.message))}
+                >
+                  <X size={18} />
+                  {emergencyStopping ? "Stopping" : "E-stop"}
+                </button>
+              </div>
+            )}
+
             {stage === "failed" && (
               <div className="ready-actions">
                 <button className="secondary-action" onClick={reset}>
diff --git a/web/src/api.ts b/web/src/api.ts
index dc1f125..9090af3 100644
--- a/web/src/api.ts
+++ b/web/src/api.ts
@@ -59,6 +59,13 @@ export function deployJob(jobId: string) {
   return request<{ jobId: string }>(`/api/jobs/${jobId}/deploy`, { method: "POST" });
 }
 
+export function emergencyStopJob(jobId: string) {
+  return request<{ jobId: string; emergencyStopped: boolean }>(
+    `/api/jobs/${jobId}/emergency-stop`,
+    { method: "POST" }
+  );
+}
+
 export function savePreset(jobId: string) {
   return request<{ preset: LibraryItem }>(`/api/jobs/${jobId}/preset`, { method: "POST" });
 }
diff --git a/web/src/styles.css b/web/src/styles.css
index 9ce1be1..f4c6856 100644
--- a/web/src/styles.css
+++ b/web/src/styles.css
@@ -229,6 +229,7 @@ textarea {
 
 .primary-action,
 .secondary-action,
+.danger-action,
 .icon-button {
   display: inline-flex;
   align-items: center;
@@ -257,6 +258,14 @@ textarea {
   padding: 0 14px;
 }
 
+.danger-action {
+  padding: 0 15px;
+  border: 1px solid rgba(255, 180, 168, 0.64);
+  color: #2b0806;
+  background: #ff8f7f;
+  font-weight: 900;
+}
+
 .compact {
   min-height: 36px;
   padding-inline: 11px;
@@ -490,7 +499,8 @@ button:disabled {
   }
 
   .primary-action,
-  .secondary-action {
+  .secondary-action,
+  .danger-action {
     width: 100%;
   }
 
diff --git a/web/tests/player.spec.js b/web/tests/player.spec.js
index d6460f8..1024760 100644
--- a/web/tests/player.spec.js
+++ b/web/tests/player.spec.js
@@ -315,3 +315,51 @@ test("deploy failure returns to ready controls", async ({ page }) => {
   await expect(page.getByRole("button", { name: "Refine" })).toBeVisible();
   await expect(page.getByRole("button", { name: "Deploy" })).toBeVisible();
 });
+
+test("deploying state shows e-stop button that sends emergency stop", async ({ page }) => {
+  await page.setViewportSize({ width: 1024, height: 768 });
+  await configurePage(page);
+  let emergencyStopRequested = false;
+  await page.route("**/api/jobs/job/deploy", async (route) => {
+    await route.fulfill({
+      status: 202,
+      contentType: "application/json",
+      body: JSON.stringify({ jobId: "job" })
+    });
+    await page.evaluate(() => {
+      setTimeout(() => {
+        window.__emitJobEvent({
+          id: 6,
+          type: "deploy_started",
+          createdAt: new Date().toISOString(),
+          payload: {}
+        });
+      }, 10);
+    });
+  });
+  await page.route("**/api/jobs/job/emergency-stop", async (route) => {
+    emergencyStopRequested = true;
+    await route.fulfill({
+      contentType: "application/json",
+      body: JSON.stringify({ jobId: "job", emergencyStopped: true })
+    });
+    await page.evaluate(() => {
+      window.__emitJobEvent({
+        id: 7,
+        type: "emergency_stop_sent",
+        createdAt: new Date().toISOString(),
+        payload: {}
+      });
+    });
+  });
+
+  await page.goto("http://127.0.0.1:5173/", { waitUntil: "networkidle" });
+  await page.getByRole("heading", { name: "Select a song" }).waitFor();
+  await page.locator(".song-card").filter({ hasText: "Harness" }).first().getByRole("button", { name: "Select" }).click();
+  await page.getByRole("button", { name: "Deploy" }).waitFor();
+  await page.getByRole("button", { name: "Deploy" }).click();
+  await page.getByRole("button", { name: "E-stop" }).click();
+
+  expect(emergencyStopRequested).toBeTruthy();
+  await expect(page.getByText("Emergency stop sent.")).toBeVisible();
+});

From 985c1c71a6c8eb5023a334a3232be8da50e2726a Mon Sep 17 00:00:00 2001
From: Yiyi Xu <xuyiyi0516@gmail.com>
Date: Tue, 23 Jun 2026 18:15:04 +0200
Subject: [PATCH 3/7] attempt 3

---
 swarm_gpt/api/server.py        | 13 +++++
 swarm_gpt/core/backend.py      | 10 ----
 swarm_gpt/core/drone_swarm.py  | 86 +++++++++++++++++++---------------
 swarm_gpt/launch.py            | 20 +++++++-
 tests/unit/test_api.py         | 20 ++++++++
 tests/unit/test_backend.py     | 58 -----------------------
 tests/unit/test_drone_swarm.py | 79 +++++++++++++++----------------
 7 files changed, 136 insertions(+), 150 deletions(-)

diff --git a/swarm_gpt/api/server.py b/swarm_gpt/api/server.py
index bd6987b..3a27ad0 100644
--- a/swarm_gpt/api/server.py
+++ b/swarm_gpt/api/server.py
@@ -166,6 +166,18 @@ def events_after(self, job_id: str, after_id: int) -> list[dict[str, Any]]:
             job = self.get(job_id)
             return [event for event in job.events if event["id"] > after_id]
 
+    def emergency_stop_all(self) -> None:
+        """Emergency-stop every job that currently has an active deployment swarm."""
+        with self._lock:
+            jobs = list(self._jobs.values())
+        for job in jobs:
+            try:
+                job.backend.emergency_stop_active_swarm()
+            except RuntimeError:
+                continue  # No active deployment swarm for this job.
+            except Exception:
+                logger.exception("Emergency stop failed for job %s", job.id)
+
 
 def _backend_from_config(config: ApiConfig, provider: LLMProvider, model_id: str) -> AppBackend:
     return AppBackend(
@@ -342,6 +354,7 @@ def create_app(config: ApiConfig | None = None) -> FastAPI:
     config = config or ApiConfig()
     store = JobStore()
     app = FastAPI(title="SwarmGPT Browser API", lifespan=_app_lifespan)
+    app.state.store = store
 
     @app.get("/api/library")
     def library() -> dict[str, Any]:
diff --git a/swarm_gpt/core/backend.py b/swarm_gpt/core/backend.py
index 8a8e012..7ddf05b 100644
--- a/swarm_gpt/core/backend.py
+++ b/swarm_gpt/core/backend.py
@@ -383,16 +383,6 @@ def deploy(self, drone_ids: list[int] | None = None) -> bool:
             if self.settings["land_on_docks"]:  # Commented out for demo
                 swarm.goto(final_pos_dict, duration=3.0)  # Hovering
             swarm.land(duration=1.5)  # Landing
-        except BaseException:
-            try:
-                swarm.emergency_stop()
-            except Exception as e:
-                logger.error(f"Emergency stop after deployment interrupt failed: {e}")
-            try:
-                self.music_manager.stop()
-            except Exception as e:
-                logger.error(f"Stopping music after deployment interrupt failed: {e}")
-            raise
         finally:
             try:
                 swarm.close()
diff --git a/swarm_gpt/core/drone_swarm.py b/swarm_gpt/core/drone_swarm.py
index da3c62b..dc10608 100644
--- a/swarm_gpt/core/drone_swarm.py
+++ b/swarm_gpt/core/drone_swarm.py
@@ -34,10 +34,13 @@
 _DISCONNECT_ERRORS = (DisconnectedError, LinkError, TimeoutError)
 _LIGHTHOUSE_DECK_PARAM = "deck.bcLighthouse4"
 _POWER_CYCLE_BOOT_WAIT = 3.0
-_EMERGENCY_STOP_TIMEOUT = 0.5
 _CommanderLevel = Literal["low", "high"]
 
 
+class EmergencyStopActive(RuntimeError):
+    """Raised when a motion command is issued after the emergency-stop latch is set."""
+
+
 class DroneSwarm:
     """Connects, configures, and commands a Crazyflie swarm with cflib2."""
 
@@ -76,6 +79,7 @@ def __init__(
         self._estimator_stop_event: Event | None = None
         self._estimator_future: Future[None] | None = None
         self._closed = False
+        self._estop = threading.Event()
 
         if not lighthouse:
             from drone_estimators.ros_nodes.ros2_connector import ROSConnector
@@ -126,6 +130,7 @@ def is_active(self, uri: str) -> bool:
 
     def takeoff(self, height: float = 1.5, duration: float = 3.0):
         """Take off the drones to a given height over a given duration."""
+        self._ensure_not_estopped()
 
         async def _takeoff(uri: str) -> None:
             cf = self._cf(uri)
@@ -137,6 +142,7 @@ async def _takeoff(uri: str) -> None:
 
     def land(self, height: float = 0.0, duration: float = 3.0):
         """Land the drones at a given height over a given duration."""
+        self._ensure_not_estopped()
 
         async def _land(uri: str) -> None:
             cf = self._cf(uri)
@@ -155,6 +161,7 @@ def goto(self, target: dict[str, list], duration: float = 3.0):
             target: Position+Yaw references in the form {'uri1': [target], ...}.
             duration: Duration of the motion in seconds.
         """
+        self._ensure_not_estopped()
         self._validate_required_uris("pos", target)
         for uri, setpoint in target.items():
             if len(setpoint) != 4:
@@ -176,6 +183,7 @@ def setpoint(self, target: dict[str, list]):
         Args:
             target: Position+Yaw references in the form {'uri1': [target], ...}.
         """
+        self._ensure_not_estopped()
         self._validate_required_uris("pos", target)
         for uri, setpoint in target.items():
             if len(setpoint) != 4:
@@ -202,7 +210,11 @@ def execute_choreography(
             t_end: End time of the choreography.
             color_top: Top deck color cues in the form {uri: {time: wrgb}}.
             color_bot: Bottom deck color cues in the form {uri: {time: wrgb}}.
+
+        Raises:
+            EmergencyStopActive: If the emergency-stop latch is set before or during playback.
         """
+        self._ensure_not_estopped()
         self._validate_required_uris("choreography", choreography)
         if not color_top and not color_bot:
             logger.warning("No colors provided for choreography.")
@@ -224,6 +236,7 @@ async def _execute(uri: str) -> None:
                 "Choreography execution", self.uris, _execute, timeout=t_end + 1.0
             )
         )
+        self._ensure_not_estopped()
 
     def apply_colors(self, color_top: dict[str, Array] | None, color_bot: dict[str, Array] | None):
         """Apply colors to the drones.
@@ -263,13 +276,24 @@ async def _set_param(uri: str) -> None:
         )
 
     def emergency_stop(self, uri: str | None = None):
-        """Send an emergency stop signal to one URI or all drones (default)."""
+        """Send an emergency stop signal to one URI or all drones (default).
+
+        Sets a latch that halts the choreography stream and blocks further motion
+        commands so fresh setpoints cannot override the motor cut.
+        """
+        self._estop.set()
         if uri is None:
             uris = self.uris
         else:
             self._validate_known_uris("uri", {uri: None})
             uris = [uri]
-        self._run(self._emergency_stop_many(uris))
+        try:
+            self._run(
+                self._parallel_by_uri("Emergency stop", uris, self._emergency_stop, timeout=0.5)
+            )
+        except Exception as exc:
+            # Best-effort: one unreachable drone must not stop the others from being cut.
+            logger.error(f"Emergency stop encountered errors: {exc}")
 
     def reset(self):
         """Reset all active drones."""
@@ -313,10 +337,12 @@ async def _shutdown_leds(uri: str) -> None:
             await self._apply_drone_color(uri, np.zeros(4), "both")
 
         async def _close() -> None:
-            active_uris = [uri for uri in self.uris if uri in self.cfs]
+            active_uris = [uri for uri in self.uris if uri in self.active_uris]
             if active_uris:
                 try:
-                    await self._emergency_stop_many(active_uris)
+                    await self._parallel_by_uri(
+                        "Emergency stop", active_uris, self._emergency_stop, timeout=0.5
+                    )
                     await asyncio.sleep(0.1)
                     await self._parallel_by_uri(
                         "Shutdown LEDs", active_uris, _shutdown_leds, timeout=0.5
@@ -344,23 +370,21 @@ async def _close() -> None:
             if self.ros_connector is not None:
                 self.ros_connector.close()
 
+    def _ensure_not_estopped(self) -> None:
+        """Block forward-motion commands once the emergency-stop latch is set."""
+        if self._estop.is_set():
+            raise EmergencyStopActive("Swarm is emergency-stopped; motion commands are blocked.")
+
     def _run(self, coroutine: Awaitable[Any]) -> Any:
-        """Run a cflib2 coroutine on the swarm event loop."""
-        if self._loop_thread is not None or self._loop.is_running():
-            future = asyncio.run_coroutine_threadsafe(coroutine, self._loop)
-            try:
-                return future.result()
-            except BaseException:
-                future.cancel()
-                raise
+        """Run a cflib2 coroutine on the swarm event loop.
 
-        task = self._loop.create_task(coroutine)
-        try:
-            return self._loop.run_until_complete(task)
-        except BaseException:
-            task.cancel()
-            self._loop.run_until_complete(asyncio.gather(task, return_exceptions=True))
-            raise
+        Dispatches across threads when the loop is owned by another thread (the estimator
+        updater) or already running (a deployment driving it), so emergency stops issued
+        from the request or signal-handler threads still reach the swarm.
+        """
+        if self._loop_thread is not None or self._loop.is_running():
+            return asyncio.run_coroutine_threadsafe(coroutine, self._loop).result()
+        return self._loop.run_until_complete(coroutine)
 
     def _start_estimator_updater(self) -> None:
         """Start continuous mocap updates after the radio links are connected."""
@@ -488,26 +512,8 @@ async def _parallel_by_uri(
                 logger.error(f"{action_name} failed for {uri}: {result}")
         return results
 
-    async def _emergency_stop_many(self, uris: Iterable[str]) -> None:
-        """Best-effort emergency stop for every connected URI without cross-drone blocking."""
-        target_uris = [uri for uri in uris if uri in self.cfs]
-
-        async def _stop_one(uri: str) -> None:
-            try:
-                await asyncio.wait_for(self._emergency_stop(uri), timeout=_EMERGENCY_STOP_TIMEOUT)
-                self._commander_levels[uri] = None
-            except Exception as exc:
-                if isinstance(exc, _DISCONNECT_ERRORS):
-                    self.active_uris.discard(uri)
-                    self._commander_levels[uri] = None
-                    logger.error(f"{uri} disconnected or unreachable. Emergency stop failed: {exc}")
-                else:
-                    logger.error(f"Emergency stop failed for {uri}: {exc}")
-
-        await asyncio.gather(*[_stop_one(uri) for uri in target_uris])
-
     async def _emergency_stop(self, uri: str) -> None:
-        await self.cfs[uri].localization().emergency().send_emergency_stop()
+        await self._cf(uri).localization().emergency().send_emergency_stop()
 
     async def _change_commander_level(self, uri: str, level: _CommanderLevel) -> None:
         """Switch commander level only when local state expects a different mode."""
@@ -635,6 +641,8 @@ async def _stream_reference(
         t_col = -np.inf
 
         while (t_cur := asyncio.get_running_loop().time() - start_time) < duration:
+            if self._estop.is_set():
+                return
             await commander.send_setpoint_position(*reference(t_cur))
 
             if t_cur - t_col >= color_period:
diff --git a/swarm_gpt/launch.py b/swarm_gpt/launch.py
index b67c421..2ab8f33 100644
--- a/swarm_gpt/launch.py
+++ b/swarm_gpt/launch.py
@@ -2,8 +2,10 @@
 
 import logging
 import os
+import signal
 import sys
 from pathlib import Path
+from types import FrameType
 
 import fire
 import uvicorn
@@ -52,8 +54,24 @@ def main(
             use_motion_primitives=use_motion_primitives,
         )
     )
+    server = uvicorn.Server(uvicorn.Config(app, host=host, port=port))
+    # uvicorn's own SIGINT handler only triggers a graceful shutdown, which waits on the
+    # open events WebSocket and lets the deploy thread keep streaming setpoints. Take over
+    # SIGINT in the main thread to cut the motors immediately before shutting down.
+    server.install_signal_handlers = lambda: None
+
+    def _emergency_shutdown(_signum: int, _frame: FrameType | None) -> None:
+        logging.warning("Ctrl+C received: emergency-stopping all active swarms.")
+        try:
+            app.state.store.emergency_stop_all()
+        except Exception:
+            logging.exception("Emergency stop during shutdown failed")
+        server.should_exit = True
+
+    signal.signal(signal.SIGINT, _emergency_shutdown)
+    signal.signal(signal.SIGTERM, _emergency_shutdown)
     try:
-        uvicorn.run(app, host=host, port=port)
+        server.run()
     finally:
         shutdown_ollama_generation()
 
diff --git a/tests/unit/test_api.py b/tests/unit/test_api.py
index c7b629e..a201f19 100644
--- a/tests/unit/test_api.py
+++ b/tests/unit/test_api.py
@@ -153,3 +153,23 @@ def backend_from_config(config: ApiConfig, provider: str, model_id: str) -> Depl
 
     assert stop_response.json() == {"jobId": job_id, "emergencyStopped": True}
     assert backend.emergency_stop_calls == 1
+
+
+def test_emergency_stop_all_stops_active_swarms_and_skips_idle_jobs() -> None:
+    calls: list[str] = []
+
+    class ActiveBackend:
+        def emergency_stop_active_swarm(self) -> None:
+            calls.append("active")
+
+    class IdleBackend:
+        def emergency_stop_active_swarm(self) -> None:
+            raise RuntimeError("No active deployment swarm to emergency stop.")
+
+    store = server.JobStore()
+    store.create(ActiveBackend())  # type: ignore[arg-type]
+    store.create(IdleBackend())  # type: ignore[arg-type]
+
+    store.emergency_stop_all()
+
+    assert calls == ["active"]
diff --git a/tests/unit/test_backend.py b/tests/unit/test_backend.py
index 111cffb..a4e9458 100644
--- a/tests/unit/test_backend.py
+++ b/tests/unit/test_backend.py
@@ -1,10 +1,7 @@
 from pathlib import Path
 
-import numpy as np
-import pytest
 from conftest import virtual_crazyswarm_config
 
-import swarm_gpt.core.drone_swarm as drone_swarm
 from swarm_gpt.core.backend import AppBackend
 
 
@@ -51,61 +48,6 @@ def test_preset_metadata_and_delete(tmp_path: Path):
     assert not (preset_dir / preset_id).exists()
 
 
-def test_deploy_emergency_stops_before_close_on_keyboard_interrupt(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    class InterruptingSwarm:
-        instances = []
-
-        def __init__(self, drones: dict, *, lighthouse: bool) -> None:
-            self.drones_by_uri = {drone["uri"]: drone for drone in drones.values()}
-            self.calls: list[str] = []
-            self.instances.append(self)
-
-        def get_obs(self, uri: str) -> dict[str, np.ndarray]:
-            pos = np.asarray(self.drones_by_uri[uri]["pos"], dtype=float)
-            if "goto" in self.calls:
-                pos = pos + np.array([0.0, 0.0, 0.5])
-            return {"pos": pos, "quat": np.array([0.0, 0.0, 0.0, 1.0])}
-
-        def goto(self, target: dict[str, np.ndarray], duration: float = 3.0) -> None:
-            self.calls.append("goto")
-
-        def is_active(self, uri: str) -> bool:
-            return uri in self.drones_by_uri
-
-        def execute_choreography(self, *args: object, **kwargs: object) -> None:
-            self.calls.append("execute_choreography")
-            raise KeyboardInterrupt
-
-        def emergency_stop(self) -> None:
-            self.calls.append("emergency_stop")
-
-        def land(self, height: float = 0.0, duration: float = 3.0) -> None:
-            self.calls.append("land")
-
-        def close(self) -> None:
-            self.calls.append("close")
-
-    config_path = virtual_crazyswarm_config(n_drones=1)
-    app = AppBackend(config_file=config_path)
-    app.settings["lighthouse"] = True
-    app.settings["land_on_docks"] = False
-    app.music_manager.song = "Crazyflie Drones Theme"
-    app.music_manager.verify_libvlc = lambda: True
-    app.music_manager.play = lambda *, wait, start_s, end_s: True
-    app.music_manager.stop = lambda: None
-    app.waypoints = {"time": np.array([[0.0, 1.0]])}
-    app.splines[0] = lambda t: np.array([0.0, 0.0, 1.0])
-    monkeypatch.setattr(drone_swarm, "DroneSwarm", InterruptingSwarm)
-
-    with pytest.raises(KeyboardInterrupt):
-        app.deploy()
-
-    swarm = InterruptingSwarm.instances[0]
-    assert swarm.calls == ["goto", "execute_choreography", "emergency_stop", "close"]
-
-
 def test_emergency_stop_active_swarm_stops_live_swarm_and_music() -> None:
     class ActiveSwarm:
         def __init__(self) -> None:
diff --git a/tests/unit/test_drone_swarm.py b/tests/unit/test_drone_swarm.py
index 4a79966..725b1d1 100644
--- a/tests/unit/test_drone_swarm.py
+++ b/tests/unit/test_drone_swarm.py
@@ -6,7 +6,7 @@
 import pytest
 from cflib2.error import DisconnectedError
 
-from swarm_gpt.core.drone_swarm import DroneSwarm
+from swarm_gpt.core.drone_swarm import DroneSwarm, EmergencyStopActive
 
 
 class FakeParam:
@@ -90,50 +90,10 @@ def make_swarm(uris: list[str]) -> DroneSwarm:
     swarm._commander_levels = dict.fromkeys(uris)
     swarm._loop = asyncio.new_event_loop()
     swarm._loop_thread = None
+    swarm._estop = threading.Event()
     return swarm
 
 
-def test_run_cancels_threadsafe_command_when_keyboard_interrupt_escapes(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    class InterruptingFuture:
-        def __init__(self) -> None:
-            self.cancelled = False
-
-        def result(self) -> None:
-            raise KeyboardInterrupt
-
-        def cancel(self) -> None:
-            self.cancelled = True
-
-    future = InterruptingFuture()
-    captured: dict[str, Any] = {}
-    swarm = make_swarm([])
-    swarm._loop_thread = threading.Thread()
-
-    async def command() -> None:
-        return None
-
-    def run_coroutine_threadsafe(
-        coroutine: Any, loop: asyncio.AbstractEventLoop
-    ) -> InterruptingFuture:
-        captured["coroutine"] = coroutine
-        captured["loop"] = loop
-        return future
-
-    monkeypatch.setattr(asyncio, "run_coroutine_threadsafe", run_coroutine_threadsafe)
-
-    try:
-        with pytest.raises(KeyboardInterrupt):
-            swarm._run(command())
-    finally:
-        captured["coroutine"].close()
-        swarm._loop.close()
-
-    assert captured["loop"] is swarm._loop
-    assert future.cancelled
-
-
 def test_run_schedules_threadsafe_when_loop_is_already_running():
     swarm = make_swarm([])
     swarm._loop_thread = None
@@ -188,6 +148,41 @@ async def emergency_stop(uri: str) -> None:
     assert stopped == [uris[1]]
 
 
+def test_emergency_stop_sets_latch_and_blocks_motion():
+    uris = ["radio://0/80/2M/E7E7E7E701"]
+    swarm = make_swarm(uris)
+
+    async def emergency_stop(uri: str) -> None:
+        return None
+
+    swarm._emergency_stop = emergency_stop
+
+    try:
+        swarm.emergency_stop()
+        assert swarm._estop.is_set()
+        with pytest.raises(EmergencyStopActive):
+            swarm.goto({uris[0]: [0.0, 0.0, 1.0, 0.0]})
+        with pytest.raises(EmergencyStopActive):
+            swarm.land()
+    finally:
+        swarm._loop.close()
+
+
+def test_stream_reference_stops_immediately_when_estopped():
+    uris = ["radio://0/80/2M/E7E7E7E701"]
+    swarm = make_swarm(uris)
+    swarm.ctrl_freq = 50
+    swarm.col_freq = 10
+    swarm._estop.set()
+
+    try:
+        swarm._loop.run_until_complete(swarm._stream_reference(uris[0], 5.0, lambda t: np.zeros(4)))
+    finally:
+        swarm._loop.close()
+
+    assert swarm.cfs[uris[0]].fake_commander.setpoints == []
+
+
 def test_estimator_updater_copies_batch_and_skips_inactive_drones():
     uris = [
         "radio://0/80/2M/E7E7E7E701",

From ab6fa23135e96e440a5c1ffbd64f5ac5b285682c Mon Sep 17 00:00:00 2001
From: Yiyi Xu <xuyiyi0516@gmail.com>
Date: Tue, 23 Jun 2026 18:29:49 +0200
Subject: [PATCH 4/7] attempt 4, last try it stopped after a slight delay

---
 swarm_gpt/core/drone_swarm.py  | 42 ++++++++++++++++++++++++++-----
 tests/unit/test_drone_swarm.py | 45 ++++++++++++++++++++++++++++++++--
 2 files changed, 79 insertions(+), 8 deletions(-)

diff --git a/swarm_gpt/core/drone_swarm.py b/swarm_gpt/core/drone_swarm.py
index dc10608..390bfcb 100644
--- a/swarm_gpt/core/drone_swarm.py
+++ b/swarm_gpt/core/drone_swarm.py
@@ -136,7 +136,7 @@ async def _takeoff(uri: str) -> None:
             cf = self._cf(uri)
             await self._change_commander_level(uri, "high")
             await cf.high_level_commander().take_off(height, None, duration, None)
-            await asyncio.sleep(duration)
+            await self._estop_guarded_sleep(uri, duration)
 
         self._run(self._parallel_by_uri("Taking off", self.uris, _takeoff, timeout=duration + 1.0))
 
@@ -149,7 +149,8 @@ async def _land(uri: str) -> None:
             await self._change_commander_level(uri, "high")
             high_level_commander = cf.high_level_commander()
             await high_level_commander.land(height, None, duration, None)
-            await asyncio.sleep(duration)
+            if await self._estop_guarded_sleep(uri, duration):
+                return
             await high_level_commander.stop(None)
 
         self._run(self._parallel_by_uri("Landing", self.uris, _land, timeout=duration + 1.0))
@@ -173,7 +174,7 @@ async def _goto(uri: str) -> None:
             await cf.high_level_commander().go_to(
                 *target[uri], duration, relative=False, linear=True, group_mask=None
             )
-            await asyncio.sleep(duration)
+            await self._estop_guarded_sleep(uri, duration)
 
         self._run(self._parallel_by_uri("Goto", self.uris, _goto, timeout=duration + 1.0))
 
@@ -287,10 +288,15 @@ def emergency_stop(self, uri: str | None = None):
         else:
             self._validate_known_uris("uri", {uri: None})
             uris = [uri]
+        coro = self._parallel_by_uri("Emergency stop", uris, self._emergency_stop, timeout=0.5)
         try:
-            self._run(
-                self._parallel_by_uri("Emergency stop", uris, self._emergency_stop, timeout=0.5)
-            )
+            if self._loop_thread is not None or self._loop.is_running():
+                # The latch already makes in-flight loop coroutines cut their own motors; this
+                # is a bounded fallback so the caller (signal handler / request) never blocks
+                # waiting on a loop that may have stopped after the self-cut.
+                asyncio.run_coroutine_threadsafe(coro, self._loop).result(timeout=1.0)
+            else:
+                self._loop.run_until_complete(coro)
         except Exception as exc:
             # Best-effort: one unreachable drone must not stop the others from being cut.
             logger.error(f"Emergency stop encountered errors: {exc}")
@@ -375,6 +381,29 @@ def _ensure_not_estopped(self) -> None:
         if self._estop.is_set():
             raise EmergencyStopActive("Swarm is emergency-stopped; motion commands are blocked.")
 
+    async def _estop_guarded_sleep(self, uri: str, duration: float) -> bool:
+        """Wait up to ``duration``, cutting this drone's motors at once if the latch trips.
+
+        Sends the emergency-stop packet from inside the swarm event loop so the motor cut
+        does not depend on cross-thread scheduling, then returns. Polls finely so an
+        in-flight high-level move is aborted within a control tick of the latch being set.
+
+        Args:
+            uri: The drone to guard and, if latched, stop.
+            duration: Total time to wait when the latch is not set.
+
+        Returns:
+            ``True`` if the latch tripped and the motors were cut, ``False`` otherwise.
+        """
+        loop = asyncio.get_running_loop()
+        deadline = loop.time() + duration
+        while (remaining := deadline - loop.time()) > 0:
+            if self._estop.is_set():
+                await self._emergency_stop(uri)
+                return True
+            await asyncio.sleep(min(0.02, remaining))
+        return False
+
     def _run(self, coroutine: Awaitable[Any]) -> Any:
         """Run a cflib2 coroutine on the swarm event loop.
 
@@ -642,6 +671,7 @@ async def _stream_reference(
 
         while (t_cur := asyncio.get_running_loop().time() - start_time) < duration:
             if self._estop.is_set():
+                await self._emergency_stop(uri)
                 return
             await commander.send_setpoint_position(*reference(t_cur))
 
diff --git a/tests/unit/test_drone_swarm.py b/tests/unit/test_drone_swarm.py
index 725b1d1..fe56f84 100644
--- a/tests/unit/test_drone_swarm.py
+++ b/tests/unit/test_drone_swarm.py
@@ -33,13 +33,25 @@ async def send_external_pose(self, *, pos: list[float], quat: list[float]) -> No
         self.sent.append((pos, quat))
 
 
+class FakeEmergency:
+    def __init__(self) -> None:
+        self.stops = 0
+
+    async def send_emergency_stop(self) -> None:
+        self.stops += 1
+
+
 class FakeLocalization:
     def __init__(self) -> None:
         self.fake_external_pose = FakeExternalPose()
+        self.fake_emergency = FakeEmergency()
 
     def external_pose(self) -> FakeExternalPose:
         return self.fake_external_pose
 
+    def emergency(self) -> FakeEmergency:
+        return self.fake_emergency
+
 
 class FakeCrazyflie:
     def __init__(self) -> None:
@@ -168,7 +180,7 @@ async def emergency_stop(uri: str) -> None:
         swarm._loop.close()
 
 
-def test_stream_reference_stops_immediately_when_estopped():
+def test_stream_reference_cuts_motors_immediately_when_estopped():
     uris = ["radio://0/80/2M/E7E7E7E701"]
     swarm = make_swarm(uris)
     swarm.ctrl_freq = 50
@@ -180,7 +192,36 @@ def test_stream_reference_stops_immediately_when_estopped():
     finally:
         swarm._loop.close()
 
-    assert swarm.cfs[uris[0]].fake_commander.setpoints == []
+    cf = swarm.cfs[uris[0]]
+    assert cf.fake_commander.setpoints == []  # no setpoints streamed
+    assert cf.fake_localization.fake_emergency.stops == 1  # motors cut from the loop
+
+
+def test_estop_guarded_sleep_cuts_motors_when_latched():
+    uris = ["radio://0/80/2M/E7E7E7E701"]
+    swarm = make_swarm(uris)
+    swarm._estop.set()
+
+    try:
+        cut = swarm._loop.run_until_complete(swarm._estop_guarded_sleep(uris[0], 5.0))
+    finally:
+        swarm._loop.close()
+
+    assert cut is True
+    assert swarm.cfs[uris[0]].fake_localization.fake_emergency.stops == 1
+
+
+def test_estop_guarded_sleep_returns_false_without_latch():
+    uris = ["radio://0/80/2M/E7E7E7E701"]
+    swarm = make_swarm(uris)
+
+    try:
+        cut = swarm._loop.run_until_complete(swarm._estop_guarded_sleep(uris[0], 0.0))
+    finally:
+        swarm._loop.close()
+
+    assert cut is False
+    assert swarm.cfs[uris[0]].fake_localization.fake_emergency.stops == 0
 
 
 def test_estimator_updater_copies_batch_and_skips_inactive_drones():

From 23e022ed4e83dc8564e639f5be6f694962d15b41 Mon Sep 17 00:00:00 2001
From: Yiyi Xu <xuyiyi0516@gmail.com>
Date: Tue, 23 Jun 2026 18:39:05 +0200
Subject: [PATCH 5/7] making it work first press ctrl c

---
 swarm_gpt/launch.py | 17 ++++++++---------
 1 file changed, 8 insertions(+), 9 deletions(-)

diff --git a/swarm_gpt/launch.py b/swarm_gpt/launch.py
index 2ab8f33..6e14c29 100644
--- a/swarm_gpt/launch.py
+++ b/swarm_gpt/launch.py
@@ -2,7 +2,6 @@
 
 import logging
 import os
-import signal
 import sys
 from pathlib import Path
 from types import FrameType
@@ -55,21 +54,21 @@ def main(
         )
     )
     server = uvicorn.Server(uvicorn.Config(app, host=host, port=port))
-    # uvicorn's own SIGINT handler only triggers a graceful shutdown, which waits on the
-    # open events WebSocket and lets the deploy thread keep streaming setpoints. Take over
-    # SIGINT in the main thread to cut the motors immediately before shutting down.
-    server.install_signal_handlers = lambda: None
+    # uvicorn captures SIGINT/SIGTERM itself (Server.capture_signals installs self.handle_exit)
+    # and only starts a graceful shutdown, which waits on the open events WebSocket while the
+    # deploy thread keeps flying. Wrap handle_exit so the first Ctrl+C cuts the motors before
+    # uvicorn begins draining. capture_signals installs whatever self.handle_exit is at call time.
+    uvicorn_handle_exit = server.handle_exit
 
-    def _emergency_shutdown(_signum: int, _frame: FrameType | None) -> None:
+    def handle_exit(sig: int, frame: FrameType | None) -> None:
         logging.warning("Ctrl+C received: emergency-stopping all active swarms.")
         try:
             app.state.store.emergency_stop_all()
         except Exception:
             logging.exception("Emergency stop during shutdown failed")
-        server.should_exit = True
+        uvicorn_handle_exit(sig, frame)
 
-    signal.signal(signal.SIGINT, _emergency_shutdown)
-    signal.signal(signal.SIGTERM, _emergency_shutdown)
+    server.handle_exit = handle_exit
     try:
         server.run()
     finally:

From 8d815e33a980c2e7472dddcceb4430a3414ff9cb Mon Sep 17 00:00:00 2001
From: Yiyi Xu <xuyiyi0516@gmail.com>
Date: Tue, 23 Jun 2026 18:49:39 +0200
Subject: [PATCH 6/7] compacting

---
 swarm_gpt/core/drone_swarm.py | 28 ++++++----------------------
 1 file changed, 6 insertions(+), 22 deletions(-)

diff --git a/swarm_gpt/core/drone_swarm.py b/swarm_gpt/core/drone_swarm.py
index 390bfcb..479613b 100644
--- a/swarm_gpt/core/drone_swarm.py
+++ b/swarm_gpt/core/drone_swarm.py
@@ -211,9 +211,6 @@ def execute_choreography(
             t_end: End time of the choreography.
             color_top: Top deck color cues in the form {uri: {time: wrgb}}.
             color_bot: Bottom deck color cues in the form {uri: {time: wrgb}}.
-
-        Raises:
-            EmergencyStopActive: If the emergency-stop latch is set before or during playback.
         """
         self._ensure_not_estopped()
         self._validate_required_uris("choreography", choreography)
@@ -237,7 +234,6 @@ async def _execute(uri: str) -> None:
                 "Choreography execution", self.uris, _execute, timeout=t_end + 1.0
             )
         )
-        self._ensure_not_estopped()
 
     def apply_colors(self, color_top: dict[str, Array] | None, color_bot: dict[str, Array] | None):
         """Apply colors to the drones.
@@ -288,17 +284,15 @@ def emergency_stop(self, uri: str | None = None):
         else:
             self._validate_known_uris("uri", {uri: None})
             uris = [uri]
+        # In-flight loop coroutines self-cut on the latch; this also sends the packet directly
+        # to cover idle windows. Bounded so the caller never blocks on a loop that has stopped.
         coro = self._parallel_by_uri("Emergency stop", uris, self._emergency_stop, timeout=0.5)
         try:
             if self._loop_thread is not None or self._loop.is_running():
-                # The latch already makes in-flight loop coroutines cut their own motors; this
-                # is a bounded fallback so the caller (signal handler / request) never blocks
-                # waiting on a loop that may have stopped after the self-cut.
                 asyncio.run_coroutine_threadsafe(coro, self._loop).result(timeout=1.0)
             else:
                 self._loop.run_until_complete(coro)
         except Exception as exc:
-            # Best-effort: one unreachable drone must not stop the others from being cut.
             logger.error(f"Emergency stop encountered errors: {exc}")
 
     def reset(self):
@@ -382,18 +376,9 @@ def _ensure_not_estopped(self) -> None:
             raise EmergencyStopActive("Swarm is emergency-stopped; motion commands are blocked.")
 
     async def _estop_guarded_sleep(self, uri: str, duration: float) -> bool:
-        """Wait up to ``duration``, cutting this drone's motors at once if the latch trips.
-
-        Sends the emergency-stop packet from inside the swarm event loop so the motor cut
-        does not depend on cross-thread scheduling, then returns. Polls finely so an
-        in-flight high-level move is aborted within a control tick of the latch being set.
-
-        Args:
-            uri: The drone to guard and, if latched, stop.
-            duration: Total time to wait when the latch is not set.
+        """Wait up to ``duration``, cutting ``uri``'s motors from the loop if the latch trips.
 
-        Returns:
-            ``True`` if the latch tripped and the motors were cut, ``False`` otherwise.
+        Returns True if the latch tripped (motors cut), False if it slept the full duration.
         """
         loop = asyncio.get_running_loop()
         deadline = loop.time() + duration
@@ -407,9 +392,8 @@ async def _estop_guarded_sleep(self, uri: str, duration: float) -> bool:
     def _run(self, coroutine: Awaitable[Any]) -> Any:
         """Run a cflib2 coroutine on the swarm event loop.
 
-        Dispatches across threads when the loop is owned by another thread (the estimator
-        updater) or already running (a deployment driving it), so emergency stops issued
-        from the request or signal-handler threads still reach the swarm.
+        Dispatches cross-thread when the loop runs in another thread or is already running,
+        so emergency stops from the request or signal-handler threads still reach the swarm.
         """
         if self._loop_thread is not None or self._loop.is_running():
             return asyncio.run_coroutine_threadsafe(coroutine, self._loop).result()

From 4a61d88a557d1cca47cda5697e7edbd8e45dd01a Mon Sep 17 00:00:00 2001
From: Yiyi Xu <xuyiyi0516@gmail.com>
Date: Fri, 26 Jun 2026 16:01:53 +0200
Subject: [PATCH 7/7] requested changes

---
 swarm_gpt/api/server.py        | 13 -----
 swarm_gpt/core/backend.py      | 11 ++--
 swarm_gpt/core/drone_swarm.py  | 62 +++------------------
 swarm_gpt/launch.py            | 19 +------
 tests/unit/test_api.py         | 20 -------
 tests/unit/test_drone_swarm.py | 99 +---------------------------------
 6 files changed, 15 insertions(+), 209 deletions(-)

diff --git a/swarm_gpt/api/server.py b/swarm_gpt/api/server.py
index 3a27ad0..bd6987b 100644
--- a/swarm_gpt/api/server.py
+++ b/swarm_gpt/api/server.py
@@ -166,18 +166,6 @@ def events_after(self, job_id: str, after_id: int) -> list[dict[str, Any]]:
             job = self.get(job_id)
             return [event for event in job.events if event["id"] > after_id]
 
-    def emergency_stop_all(self) -> None:
-        """Emergency-stop every job that currently has an active deployment swarm."""
-        with self._lock:
-            jobs = list(self._jobs.values())
-        for job in jobs:
-            try:
-                job.backend.emergency_stop_active_swarm()
-            except RuntimeError:
-                continue  # No active deployment swarm for this job.
-            except Exception:
-                logger.exception("Emergency stop failed for job %s", job.id)
-
 
 def _backend_from_config(config: ApiConfig, provider: LLMProvider, model_id: str) -> AppBackend:
     return AppBackend(
@@ -354,7 +342,6 @@ def create_app(config: ApiConfig | None = None) -> FastAPI:
     config = config or ApiConfig()
     store = JobStore()
     app = FastAPI(title="SwarmGPT Browser API", lifespan=_app_lifespan)
-    app.state.store = store
 
     @app.get("/api/library")
     def library() -> dict[str, Any]:
diff --git a/swarm_gpt/core/backend.py b/swarm_gpt/core/backend.py
index 7ddf05b..2e79e61 100644
--- a/swarm_gpt/core/backend.py
+++ b/swarm_gpt/core/backend.py
@@ -23,6 +23,7 @@
 if TYPE_CHECKING:
     from numpy.typing import NDArray as Array
 
+    from swarm_gpt.core.drone_swarm import DroneSwarm
     from swarm_gpt.utils.llm_providers import LLMProvider
 
 logging.basicConfig(level=logging.WARNING)
@@ -119,7 +120,7 @@ def __init__(
         self._preset: None | str = None
         self._strict_processing = strict_processing
         self._strict_drone_match = strict_drone_match
-        self._active_swarm: Any | None = None
+        self._active_swarm: DroneSwarm | None = None
         if set(self.songs) & set(self.presets):
             raise ValueError("Songs and presets must have unique names")
 
@@ -380,14 +381,12 @@ def deploy(self, drone_ids: list[int] | None = None) -> bool:
                     )
             self.music_manager.stop()
             swarm.goto(final_pos_dict, duration=2.0)  # Transition from ideal point to hover pos
-            if self.settings["land_on_docks"]:  # Commented out for demo
+            if self.settings["land_on_docks"]:
                 swarm.goto(final_pos_dict, duration=3.0)  # Hovering
             swarm.land(duration=1.5)  # Landing
         finally:
-            try:
-                swarm.close()
-            finally:
-                self._active_swarm = None
+            self._active_swarm = None
+            swarm.close()
         logger.info("Deployment successful")
         return True
 
diff --git a/swarm_gpt/core/drone_swarm.py b/swarm_gpt/core/drone_swarm.py
index 479613b..b2fa6b2 100644
--- a/swarm_gpt/core/drone_swarm.py
+++ b/swarm_gpt/core/drone_swarm.py
@@ -37,10 +37,6 @@
 _CommanderLevel = Literal["low", "high"]
 
 
-class EmergencyStopActive(RuntimeError):
-    """Raised when a motion command is issued after the emergency-stop latch is set."""
-
-
 class DroneSwarm:
     """Connects, configures, and commands a Crazyflie swarm with cflib2."""
 
@@ -79,7 +75,6 @@ def __init__(
         self._estimator_stop_event: Event | None = None
         self._estimator_future: Future[None] | None = None
         self._closed = False
-        self._estop = threading.Event()
 
         if not lighthouse:
             from drone_estimators.ros_nodes.ros2_connector import ROSConnector
@@ -130,27 +125,24 @@ def is_active(self, uri: str) -> bool:
 
     def takeoff(self, height: float = 1.5, duration: float = 3.0):
         """Take off the drones to a given height over a given duration."""
-        self._ensure_not_estopped()
 
         async def _takeoff(uri: str) -> None:
             cf = self._cf(uri)
             await self._change_commander_level(uri, "high")
             await cf.high_level_commander().take_off(height, None, duration, None)
-            await self._estop_guarded_sleep(uri, duration)
+            await asyncio.sleep(duration)
 
         self._run(self._parallel_by_uri("Taking off", self.uris, _takeoff, timeout=duration + 1.0))
 
     def land(self, height: float = 0.0, duration: float = 3.0):
         """Land the drones at a given height over a given duration."""
-        self._ensure_not_estopped()
 
         async def _land(uri: str) -> None:
             cf = self._cf(uri)
             await self._change_commander_level(uri, "high")
             high_level_commander = cf.high_level_commander()
             await high_level_commander.land(height, None, duration, None)
-            if await self._estop_guarded_sleep(uri, duration):
-                return
+            await asyncio.sleep(duration)
             await high_level_commander.stop(None)
 
         self._run(self._parallel_by_uri("Landing", self.uris, _land, timeout=duration + 1.0))
@@ -162,7 +154,6 @@ def goto(self, target: dict[str, list], duration: float = 3.0):
             target: Position+Yaw references in the form {'uri1': [target], ...}.
             duration: Duration of the motion in seconds.
         """
-        self._ensure_not_estopped()
         self._validate_required_uris("pos", target)
         for uri, setpoint in target.items():
             if len(setpoint) != 4:
@@ -174,7 +165,7 @@ async def _goto(uri: str) -> None:
             await cf.high_level_commander().go_to(
                 *target[uri], duration, relative=False, linear=True, group_mask=None
             )
-            await self._estop_guarded_sleep(uri, duration)
+            await asyncio.sleep(duration)
 
         self._run(self._parallel_by_uri("Goto", self.uris, _goto, timeout=duration + 1.0))
 
@@ -184,7 +175,6 @@ def setpoint(self, target: dict[str, list]):
         Args:
             target: Position+Yaw references in the form {'uri1': [target], ...}.
         """
-        self._ensure_not_estopped()
         self._validate_required_uris("pos", target)
         for uri, setpoint in target.items():
             if len(setpoint) != 4:
@@ -212,7 +202,6 @@ def execute_choreography(
             color_top: Top deck color cues in the form {uri: {time: wrgb}}.
             color_bot: Bottom deck color cues in the form {uri: {time: wrgb}}.
         """
-        self._ensure_not_estopped()
         self._validate_required_uris("choreography", choreography)
         if not color_top and not color_bot:
             logger.warning("No colors provided for choreography.")
@@ -273,27 +262,13 @@ async def _set_param(uri: str) -> None:
         )
 
     def emergency_stop(self, uri: str | None = None):
-        """Send an emergency stop signal to one URI or all drones (default).
-
-        Sets a latch that halts the choreography stream and blocks further motion
-        commands so fresh setpoints cannot override the motor cut.
-        """
-        self._estop.set()
+        """Send an emergency stop signal to one URI or all drones (default)."""
         if uri is None:
             uris = self.uris
         else:
             self._validate_known_uris("uri", {uri: None})
             uris = [uri]
-        # In-flight loop coroutines self-cut on the latch; this also sends the packet directly
-        # to cover idle windows. Bounded so the caller never blocks on a loop that has stopped.
-        coro = self._parallel_by_uri("Emergency stop", uris, self._emergency_stop, timeout=0.5)
-        try:
-            if self._loop_thread is not None or self._loop.is_running():
-                asyncio.run_coroutine_threadsafe(coro, self._loop).result(timeout=1.0)
-            else:
-                self._loop.run_until_complete(coro)
-        except Exception as exc:
-            logger.error(f"Emergency stop encountered errors: {exc}")
+        self._run(self._parallel_by_uri("Emergency stop", uris, self._emergency_stop, timeout=0.5))
 
     def reset(self):
         """Reset all active drones."""
@@ -370,30 +345,12 @@ async def _close() -> None:
             if self.ros_connector is not None:
                 self.ros_connector.close()
 
-    def _ensure_not_estopped(self) -> None:
-        """Block forward-motion commands once the emergency-stop latch is set."""
-        if self._estop.is_set():
-            raise EmergencyStopActive("Swarm is emergency-stopped; motion commands are blocked.")
-
-    async def _estop_guarded_sleep(self, uri: str, duration: float) -> bool:
-        """Wait up to ``duration``, cutting ``uri``'s motors from the loop if the latch trips.
-
-        Returns True if the latch tripped (motors cut), False if it slept the full duration.
-        """
-        loop = asyncio.get_running_loop()
-        deadline = loop.time() + duration
-        while (remaining := deadline - loop.time()) > 0:
-            if self._estop.is_set():
-                await self._emergency_stop(uri)
-                return True
-            await asyncio.sleep(min(0.02, remaining))
-        return False
-
     def _run(self, coroutine: Awaitable[Any]) -> Any:
         """Run a cflib2 coroutine on the swarm event loop.
 
-        Dispatches cross-thread when the loop runs in another thread or is already running,
-        so emergency stops from the request or signal-handler threads still reach the swarm.
+        Dispatches cross-thread when the loop runs in another thread or is already running
+        (e.g. a deployment driving it), so an emergency stop from the request thread that
+        handles the frontend button still reaches the swarm mid-performance.
         """
         if self._loop_thread is not None or self._loop.is_running():
             return asyncio.run_coroutine_threadsafe(coroutine, self._loop).result()
@@ -654,9 +611,6 @@ async def _stream_reference(
         t_col = -np.inf
 
         while (t_cur := asyncio.get_running_loop().time() - start_time) < duration:
-            if self._estop.is_set():
-                await self._emergency_stop(uri)
-                return
             await commander.send_setpoint_position(*reference(t_cur))
 
             if t_cur - t_col >= color_period:
diff --git a/swarm_gpt/launch.py b/swarm_gpt/launch.py
index 6e14c29..b67c421 100644
--- a/swarm_gpt/launch.py
+++ b/swarm_gpt/launch.py
@@ -4,7 +4,6 @@
 import os
 import sys
 from pathlib import Path
-from types import FrameType
 
 import fire
 import uvicorn
@@ -53,24 +52,8 @@ def main(
             use_motion_primitives=use_motion_primitives,
         )
     )
-    server = uvicorn.Server(uvicorn.Config(app, host=host, port=port))
-    # uvicorn captures SIGINT/SIGTERM itself (Server.capture_signals installs self.handle_exit)
-    # and only starts a graceful shutdown, which waits on the open events WebSocket while the
-    # deploy thread keeps flying. Wrap handle_exit so the first Ctrl+C cuts the motors before
-    # uvicorn begins draining. capture_signals installs whatever self.handle_exit is at call time.
-    uvicorn_handle_exit = server.handle_exit
-
-    def handle_exit(sig: int, frame: FrameType | None) -> None:
-        logging.warning("Ctrl+C received: emergency-stopping all active swarms.")
-        try:
-            app.state.store.emergency_stop_all()
-        except Exception:
-            logging.exception("Emergency stop during shutdown failed")
-        uvicorn_handle_exit(sig, frame)
-
-    server.handle_exit = handle_exit
     try:
-        server.run()
+        uvicorn.run(app, host=host, port=port)
     finally:
         shutdown_ollama_generation()
 
diff --git a/tests/unit/test_api.py b/tests/unit/test_api.py
index a201f19..c7b629e 100644
--- a/tests/unit/test_api.py
+++ b/tests/unit/test_api.py
@@ -153,23 +153,3 @@ def backend_from_config(config: ApiConfig, provider: str, model_id: str) -> Depl
 
     assert stop_response.json() == {"jobId": job_id, "emergencyStopped": True}
     assert backend.emergency_stop_calls == 1
-
-
-def test_emergency_stop_all_stops_active_swarms_and_skips_idle_jobs() -> None:
-    calls: list[str] = []
-
-    class ActiveBackend:
-        def emergency_stop_active_swarm(self) -> None:
-            calls.append("active")
-
-    class IdleBackend:
-        def emergency_stop_active_swarm(self) -> None:
-            raise RuntimeError("No active deployment swarm to emergency stop.")
-
-    store = server.JobStore()
-    store.create(ActiveBackend())  # type: ignore[arg-type]
-    store.create(IdleBackend())  # type: ignore[arg-type]
-
-    store.emergency_stop_all()
-
-    assert calls == ["active"]
diff --git a/tests/unit/test_drone_swarm.py b/tests/unit/test_drone_swarm.py
index fe56f84..d7ef99e 100644
--- a/tests/unit/test_drone_swarm.py
+++ b/tests/unit/test_drone_swarm.py
@@ -6,7 +6,7 @@
 import pytest
 from cflib2.error import DisconnectedError
 
-from swarm_gpt.core.drone_swarm import DroneSwarm, EmergencyStopActive
+from swarm_gpt.core.drone_swarm import DroneSwarm
 
 
 class FakeParam:
@@ -33,25 +33,13 @@ async def send_external_pose(self, *, pos: list[float], quat: list[float]) -> No
         self.sent.append((pos, quat))
 
 
-class FakeEmergency:
-    def __init__(self) -> None:
-        self.stops = 0
-
-    async def send_emergency_stop(self) -> None:
-        self.stops += 1
-
-
 class FakeLocalization:
     def __init__(self) -> None:
         self.fake_external_pose = FakeExternalPose()
-        self.fake_emergency = FakeEmergency()
 
     def external_pose(self) -> FakeExternalPose:
         return self.fake_external_pose
 
-    def emergency(self) -> FakeEmergency:
-        return self.fake_emergency
-
 
 class FakeCrazyflie:
     def __init__(self) -> None:
@@ -102,7 +90,6 @@ def make_swarm(uris: list[str]) -> DroneSwarm:
     swarm._commander_levels = dict.fromkeys(uris)
     swarm._loop = asyncio.new_event_loop()
     swarm._loop_thread = None
-    swarm._estop = threading.Event()
     return swarm
 
 
@@ -140,90 +127,6 @@ def test_setpoint_sends_once_and_returns():
         assert cf.fake_param.values == [("commander.enHighLevel", 0)]
 
 
-def test_emergency_stop_one_hung_drone_does_not_block_others():
-    uris = ["radio://0/80/2M/E7E7E7E701", "radio://0/80/2M/E7E7E7E702"]
-    swarm = make_swarm(uris)
-    stopped: list[str] = []
-
-    async def emergency_stop(uri: str) -> None:
-        if uri == uris[0]:
-            await asyncio.sleep(1)
-        stopped.append(uri)
-
-    swarm._emergency_stop = emergency_stop
-
-    try:
-        swarm.emergency_stop()
-    finally:
-        swarm._loop.close()
-
-    assert stopped == [uris[1]]
-
-
-def test_emergency_stop_sets_latch_and_blocks_motion():
-    uris = ["radio://0/80/2M/E7E7E7E701"]
-    swarm = make_swarm(uris)
-
-    async def emergency_stop(uri: str) -> None:
-        return None
-
-    swarm._emergency_stop = emergency_stop
-
-    try:
-        swarm.emergency_stop()
-        assert swarm._estop.is_set()
-        with pytest.raises(EmergencyStopActive):
-            swarm.goto({uris[0]: [0.0, 0.0, 1.0, 0.0]})
-        with pytest.raises(EmergencyStopActive):
-            swarm.land()
-    finally:
-        swarm._loop.close()
-
-
-def test_stream_reference_cuts_motors_immediately_when_estopped():
-    uris = ["radio://0/80/2M/E7E7E7E701"]
-    swarm = make_swarm(uris)
-    swarm.ctrl_freq = 50
-    swarm.col_freq = 10
-    swarm._estop.set()
-
-    try:
-        swarm._loop.run_until_complete(swarm._stream_reference(uris[0], 5.0, lambda t: np.zeros(4)))
-    finally:
-        swarm._loop.close()
-
-    cf = swarm.cfs[uris[0]]
-    assert cf.fake_commander.setpoints == []  # no setpoints streamed
-    assert cf.fake_localization.fake_emergency.stops == 1  # motors cut from the loop
-
-
-def test_estop_guarded_sleep_cuts_motors_when_latched():
-    uris = ["radio://0/80/2M/E7E7E7E701"]
-    swarm = make_swarm(uris)
-    swarm._estop.set()
-
-    try:
-        cut = swarm._loop.run_until_complete(swarm._estop_guarded_sleep(uris[0], 5.0))
-    finally:
-        swarm._loop.close()
-
-    assert cut is True
-    assert swarm.cfs[uris[0]].fake_localization.fake_emergency.stops == 1
-
-
-def test_estop_guarded_sleep_returns_false_without_latch():
-    uris = ["radio://0/80/2M/E7E7E7E701"]
-    swarm = make_swarm(uris)
-
-    try:
-        cut = swarm._loop.run_until_complete(swarm._estop_guarded_sleep(uris[0], 0.0))
-    finally:
-        swarm._loop.close()
-
-    assert cut is False
-    assert swarm.cfs[uris[0]].fake_localization.fake_emergency.stops == 0
-
-
 def test_estimator_updater_copies_batch_and_skips_inactive_drones():
     uris = [
         "radio://0/80/2M/E7E7E7E701",