diff --git a/openpilot/common/esim/base.py b/openpilot/common/esim/base.py
index b783a630b24bd7..472b523e2c7770 100644
--- a/openpilot/common/esim/base.py
+++ b/openpilot/common/esim/base.py
@@ -21,6 +21,13 @@ class Profile:
   def is_comma(self) -> bool:
     return self.provider == 'Webbing' and self.iccid.startswith('8985235')
 
+  @property
+  def display_name(self) -> str:
+    if self.is_comma:
+      return "comma prime"
+    name = self.nickname or self.provider or "<unnamed>"
+    return f"{name} (...{self.iccid[-4:]})"
+
 
 class LPABase(ABC):
   @abstractmethod
diff --git a/openpilot/selfdrive/ui/mici/layouts/settings/network/__init__.py b/openpilot/selfdrive/ui/mici/layouts/settings/network/__init__.py
index ddbab4b478cb24..4719feecb980f5 100644
--- a/openpilot/selfdrive/ui/mici/layouts/settings/network/__init__.py
+++ b/openpilot/selfdrive/ui/mici/layouts/settings/network/__init__.py
@@ -1,10 +1,57 @@
 import pyray as rl
 
+from openpilot.cereal import log
 from openpilot.selfdrive.ui.mici.layouts.settings.network.wifi_ui import WifiIcon
 from openpilot.selfdrive.ui.mici.widgets.button import BigButton
+from openpilot.common.hardware import HARDWARE
 from openpilot.system.ui.lib.application import gui_app
+from openpilot.system.ui.lib.cellular_manager import CellularManager
 from openpilot.system.ui.lib.wifi_manager import WifiManager, ConnectStatus, SecurityType, normalize_ssid
 
+NetworkStrength = log.DeviceState.NetworkStrength
+NetworkType = log.DeviceState.NetworkType
+
+
+class EsimNetworkButton(BigButton):
+  def __init__(self, cellular_manager: CellularManager):
+    self._cellular_manager = cellular_manager
+    self._cell_icons = {
+      NetworkStrength.unknown: gui_app.texture("icons_mici/settings/network/cell_strength_none.png", 64, 47),
+      NetworkStrength.poor: gui_app.texture("icons_mici/settings/network/cell_strength_low.png", 64, 47),
+      NetworkStrength.moderate: gui_app.texture("icons_mici/settings/network/cell_strength_medium.png", 64, 47),
+      NetworkStrength.good: gui_app.texture("icons_mici/settings/network/cell_strength_high.png", 64, 47),
+      NetworkStrength.great: gui_app.texture("icons_mici/settings/network/cell_strength_full.png", 64, 47),
+    }
+    super().__init__("esim", "loading...", self._cell_icons[NetworkStrength.unknown], scroll=True)
+
+  def _update_state(self):
+    super()._update_state()
+    self.set_enabled(self._cellular_manager.is_euicc is not False)
+    text, value, icon = self._compute_state()
+    self.set_text(text)
+    self.set_value(value)
+    self.set_icon(icon)
+
+  def _compute_state(self):
+    cm = self._cellular_manager
+    none_icon = self._cell_icons[NetworkStrength.unknown]
+    ip = cm.modem_state.get("ip_address") or "obtaining IP..."
+    if cm.is_euicc is False:
+      iccid = cm.modem_state.get("iccid") or ""
+      if not iccid:
+        return "sim", "no sim", none_icon
+      return f"sim (...{iccid[-4:]})", ip, self._cell_icon()
+
+    active = cm.active_profile
+    if active is None:
+      return "esim", "loading...", none_icon
+    return active.display_name, ip, self._cell_icon()
+
+  def _cell_icon(self):
+    # read directly from HARDWARE so it reflects modem state even when wifi is the active connection
+    strength = HARDWARE.get_network_strength(NetworkType.cell4G)
+    return self._cell_icons.get(strength, self._cell_icons[NetworkStrength.unknown])
+
 
 class WifiNetworkButton(BigButton):
   def __init__(self, wifi_manager: WifiManager):
