@@ -131,7 +131,7 @@ def apply_tool(tool_name: str) -> None:
 _joint_min_speed: Vec6i = np.array([100, 100, 100, 100, 100, 100], dtype=np.int32)
 
 # Jog speeds (steps/s) - 80% of max for safety margin during jogging
-_joint_max_jog_speed: Vec6i = (_joint_max_speed * 0.5).astype(np.int32)
+_joint_max_jog_speed: Vec6i = (_joint_max_speed * 0.8).astype(np.int32)
 _joint_min_jog_speed: Vec6i = np.array([100, 100, 100, 100, 100, 100], dtype=np.int32)
 
 # Joint accelerations (steps/s^2) per joint
 
@@ -690,7 +690,7 @@ async def is_robot_stopped(self, threshold_speed: float = 2.0) -> bool:
 
     async def wait_motion_complete(
         self,
-        timeout: float = 90.0,
+        timeout: float = 10.0,
         settle_window: float = 0.25,
         speed_threshold: float = 2.0,
         angle_threshold: float = 0.5,
@@ -727,57 +727,53 @@ async def wait_motion_complete(
                 if timeout_task.done():
                     return False
 
-                # Check speeds from status
+                # Check speeds and angles from status
                 speeds = status.get("speeds")
+                angles = status.get("angles")
+
+                max_speed = None
                 if speeds and isinstance(speeds, Iterable):
                     max_speed = max(abs(s) for s in speeds)
 
-                    # Phase 1: Wait for motion to start
-                    if not motion_started:
-                        if max_speed >= speed_threshold:
-                            motion_started = True
-                            settle_start = None  # Reset settle timer
-                        elif time.time() - start_time > motion_start_timeout:
-                            # Motion never started - consider complete
-                            # This handles cases where command was invalid or no-op
-                            motion_started = True
-
-                    # Phase 2: Wait for motion to complete
-                    if motion_started:
-                        if max_speed < speed_threshold:
-                            if settle_start is None:
-                                settle_start = time.time()
-                            elif time.time() - settle_start > settle_window:
-                                return True
-                        else:
-                            settle_start = None
-
-                # Also check angles as fallback
-                angles = status.get("angles")
-                if angles and not speeds:
-                    if last_angles is not None:
-                        max_change = max(
-                            abs(a - b)
-                            for a, b in zip(angles, last_angles, strict=False)
-                        )
-
-                        # Detect motion start from angle changes
-                        if not motion_started:
-                            if max_change >= angle_threshold:
-                                motion_started = True
-                                settle_start = None
-                            elif time.time() - start_time > motion_start_timeout:
-                                motion_started = True
-
-                        if motion_started:
-                            if max_change < angle_threshold:
-                                if settle_start is None:
-                                    settle_start = time.time()
-                                elif time.time() - settle_start > settle_window:
-                                    return True
-                            else:
-                                settle_start = None
+                max_angle_change = None
+                if angles and last_angles is not None:
+                    max_angle_change = max(
+                        abs(a - b) for a, b in zip(angles, last_angles, strict=False)
+                    )
+                if angles:
                     last_angles = angles
+
+                # Phase 1: Wait for motion to start
+                if not motion_started:
+                    started_by_speed = (
+                        max_speed is not None and max_speed >= speed_threshold
+                    )
+                    started_by_angle = (
+                        max_angle_change is not None
+                        and max_angle_change >= angle_threshold
+                    )
+                    if started_by_speed or started_by_angle:
+                        motion_started = True
+                        settle_start = None
+                    elif time.time() - start_time > motion_start_timeout:
+                        # Motion never started - consider complete
+                        motion_started = True
+
+                # Phase 2: Wait for motion to complete
+                if motion_started:
+                    # Check if settled: require ALL available metrics to be below threshold
+                    speed_settled = max_speed is None or max_speed < speed_threshold
+                    angle_settled = (
+                        max_angle_change is None or max_angle_change < angle_threshold
+                    )
+
+                    if speed_settled and angle_settled:
+                        if settle_start is None:
+                            settle_start = time.time()
+                        elif time.time() - settle_start > settle_window:
+                            return True
+                    else:
+                        settle_start = None
         finally:
             timeout_task.cancel()
             try:
 
@@ -191,17 +191,19 @@ async def subscribe_status(
                 )
                 continue
 
-    except asyncio.CancelledError:
-        # Normal shutdown path when consumer task is cancelled
-        logger.info("subscribe_status cancelled")
-        raise
+    except (asyncio.CancelledError, GeneratorExit):
+        # Normal shutdown - don't log
+        pass
     except Exception as e:
-        logger.error(f"Error in subscribe_status: {e}", exc_info=True)
-        raise
+        # Log unexpected errors, but not "Event loop is closed" during shutdown
+        if "Event loop is closed" not in str(e):
+            logger.error(f"Error in subscribe_status: {e}")
     finally:
-        if transport:
-            logger.info("Closing transport...")
-            transport.close()
+        try:
+            if transport:
+                transport.close()
+        except Exception:
+            pass
         try:
             sock.close()
         except Exception:
 
@@ -31,13 +31,30 @@ def _loop_worker(loop: asyncio.AbstractEventLoop) -> None:
 
 def _stop_sync_loop() -> None:
     global _SYNC_LOOP, _SYNC_THREAD
-    if _SYNC_LOOP is not None:
-        try:
-            _SYNC_LOOP.call_soon_threadsafe(_SYNC_LOOP.stop)
-        except Exception:
-            pass
-        _SYNC_LOOP = None
-        _SYNC_THREAD = None
+    if _SYNC_LOOP is None:
+        return
+
+    loop = _SYNC_LOOP
+
+    async def _shutdown():
+        # Cancel all pending tasks
+        tasks = [t for t in asyncio.all_tasks(loop) if t is not asyncio.current_task()]
+        for task in tasks:
+            task.cancel()
+        # Let cancelled tasks finalize
+        if tasks:
+            await asyncio.gather(*tasks, return_exceptions=True)
+        loop.stop()
+
+    try:
+        asyncio.run_coroutine_threadsafe(_shutdown(), loop)
+        if _SYNC_THREAD is not None:
+            _SYNC_THREAD.join(timeout=2.0)
+    except Exception:
+        pass
+
+    _SYNC_LOOP = None
+    _SYNC_THREAD = None
 
 
 def _ensure_sync_loop() -> None:
@@ -382,7 +399,7 @@ def is_robot_stopped(self, threshold_speed: float = 2.0) -> bool:
 
     def wait_motion_complete(
         self,
-        timeout: float = 90.0,
+        timeout: float = 10.0,
         settle_window: float = 0.25,
         speed_threshold: float = 2.0,
         angle_threshold: float = 0.5,
 
@@ -11,7 +11,6 @@
 from typing import Any, ClassVar, overload
 
 import numpy as np
-from numba import njit  # type: ignore[import-untyped]
 
 from parol6.config import INTERVAL_S, LIMITS, TRACE
 from parol6.protocol.wire import CommandCode
@@ -20,9 +19,6 @@
 
 logger = logging.getLogger(__name__)
 
-_JOINT_LIM_MIN = LIMITS.joint.position.steps[:, 0]
-_JOINT_LIM_MAX = LIMITS.joint.position.steps[:, 1]
-
 
 class ExecutionStatusCode(Enum):
     """Enumeration for command execution status codes."""
@@ -488,10 +484,9 @@ def linmap_pct(pct: float, lo: float, hi: float) -> float:
         return lo + (hi - lo) * (pct / 100.0)
 
     @staticmethod
-    @njit
     def limit_hit_mask(pos_steps: np.ndarray, speeds: np.ndarray) -> np.ndarray:
-        return ((speeds > 0) & (pos_steps >= _JOINT_LIM_MAX)) | (
-            (speeds < 0) & (pos_steps <= _JOINT_LIM_MIN)
+        return ((speeds > 0) & (pos_steps >= LIMITS.joint.position.steps[:, 1])) | (
+            (speeds < 0) & (pos_steps <= LIMITS.joint.position.steps[:, 0])
         )
 
     def fail_and_idle(self, state: ControllerState, message: str) -> None:
 
@@ -35,7 +35,7 @@ def _trace(self, msg, *args, **kwargs):
 logger = logging.getLogger(__name__)
 
 # Default control/sample rates (Hz)
-CONTROL_RATE_HZ: float = float(os.getenv("PAROL6_CONTROL_RATE_HZ", "250"))
+CONTROL_RATE_HZ: float = float(os.getenv("PAROL6_CONTROL_RATE_HZ", "200"))
 
 DEFAULT_ACCEL_PERCENT: float = 100.0
 
 
@@ -330,6 +330,15 @@ def reset_limits(self) -> None:
             self._acc_scale = 1.0
             self._apply_limits()
 
+    def reset(self) -> None:
+        """Reset executor state."""
+        with self._lock:
+            self._vel_scale = 1.0
+            self._acc_scale = 1.0
+            self.active = False
+            self._cart_vel_limit = None
+            self._init_state()
+
     @property
     def current_position(self) -> list[float]:
         """Get current position state in radians."""
@@ -450,7 +459,9 @@ def sync_pose(self, current_pose: sp.SE3) -> None:
             current_pose: Current TCP pose as SE3
         """
         with self._lock:
-            self.reference_pose = current_pose
+            self.reference_pose = (
+                current_pose.copy()
+            )  # Copy to avoid aliasing with cached FK
             # Reset Ruckig state to origin (relative to reference)
             self.inp.current_position = [0.0] * 6
             self.inp.current_velocity = [0.0] * 6
 
@@ -36,9 +36,6 @@
 if TYPE_CHECKING:
     import sophuspy as sp
 
-# Silence toppra's verbose debug output
-logging.getLogger("toppra").setLevel(logging.INFO)
-
 logger = logging.getLogger(__name__)
 
 
 
@@ -1468,6 +1468,16 @@ def main():
         datefmt="%H:%M:%S",
     )
 
+    third_party_log_level = log_level if log_level >= logging.INFO else logging.INFO
+    # Silence toppra's verbose debug output
+    logging.getLogger("toppra").setLevel(third_party_log_level)
+    logging.getLogger("numba").setLevel(third_party_log_level)
+
+    # Pre-compile numba JIT functions to avoid mid-loop compilation stalls
+    from parol6.utils.warmup import warmup_jit
+
+    warmup_jit()
+
     # Create configuration (env vars may override defaults)
     env_host = os.getenv("PAROL6_CONTROLLER_IP")
     env_port = os.getenv("PAROL6_CONTROLLER_PORT")
 
@@ -239,6 +239,12 @@ def reset(self) -> None:
         self._fkine_last_pos_in.fill(0)
         self._fkine_last_tool = ""
 
+        # Reset streaming executors (clears reference_pose and Ruckig state)
+        if self.streaming_executor is not None:
+            self.streaming_executor.reset()
+        if self.cartesian_streaming_executor is not None:
+            self.cartesian_streaming_executor.reset()
+
         logger.debug("Controller state reset (preserving connection)")
 
     @property