diff --git a/openpilot/selfdrive/ui/mici/layouts/settings/network/esim_ui.py b/openpilot/selfdrive/ui/mici/layouts/settings/network/esim_ui.py
new file mode 100644
index 00000000000000..2984466c3fefd0
--- /dev/null
+++ b/openpilot/selfdrive/ui/mici/layouts/settings/network/esim_ui.py
@@ -0,0 +1,211 @@
+import pyray as rl
+from collections.abc import Callable
+
+from openpilot.selfdrive.ui.mici.widgets.button import BigButton, LABEL_COLOR
+from openpilot.selfdrive.ui.mici.layouts.settings.network.wifi_ui import ForgetButton
+from openpilot.selfdrive.ui.mici.widgets.dialog import BigDialog, BigInputDialog
+from openpilot.common.esim.base import Profile
+from openpilot.system.ui.lib.application import DEFAULT_TEXT_COLOR, FontWeight, MousePos, gui_app
+from openpilot.system.ui.lib.cellular_manager import CellularManager
+from openpilot.system.ui.widgets import Widget
+from openpilot.system.ui.widgets.label import gui_label
+from openpilot.system.ui.widgets.scroller import NavScroller
+
+SUB_LABEL_DISABLED = rl.Color(255, 255, 255, int(255 * 0.585))
+CHECK_ICON_COLOR = rl.Color(255, 255, 255, int(255 * 0.9 * 0.65))
+
+
+class RenameButton(Widget):
+  SIZE = 84
+  MARGIN = 12
+
+  def __init__(self, rename_callback: Callable):
+    super().__init__()
+    self._rename_callback = rename_callback
+
+    self._bg_txt = gui_app.texture("icons_mici/buttons/button_circle.png", self.SIZE, self.SIZE)
+    self._bg_pressed_txt = gui_app.texture("icons_mici/buttons/button_circle_pressed.png", self.SIZE, self.SIZE)
+    self.set_rect(rl.Rectangle(0, 0, self.SIZE + self.MARGIN * 2, self.SIZE + self.MARGIN * 2))
+
+  def _handle_mouse_release(self, mouse_pos: MousePos):
+    super()._handle_mouse_release(mouse_pos)
+    self._rename_callback()
+
+  def _render(self, _):
+    bg_txt = self._bg_pressed_txt if self.is_pressed else self._bg_txt
+    rl.draw_texture_ex(bg_txt, (self._rect.x + (self._rect.width - self._bg_txt.width) / 2,
+                                self._rect.y + (self._rect.height - self._bg_txt.height) / 2), 0, 1.0, rl.WHITE)
+    gui_label(self._rect, "Aa", 32, alignment=rl.GuiTextAlignment.TEXT_ALIGN_CENTER)
+
+
+class EsimProfileButton(BigButton):
+  LABEL_PADDING = 98
+  LABEL_WIDTH = 402 - 98 - 28
+  SUB_LABEL_WIDTH = 402 - BigButton.LABEL_HORIZONTAL_PADDING * 2
+
+  def __init__(self, profile: Profile, cellular_manager: CellularManager):
+    self._cellular_manager = cellular_manager
+    super().__init__(profile.display_name, scroll=True)
+
+    self._profile = profile
+
+    self._cell_full_txt = gui_app.texture("icons_mici/settings/network/cell_strength_full.png", 48, 36)
+    self._cell_none_txt = gui_app.texture("icons_mici/settings/network/cell_strength_none.png", 48, 36)
+    self._check_txt = gui_app.texture("icons_mici/setup/driver_monitoring/dm_check.png", 32, 32)
+    self._comma_txt = gui_app.texture("icons_mici/settings/comma_icon.png", 36, 36) if profile.is_comma else None
+
+    self._delete_btn = ForgetButton(lambda: self._cellular_manager.delete_profile(self._profile.iccid), "slide to delete", size=63)
+    self._rename_btn = RenameButton(self._on_rename) if not profile.is_comma else None
+    self.update_profile(profile)
+
+  @property
+  def profile(self) -> Profile:
+    return self._profile
+
+  def update_profile(self, profile: Profile):
+    self._profile = profile
+    active = profile.enabled
+    self.set_text(profile.display_name)
+    self.set_value("active" if active else "switch")
+    self.set_enabled(not active)
+    self._sub_label.set_color(SUB_LABEL_DISABLED if active else DEFAULT_TEXT_COLOR)
+    self._sub_label.set_font_weight(FontWeight.ROMAN if active else FontWeight.SEMI_BOLD)
+
+  @property
+  def _show_delete_btn(self) -> bool:
+    return not self._profile.enabled and not self._profile.is_comma
+
+  def _on_rename(self):
+    current = self._profile.nickname or ""
+    dlg = BigInputDialog("nickname", default_text=current, minimum_length=0, confirm_callback=self._on_nickname_entered)
+    gui_app.push_widget(dlg)
+
+  def _on_nickname_entered(self, nickname: str):
+    self._cellular_manager.nickname_profile(self._profile.iccid, nickname.strip())
+
+  def _handle_mouse_release(self, mouse_pos: MousePos):
+    if self._show_delete_btn and rl.check_collision_point_rec(mouse_pos, self._delete_btn.rect):
+      return
+    if self._rename_btn is not None and rl.check_collision_point_rec(mouse_pos, self._rename_btn.rect):
+      return
+    super()._handle_mouse_release(mouse_pos)
+
+  def _get_label_font_size(self):
+    return 48
+
+  def _draw_content(self, btn_y: float):
+    self._label.set_color(LABEL_COLOR)
+    label_rect = rl.Rectangle(self._rect.x + self.LABEL_PADDING, btn_y + self.LABEL_VERTICAL_PADDING,
+                              self.LABEL_WIDTH, self._rect.height - self.LABEL_VERTICAL_PADDING * 2)
+    self._label.render(label_rect)
+
+    active = self._profile.enabled
+
+    if self.value:
+      sub_label_x = self._rect.x + self.LABEL_HORIZONTAL_PADDING
+      label_y = btn_y + self._rect.height - self.LABEL_VERTICAL_PADDING
+      action_w = self._rename_btn.rect.width if self._rename_btn is not None else 0
+      # delete sits just inside rename's left edge (overlap their inner margins) so the sub_label has more room
+      action_w += self._delete_btn.rect.width - ForgetButton.MARGIN if self._show_delete_btn else 0
+      sub_label_w = self.SUB_LABEL_WIDTH - action_w
+      sub_label_height = self._sub_label.get_content_height(sub_label_w)
+
+      if active:
+        check_y = int(label_y - sub_label_height + (sub_label_height - self._check_txt.height) / 2)
+        rl.draw_texture_ex(self._check_txt, rl.Vector2(sub_label_x, check_y), 0.0, 1.0, CHECK_ICON_COLOR)
+        sub_label_x += self._check_txt.width + 14
+
+      sub_label_rect = rl.Rectangle(sub_label_x, label_y - sub_label_height, sub_label_w, sub_label_height)
+      self._sub_label.render(sub_label_rect)
+
+    if self._comma_txt:
+      rl.draw_texture_ex(self._comma_txt, (self._rect.x + 36, btn_y + 38), 0.0, 1.0, rl.WHITE)
+    else:
+      cell_icon = self._cell_full_txt if active else self._cell_none_txt
+      rl.draw_texture_ex(cell_icon, (self._rect.x + 30, btn_y + 38), 0.0, 1.0, rl.WHITE)
+
+    btn_x = self._rect.x + self._rect.width
+    btn_bottom = btn_y + self._rect.height
+    if self._rename_btn is not None:
+      btn_x -= self._rename_btn.rect.width
+      self._rename_btn.render(rl.Rectangle(
+        btn_x, btn_bottom - self._rename_btn.rect.height,
+        self._rename_btn.rect.width, self._rename_btn.rect.height,
+      ))
+    if self._show_delete_btn:
+      btn_x -= self._delete_btn.rect.width - ForgetButton.MARGIN
+      self._delete_btn.render(rl.Rectangle(
+        btn_x, btn_bottom - self._delete_btn.rect.height,
+        self._delete_btn.rect.width, self._delete_btn.rect.height,
+      ))
+
+  def set_touch_valid_callback(self, touch_callback: Callable[[], bool]) -> None:
+    def action_pressed() -> bool:
+      return self._delete_btn.is_pressed or (self._rename_btn is not None and self._rename_btn.is_pressed)
+    super().set_touch_valid_callback(lambda: touch_callback() and not action_pressed())
+    self._delete_btn.set_touch_valid_callback(touch_callback)
+    if self._rename_btn:
+      self._rename_btn.set_touch_valid_callback(touch_callback)
+
+
+class EsimUI(NavScroller):
+  def __init__(self, cellular_manager: CellularManager):
+    super().__init__()
+
+    self._cellular_manager = cellular_manager
+
+    self._cellular_manager.add_callbacks(
+      profiles_updated=self._on_profiles_updated,
+      operation_error=self._on_error,
+    )
+
+  def show_event(self):
+    super().show_event()
+    self._update_buttons(re_sort=True)
+    self._cellular_manager.refresh_profiles()
+
+  def _on_profiles_updated(self, profiles: list[Profile]):
+    self._update_buttons()
+
+  def _update_buttons(self, re_sort: bool = False):
+    existing = {btn.profile.iccid: btn for btn in self._scroller.items}
+    buttons = []
+    for profile in self._cellular_manager.profiles:
+      btn = existing.get(profile.iccid)
+      if btn is None:
+        btn = EsimProfileButton(profile, self._cellular_manager)
+        btn.set_click_callback(lambda iccid=profile.iccid: self._on_profile_clicked(iccid))
+        self._scroller.add_widget(btn)
+      else:
+        btn.update_profile(profile)
+      buttons.append(btn)
+
+    if re_sort:
+      self._scroller.items[:] = sorted(buttons, key=lambda b: not b.profile.enabled)
+    else:
+      self._scroller.items[:] = [btn for btn in self._scroller.items if btn in buttons]
+
+  def _move_profile_to_front(self, iccid: str | None, scroll: bool = False):
+    front_btn_idx = next((i for i, btn in enumerate(self._scroller.items) if btn.profile.iccid == iccid), None) if iccid else None
+
+    if front_btn_idx is not None and front_btn_idx > 0:
+      self._scroller.move_item(front_btn_idx, 0)
+
+      if scroll:
+        self._scroller.scroll_to(self._scroller.scroll_panel.get_offset(), smooth=True)
+
+  def _update_state(self):
+    super()._update_state()
+
+    active = self._cellular_manager.active_profile
+    self._move_profile_to_front(active.iccid if active else None)
+
+  def _on_error(self, error: str):
+    dlg = BigDialog("esim error", error)
+    gui_app.push_widget(dlg)
+
+  def _on_profile_clicked(self, iccid: str):
+    if self._cellular_manager.busy:
+      return
+    self._cellular_manager.switch_profile(iccid)
+    self._move_profile_to_front(iccid, scroll=True)
diff --git a/openpilot/selfdrive/ui/mici/layouts/settings/network/network_layout.py b/openpilot/selfdrive/ui/mici/layouts/settings/network/network_layout.py
index 58b3d0c77dceeb..6ad2767db8b4c9 100644
--- a/openpilot/selfdrive/ui/mici/layouts/settings/network/network_layout.py
+++ b/openpilot/selfdrive/ui/mici/layouts/settings/network/network_layout.py
@@ -1,12 +1,14 @@
-from openpilot.system.ui.widgets.scroller import NavScroller
-from openpilot.selfdrive.ui.mici.layouts.settings.network import WifiNetworkButton
+from openpilot.selfdrive.ui.lib.prime_state import PrimeType
+from openpilot.selfdrive.ui.mici.layouts.settings.network import EsimNetworkButton, WifiNetworkButton
+from openpilot.selfdrive.ui.mici.layouts.settings.network.esim_ui import EsimUI
 from openpilot.selfdrive.ui.mici.layouts.settings.network.wifi_ui import WifiUIMici
 from openpilot.selfdrive.ui.mici.widgets.button import BigButton, BigMultiToggle, BigParamControl, BigToggle
 from openpilot.selfdrive.ui.mici.widgets.dialog import BigInputDialog
 from openpilot.selfdrive.ui.ui_state import ui_state
-from openpilot.selfdrive.ui.lib.prime_state import PrimeType
 from openpilot.system.ui.lib.application import gui_app
+from openpilot.system.ui.lib.cellular_manager import CellularManager
 from openpilot.system.ui.lib.wifi_manager import WifiManager, Network, MeteredType
+from openpilot.system.ui.widgets.scroller import NavScroller
 
 
 class NetworkLayoutMici(NavScroller):
@@ -64,6 +66,13 @@ def network_metered_callback(value: str):
     self._wifi_button = WifiNetworkButton(self._wifi_manager)
     self._wifi_button.set_click_callback(lambda: gui_app.push_widget(self._wifi_ui))
 
+    # ******** eSIM ********
+    self._cellular_manager = CellularManager()
+    self._esim_ui = EsimUI(self._cellular_manager)
+    self._esim_button = EsimNetworkButton(self._cellular_manager)
+
+    self._esim_button.set_click_callback(lambda: gui_app.push_widget(self._esim_ui))
+
     # ******** Advanced settings ********
     # ******** Roaming toggle ********
     self._roaming_btn = BigParamControl("enable roaming", "GsmRoaming")
@@ -78,6 +87,7 @@ def network_metered_callback(value: str):
     # Main scroller ----------------------------------
     self._scroller.add_widgets([
       self._wifi_button,
+      self._esim_button,
       self._network_metered_btn,
       self._tethering_toggle_btn,
       self._tethering_password_btn,
@@ -91,9 +101,12 @@ def network_metered_callback(value: str):
   def _update_state(self):
     super()._update_state()
 
-    # If not using prime SIM, show GSM settings and enable IPv4 forwarding
-    show_cell_settings = ui_state.prime_state.get_type() in (PrimeType.NONE, PrimeType.LITE)
-    self._wifi_manager.set_ipv4_forward(show_cell_settings)
+    not_prime = ui_state.prime_state.get_type() in (PrimeType.NONE, PrimeType.LITE)
+    self._wifi_manager.set_ipv4_forward(not_prime)
+
+    # full prime hides GSM settings only when the comma profile is the active one
+    active = self._cellular_manager.active_profile
+    show_cell_settings = not_prime or active is None or not active.is_comma
     self._roaming_btn.set_visible(show_cell_settings)
     self._apn_btn.set_visible(show_cell_settings)
     self._cellular_metered_btn.set_visible(show_cell_settings)
@@ -102,14 +115,16 @@ def show_event(self):
     super().show_event()
     self._wifi_manager.set_active(True)
 
-    # Process wifi callbacks while at any point in the nav stack
+    # Process wifi and esim callbacks while at any point in the nav stack
     gui_app.add_nav_stack_tick(self._wifi_manager.process_callbacks)
+    gui_app.add_nav_stack_tick(self._cellular_manager.process_callbacks)
 
   def hide_event(self):
     super().hide_event()
     self._wifi_manager.set_active(False)
 
     gui_app.remove_nav_stack_tick(self._wifi_manager.process_callbacks)
+    gui_app.remove_nav_stack_tick(self._cellular_manager.process_callbacks)
 
   def _edit_apn(self):
     def update_apn(apn: str):
diff --git a/openpilot/selfdrive/ui/mici/layouts/settings/network/wifi_ui.py b/openpilot/selfdrive/ui/mici/layouts/settings/network/wifi_ui.py
index 8404faf9f7e6cc..cd5c2bda0e5a95 100644
--- a/openpilot/selfdrive/ui/mici/layouts/settings/network/wifi_ui.py
+++ b/openpilot/selfdrive/ui/mici/layouts/settings/network/wifi_ui.py
@@ -235,18 +235,21 @@ def _update_state(self):
 class ForgetButton(Widget):
   MARGIN = 12  # bottom and right
 
-  def __init__(self, forget_network: Callable):
+  def __init__(self, forget_network: Callable, label: str = "slide to forget", size: int = 84):
     super().__init__()
     self._forget_network = forget_network
+    self._label = label
 
-    self._bg_txt = gui_app.texture("icons_mici/settings/network/new/forget_button.png", 84, 84)
-    self._bg_pressed_txt = gui_app.texture("icons_mici/settings/network/new/forget_button_pressed.png", 84, 84)
-    self._trash_txt = gui_app.texture("icons_mici/settings/network/new/trash.png", 29, 35)
-    self.set_rect(rl.Rectangle(0, 0, 84 + self.MARGIN * 2, 84 + self.MARGIN * 2))
+    trash_w, trash_h = round(29 * size / 84), round(35 * size / 84)
+    self._bg_txt = gui_app.texture("icons_mici/settings/network/new/forget_button.png", size, size)
+    self._bg_pressed_txt = gui_app.texture("icons_mici/settings/network/new/forget_button_pressed.png", size, size)
+    self._trash_txt = gui_app.texture("icons_mici/settings/network/new/trash.png", trash_w, trash_h)
+    self._dialog_trash_txt = gui_app.texture("icons_mici/settings/network/new/trash.png", 54, 64)
+    self.set_rect(rl.Rectangle(0, 0, size + self.MARGIN * 2, size + self.MARGIN * 2))
 
   def _handle_mouse_release(self, mouse_pos: MousePos):
     super()._handle_mouse_release(mouse_pos)
-    dlg = BigConfirmationDialog("slide to forget", gui_app.texture("icons_mici/settings/network/new/trash.png", 54, 64), self._forget_network, red=True)
+    dlg = BigConfirmationDialog(self._label, self._dialog_trash_txt, self._forget_network, red=True)
     gui_app.push_widget(dlg)
 
   def _render(self, _):
diff --git a/openpilot/system/ui/lib/cellular_manager.py b/openpilot/system/ui/lib/cellular_manager.py
new file mode 100644
index 00000000000000..d96473e55860ee
--- /dev/null
+++ b/openpilot/system/ui/lib/cellular_manager.py
@@ -0,0 +1,160 @@
+import time
+import threading
+from collections.abc import Callable
+from dataclasses import replace
+
+from openpilot.common.hardware import HARDWARE
+from openpilot.common.swaglog import cloudlog
+from openpilot.common.esim.base import LPABase, Profile
+
+
+PROFILE_POLL_INTERVAL_S = 5.0
+
+
+def _get_modem_state() -> dict:
+  try:
+    return HARDWARE.get_modem_state()
+  except Exception:
+    return {}
+
+
+class CellularManager:
+  def __init__(self):
+    self._lpa: LPABase | None = None
+    self._profiles: list[Profile] = []
+    self._busy: bool = False
+    # re-probed every poll; SIM may be swapped at runtime on tray-accessible devices
+    self._is_euicc: bool | None = None
+    self._modem_state: dict = {}
+
+    self._lock = threading.Lock()
+    self._callback_lock = threading.Lock()
+    self._callback_queue: list[Callable] = []
+
+    self._profiles_updated_cbs: list[Callable[[list[Profile]], None]] = []
+    self._operation_error_cbs: list[Callable[[str], None]] = []
+
+    self._last_profile_poll: float = 0.0
+    self._polling: bool = False
+
+  def add_callbacks(self, profiles_updated: Callable | None = None, operation_error: Callable | None = None):
+    if profiles_updated:
+      self._profiles_updated_cbs.append(profiles_updated)
+    if operation_error:
+      self._operation_error_cbs.append(operation_error)
+
+  @property
+  def modem_state(self) -> dict:
+    return self._modem_state
+
+  def process_callbacks(self):
+    with self._callback_lock:
+      to_run, self._callback_queue = self._callback_queue, []
+    for cb in to_run:
+      cb()
+
+    self._modem_state = _get_modem_state()
+
+    if not self._busy and not self._polling and time.monotonic() - self._last_profile_poll >= PROFILE_POLL_INTERVAL_S:
+      self._last_profile_poll = time.monotonic()
+      self._poll_profiles()
+
+  @property
+  def profiles(self) -> list[Profile]:
+    return self._profiles
+
+  @property
+  def active_profile(self) -> Profile | None:
+    return next((p for p in self._profiles if p.enabled), None)
+
+  @property
+  def busy(self) -> bool:
+    return self._busy
+
+  @property
+  def is_euicc(self) -> bool | None:
+    return self._is_euicc
+
+  def _ensure_lpa(self) -> LPABase:
+    if self._lpa is None:
+      self._lpa = HARDWARE.get_sim_lpa()
+    return self._lpa
+
+  def _enqueue(self, cb: Callable):
+    with self._callback_lock:
+      self._callback_queue.append(cb)
+
+  def _stop_polling(self):
+    self._polling = False
+
+  def _set_profiles(self, profiles: list[Profile]):
+    self._profiles = profiles
+    for cb in self._profiles_updated_cbs:
+      cb(profiles)
+
+  def _finish(self, profiles: list[Profile] | None = None, error: str | None = None):
+    self._busy = False
+    if profiles is not None:
+      self._set_profiles(profiles)
+    if error is not None:
+      self.refresh_profiles()
+      for cb in self._operation_error_cbs:
+        cb(error)
+
+  def _run_operation(self, fn: Callable[[LPABase], None], error_msg: str, relist: bool = True):
+    self._busy = True
+
+    def worker():
+      try:
+        with self._lock:
+          lpa = self._ensure_lpa()
+          fn(lpa)
+          profiles = lpa.list_profiles() if relist else None
+        self._enqueue(lambda: self._finish(profiles=profiles))
+      except Exception as e:
+        cloudlog.exception(error_msg)
+        err = str(e)
+        self._enqueue(lambda: self._finish(error=err))
+
+    threading.Thread(target=worker, daemon=True).start()
+
+  def refresh_profiles(self):
+    # next process_callbacks tick polls, respecting busy/polling guards
+    self._last_profile_poll = 0.0
+
+  def _poll_profiles(self):
+    self._polling = True
+    prev_is_euicc = self._is_euicc
+
+    def worker():
+      try:
+        with self._lock:
+          lpa = self._ensure_lpa()
+          is_euicc = lpa.is_euicc()
+          profiles = lpa.list_profiles() if is_euicc else []
+        if is_euicc != prev_is_euicc:
+          cloudlog.info(f"eSIM: is_euicc={is_euicc}")
+        self._enqueue(lambda: self._finish_poll(is_euicc, profiles))
+      except Exception:
+        cloudlog.exception("Failed to poll eSIM profiles")
+        self._enqueue(self._stop_polling)
+
+    threading.Thread(target=worker, daemon=True).start()
+
+  def _finish_poll(self, is_euicc: bool, profiles: list[Profile]):
+    self._polling = False
+    if self._busy:
+      return
+    self._is_euicc = is_euicc
+    self._set_profiles(profiles)
+
+  def switch_profile(self, iccid: str):
+    # optimistic: list_profiles() can briefly return stale enabled state after a switch
+    self._set_profiles([replace(p, enabled=(p.iccid == iccid)) for p in self._profiles])
+    self._run_operation(lambda lpa: lpa.switch_profile(iccid), "Failed to switch eSIM profile", relist=False)
+
+  def delete_profile(self, iccid: str):
+    self._run_operation(lambda lpa: lpa.delete_profile(iccid), "Failed to delete eSIM profile")
+
+  def nickname_profile(self, iccid: str, nickname: str):
+    self._run_operation(lambda lpa: lpa.nickname_profile(iccid, nickname), "Failed to update eSIM profile nickname")