From 29f498d77ebd63443476651da6a0404cc0969e22 Mon Sep 17 00:00:00 2001
From: Danny <dannyirwin31@yahoo.com>
Date: Fri, 30 Oct 2026 17:39:24 -0700
Subject: [PATCH 01/38] StarPort: Unofficial dongle option, v4 head unit
 version reply fallback, patience for not-ready cars

---
 .../starpilot/galaxy/tests/test_starport.mjs  |   9 +-
 openpilot/starpilot/galaxy/web/js/starport.js |   6 +-
 .../starpilot/system/starport/bootstrap.py    |  86 ++++++++++++++-
 .../system/starport/bugsink_diagnosis.py      |   5 +
 .../starpilot/system/starport/car_profiles.py |   4 +-
 .../starpilot/system/starport/supervisor.py   |   9 +-
 .../tests/test_bootstrap_receivers.py         | 102 +++++++++++++++++-
 .../starport/tests/test_car_profiles.py       |  10 +-
 8 files changed, 214 insertions(+), 17 deletions(-)

diff --git a/openpilot/starpilot/galaxy/tests/test_starport.mjs b/openpilot/starpilot/galaxy/tests/test_starport.mjs
index 275679293b..f2ef23f936 100644
--- a/openpilot/starpilot/galaxy/tests/test_starport.mjs
+++ b/openpilot/starpilot/galaxy/tests/test_starport.mjs
@@ -524,15 +524,16 @@ assert.equal(dongle.adapterRow.value, 'Choose one', 'no default: the owner picks
 assert.equal(settingControl(dongle.adapterRow), 'select', 'the initial adapter prompt must open a picker')
 assert.match(dongle.pairingReason, /adapter model/)
 dongle.runtime = { car_type: 'adapter', car_profile: 'default', car_profile_source: 'override' }
-assert.equal(dongle.adapterRow.value, 'Other')
-assert.deepEqual(dongle.adapterRow.choices, ['AAWireless', 'Other'])
+assert.equal(dongle.adapterRow.value, 'Motorola MA1')
+assert.deepEqual(dongle.adapterRow.choices, ['AAWireless', 'Motorola MA1', 'Unofficial dongle'])
 dongle.runtime = { car_type: 'adapter', car_profile: 'aawireless', car_profile_source: 'override' }
 assert.equal(dongle.adapterRow.value, 'AAWireless')
 const dongleCalls = []
 dongle.control = (action, extra) => dongleCalls.push([action, extra])
-dongle.saveAdapter(0, 'Other')
+dongle.saveAdapter(0, 'Motorola MA1')
 dongle.saveAdapter(0, 'AAWireless')
-assert.deepEqual(dongleCalls, [['car_profile', { profile: 'default' }], ['car_profile', { profile: 'aawireless' }]])
+dongle.saveAdapter(0, 'Unofficial dongle')
+assert.deepEqual(dongleCalls, [['car_profile', { profile: 'default' }], ['car_profile', { profile: 'aawireless' }], ['car_profile', { profile: 'unofficial' }]])
 assert.match(StarPortPage.template, /adapterSetup" :row="adapterRow"/)
 assert.match(StarPortPage.template, /What’s in your car\?|carTypeRow/)
 assert.match(StarPortPage.template, /runtime\?\.pairing_note/)
diff --git a/openpilot/starpilot/galaxy/web/js/starport.js b/openpilot/starpilot/galaxy/web/js/starport.js
index 7e45891075..37a0f25f3b 100644
--- a/openpilot/starpilot/galaxy/web/js/starport.js
+++ b/openpilot/starpilot/galaxy/web/js/starport.js
@@ -44,7 +44,7 @@ export function uploadPackage(path, options, progress, makeRequest = () => new X
 }
 
 const ADDRESS = /^(?:[0-9A-F]{2}:){5}[0-9A-F]{2}$/
-const ADAPTER_MODELS = { aawireless: "AAWireless", default: "Other" }
+const ADAPTER_MODELS = { aawireless: "AAWireless", default: "Motorola MA1", unofficial: "Unofficial dongle" }
 const HEAD_UNIT_APPS = { headunitpad: "HeadunitPad", openheadunit: "Open Headunit" }
 const HOTSPOT_LINK = `<a class="gx-link" href="#/galaxy">Galaxy Wi-Fi Hotspot</a>`
 const WIRED_STATUS = `<div v-if="wired" class="gx-note">
@@ -564,9 +564,9 @@ export const StarPortPage = {
     },
     adapterRow() {
       const chosen = this.runtime?.car_profile_source === "override"
-      return { label: "Adapter", value: !chosen ? "Choose one" : this.runtime.car_profile === "aawireless" ? ADAPTER_MODELS.aawireless : ADAPTER_MODELS.default,
+      return { label: "Adapter", value: !chosen ? "Choose one" : ADAPTER_MODELS[this.runtime.car_profile] || ADAPTER_MODELS.default,
         choices: [...(!chosen ? ["Choose one"] : []), ...Object.values(ADAPTER_MODELS)], available: true, action: true,
-        reason: "AAWireless gets video and car-data settings tuned for that dongle. Other adapters use the regular pairing." }
+        reason: "AAWireless gets video and car-data settings tuned for that dongle. Motorola MA1 uses the regular pairing. Pick Unofficial dongle for other wireless dongles that will not connect; it tries alternate handshakes and logs more." }
     },
     appDisabled() {
       return !this.setup?.enabled || !this.setup.parked || !!this.pairing?.active || this.linked
diff --git a/openpilot/starpilot/system/starport/bootstrap.py b/openpilot/starpilot/system/starport/bootstrap.py
index 4ae9c37513..bd00289ec1 100644
--- a/openpilot/starpilot/system/starport/bootstrap.py
+++ b/openpilot/starpilot/system/starport/bootstrap.py
@@ -30,6 +30,7 @@ import re
 import struct
 import threading
 import time
+import uuid
 from collections.abc import Callable
 from dataclasses import dataclass, field as dataclass_field
 
@@ -53,6 +54,11 @@ NAMES = {1: "WifiStartRequest", 2: "WifiInfoRequest", 3: "WifiInfoResponse", 4:
 
 STATUS_SUCCESS = 0
 STATUS_NETWORK_UNAVAILABLE = -1
+# Fallback for a v4+ head unit that goes silent after our usual reply: a phone-shaped WifiVersionResponse, where 1 is
+# success (open-android-auto WifiVersionStatus) and the channel type and session info are filled in.
+MODERN_MAJOR = 4
+MODERN_VERSION_SUCCESS = 1
+CHANNEL_5GHZ, CHANNEL_24GHZ, CHANNEL_DUAL = 1, 2, 3
 
 SECURITY_OPEN = 1
 SECURITY_NAMES = {0: "unknown", 1: "open", 2: "wep64", 3: "wep128", 4: "wpa", 8: "wpa2", 12: "wpa/wpa2",
@@ -61,9 +67,19 @@ SECURITY_NAMES = {0: "unknown", 1: "open", 2: "wep64", 3: "wep128", 4: "wpa", 8:
 MAX_FRAME = 4096
 MAX_FRAMES = 64
 INITIAL_KICK_SECONDS = 2.5
+# A car that keeps answering "not ready" gets up to this many stage timeouts before the setup is abandoned.
+REFUSAL_PATIENCE = 3
 # Phone-side WifiPing while joining the receiver's Wi-Fi, so an impatient receiver (a wireless adapter) keeps the
 # idle RFCOMM link. Sent only to a receiver that pings us first: one that never pings may not expect them.
 JOIN_PING_INTERVAL = 2.0
+# Opt-in handshake variations for dongles that stall the standard exchange; "" is the standard behavior.
+EXPERIMENTS = {
+  "start_response_first": ("Answer start request first", {"start_response_first"}),
+  "version_endpoint": ("Use version endpoint", {"version_endpoint"}),
+  "all": ("All of these", {"start_response_first", "version_endpoint"}),
+}
+# Frames that carry credentials or the vehicle identifier are never dumped as hex.
+HEX_LOG_SKIP = (WIFI_INFO_RESPONSE, WIFI_SETUP_INFO, WIFI_VERSION_REQUEST)
 MAC_RE = re.compile(r"^(?:[0-9A-Fa-f]{2}[:-]){5}[0-9A-Fa-f]{2}$")
 
 
@@ -165,7 +181,25 @@ def parse_setup_info(payload: bytes) -> tuple[Endpoint | None, WifiCredentials |
   return endpoint, credentials
 
 
-def parse_version_request(payload: bytes) -> tuple[int, int, Endpoint | None, dict]:
+def channel_type(request: bytes) -> int:
+  """The WifiChannelType to select: the car's stated preference, else what its channel list allows."""
+  fields = parse_fields(request)
+  preference = one(fields, 3)
+  if isinstance(preference, int) and preference in (CHANNEL_5GHZ, CHANNEL_24GHZ, CHANNEL_DUAL):
+    return preference
+  channels = [value for value in fields.get(4, []) if isinstance(value, int) and value > 0]
+  if channels and all(value >= 5000 for value in channels):
+    return CHANNEL_5GHZ
+  if channels and all(value < 5000 for value in channels):
+    return CHANNEL_24GHZ
+  return CHANNEL_DUAL
+
+
+def valid_experiment(value: str) -> bool:
+  return value == "" or value in EXPERIMENTS
+
+
+def parse_version_request(payload: bytes, endpoint_fields: tuple[int, ...] = ()) -> tuple[int, int, Endpoint | None, dict]:
   """Major/minor, an optional projection endpoint, and head-unit identity strings."""
   fields = parse_fields(payload)
   major, minor = int(one(fields, 1, 1) or 1), int(one(fields, 2, 0) or 0)
@@ -185,6 +219,13 @@ def parse_version_request(payload: bytes) -> tuple[int, int, Endpoint | None, di
       labels = {1: "car_make", 2: "car_model", 3: "car_year", 5: "head_unit_make", 6: "head_unit_model",
                 7: "head_unit_software_build", 8: "head_unit_software_version"}
       head_unit.update({label: text(info, key) for key, label in labels.items() if text(info, key)})
+  for number in endpoint_fields:
+    for value in fields.get(number, []):
+      if isinstance(value, bytes):
+        try:
+          endpoint = parse_endpoint(value) or endpoint
+        except ValueError:
+          continue
   return major, minor, endpoint, head_unit
 
 
@@ -224,8 +265,15 @@ class WirelessBootstrap:
 
   def __init__(self, sock, log: Callable[..., None], *, device_serial: str = "starpilot",
                version_status: int = STATUS_SUCCESS, stage_timeout: float = 20.0, start_request_delay: float = 5.0,
-               initial_kick_delay: float = INITIAL_KICK_SECONDS, join_ping_interval: float = JOIN_PING_INTERVAL):
+               initial_kick_delay: float = INITIAL_KICK_SECONDS, join_ping_interval: float = JOIN_PING_INTERVAL,
+               experiment: str = "", modern_reply: bool = False):
     self.sock = sock
+    self.experiment = experiment if valid_experiment(experiment) else ""
+    self.lifetime_id = uuid.uuid4().hex
+    self.modern_reply = modern_reply
+    self.version_major = 0
+    self.car_started = False
+    self.flags = EXPERIMENTS[self.experiment][1] if self.experiment else set()
     self.initial_kick_delay = initial_kick_delay
     self.join_ping_interval = join_ping_interval
     self.peer_uses_pings = False
@@ -251,6 +299,11 @@ class WirelessBootstrap:
       self.sock.sendall(encode_frame(message_id, payload))
     if message_id not in (WIFI_PING_REQUEST, WIFI_PING_RESPONSE):
       self.log("bootstrap_tx", message=NAMES.get(message_id, message_id), bytes=len(payload))
+      self._log_hex("tx", message_id, payload)
+
+  def _log_hex(self, direction: str, message_id: int, payload: bytes) -> None:
+    if self.experiment and message_id not in HEX_LOG_SKIP:
+      self.log("bootstrap_frame_hex", direction=direction, message=NAMES.get(message_id, message_id), hex=payload.hex())
 
   def next_frame(self, timeout: float) -> tuple[int, bytes]:
     deadline = time.monotonic() + timeout
@@ -277,8 +330,25 @@ class WirelessBootstrap:
       if self.frames_seen > MAX_FRAMES:
         raise BootstrapError(self.stage, "too many bootstrap frames")
       self.log("bootstrap_rx", message=NAMES.get(message_id, message_id), bytes=len(payload))
+      self._log_hex("rx", message_id, payload)
     return message_id, payload
 
+  def _version_response(self, major: int, minor: int, request: bytes) -> bytes:
+    self.version_major = major
+    if major < MODERN_MAJOR or not self.modern_reply:
+      return field(1, major) + field(2, minor) + field(3, self.device_serial) + field(4, self.version_status)
+    selected = channel_type(request)
+    session = field(1, self.device_serial) + field(2, self.lifetime_id)
+    reply = (field(1, major) + field(2, minor) + field(3, self.device_serial) + field(4, MODERN_VERSION_SUCCESS) +
+             field(5, selected) + field(6, session))
+    self.log("bootstrap_version_reply", style="modern", channel_type=selected, hex=reply.hex())
+    return reply
+
+  def silent_after_modern_version(self, error: BaseException) -> bool:
+    """A v4+ head unit took our version reply but never started; the other reply style may suit it."""
+    return (isinstance(error, BootstrapTimeout) and error.stage == "wifi_start" and self.version_major >= MODERN_MAJOR
+            and not self.car_started)
+
   def service(self, message_id: int, payload: bytes) -> bool:
     """Handle stage-independent frames; returns True when consumed."""
     if message_id == WIFI_PING_REQUEST:
@@ -306,6 +376,7 @@ class WirelessBootstrap:
     # exchange if the car has not started it; newer head units (2025 Honda) wait for it.
     start_request_at: float | None = None
     deadline = time.monotonic() + self.stage_timeout
+    latest_deadline = time.monotonic() + REFUSAL_PATIENCE * self.stage_timeout
     initial_kick_at: float | None = time.monotonic() + self.initial_kick_delay
     hint_ready_at: float | None = None
     while endpoint is None:
@@ -337,23 +408,27 @@ class WirelessBootstrap:
         continue
       initial_kick_at = None  # setup messages drive the exchange; pings alone do not
       if message_id == WIFI_VERSION_REQUEST:
-        major, minor, version_endpoint, info = parse_version_request(payload)
+        major, minor, version_endpoint, info = parse_version_request(
+          payload, (6,) if "version_endpoint" in self.flags else ())
         version, head_unit = (major, minor), {**head_unit, **info}
         self.log("bootstrap_version", major=major, minor=minor, head_unit=info,
                  endpoint=version_endpoint.__dict__ if version_endpoint else None, message=describe_version_request(payload))
-        self.send(WIFI_VERSION_RESPONSE, field(1, major) + field(2, minor) + field(3, self.device_serial) +
-                  field(4, self.version_status))
+        self.send(WIFI_VERSION_RESPONSE, self._version_response(major, minor, payload))
         hinted = version_endpoint or hinted
         if hinted is not None and hint_ready_at is None:
           hint_ready_at = time.monotonic() + 3.0
         if start_request_at is None:
           start_request_at = time.monotonic() + self.start_request_delay
       elif message_id == WIFI_START_REQUEST:
+        self.car_started = True
         parsed = parse_endpoint(payload)
         if parsed is None:
           raise BootstrapError(self.stage, "WifiStartRequest has no valid IPv4 endpoint")
         endpoint = parsed
+        if "start_response_first" in self.flags:
+          self.send(WIFI_START_RESPONSE, field(3, STATUS_SUCCESS))
       elif message_id == WIFI_START_RESPONSE:
+        self.car_started = True
         # The car's answer to our WifiStartRequest (2025 Honda): ip=1, port=2, status=3 once it is
         # ready, or a negative status alone before then (it may follow up on its own; ask again anyway).
         status = signed(one(parse_fields(payload), 3, STATUS_SUCCESS))
@@ -362,6 +437,7 @@ class WirelessBootstrap:
           endpoint = parsed
         else:
           self.log("bootstrap_start_refused", status=status, endpoint=parsed is not None)
+          deadline = min(latest_deadline, max(deadline, time.monotonic() + self.stage_timeout))  # a car that answers is not gone
           start_request_at = time.monotonic() + self.start_request_delay
       elif message_id == WIFI_SETUP_INFO:
         setup_endpoint, setup_credentials = parse_setup_info(payload)
diff --git a/openpilot/starpilot/system/starport/bugsink_diagnosis.py b/openpilot/starpilot/system/starport/bugsink_diagnosis.py
index 69f1f172c5..058b9505cf 100644
--- a/openpilot/starpilot/system/starport/bugsink_diagnosis.py
+++ b/openpilot/starpilot/system/starport/bugsink_diagnosis.py
@@ -125,6 +125,11 @@ def diagnosis(session):
     explanation = "Authentication did not complete. A timeout alone does not prove a bad certificate."
     actions = ["Check whether TLS completed and whether the head unit replied to authentication.",
                "Retry with the head unit fully awake; compare with any successful attempt in this session."]
+  elif stage in ("wifi_start", "wifi_info"):
+    category, confidence = "head_unit_bootstrap_stalled", "observed"
+    explanation = "Bluetooth connected and the version exchange ran, but the head unit stopped answering the Wi-Fi setup."
+    actions = ["Read the attached handshake trace for the last messages the head unit sent and the ones it ignored.",
+               "Compare the head unit make, model and protocol version with other reports before changing timings."]
   elif stage in ("connecting_bluetooth", "rfcomm", "bootstrap"):
     category, confidence = "head_unit_unavailable", "suspected"
     explanation = "The Bluetooth/bootstrap exchange did not complete; the head unit may still be waking or already off."
diff --git a/openpilot/starpilot/system/starport/car_profiles.py b/openpilot/starpilot/system/starport/car_profiles.py
index 52ac24a729..faeda26273 100644
--- a/openpilot/starpilot/system/starport/car_profiles.py
+++ b/openpilot/starpilot/system/starport/car_profiles.py
@@ -1,13 +1,15 @@
 """Android Auto tuning selected from the saved head-unit fingerprint or an override."""
 import re
 
-DEFAULTS = {"connect_delay_s": 0.0, "max_window": 2, "phone_services": False, "phone_frames": False}
+DEFAULTS = {"connect_delay_s": 0.0, "max_window": 2, "phone_services": False, "phone_frames": False,
+            "bootstrap_experiments": False}
 
 FINGERPRINT_KEYS = ("head_unit_make", "head_unit_model", "car_make", "car_model", "car_year")
 
 RULES: list[dict] = [
   {"id": "aawireless", "label": "AAWireless", "match": {},
    "tuning": {"max_window": 30, "phone_services": True, "phone_frames": True}},
+  {"id": "unofficial", "label": "Unofficial dongle", "match": {}, "tuning": {"bootstrap_experiments": True}},
 ]
 
 
diff --git a/openpilot/starpilot/system/starport/supervisor.py b/openpilot/starpilot/system/starport/supervisor.py
index 0c161d4e2c..246202f3ab 100644
--- a/openpilot/starpilot/system/starport/supervisor.py
+++ b/openpilot/starpilot/system/starport/supervisor.py
@@ -353,6 +353,7 @@ class Supervisor:
     self._pairing_seen: tuple = ()
     self._car_seen_at = -CAR_LINK_HOLD
     self._hfp_link = threading.Event()  # set when the chosen car opens the hands-free link
+    self._modern_reply: dict[str, bool] = {}  # car address -> answer its v4+ version request like a current phone
     self.auto = AutoConnectPolicy()
     self._companion_retry_at = 0.0
     self.log = EventLog()
@@ -1234,16 +1235,22 @@ class Supervisor:
       channel, source = self._discover_channel(address), "sdp"
     self.log("rfcomm_channel", channel=channel, source=source)
 
+    boot = None
     try:
       self._stage("rfcomm", f"channel {channel}")
       rfcomm = self._track(bt_sockets.connect_rfcomm(address, channel))
       boot = WirelessBootstrap(rfcomm, self._bootstrap_log, device_serial=config["device_name"],
-                               version_status=int(config.get("version_status", 0)))
+                               version_status=int(config.get("version_status", 0)),
+                               experiment="all" if car_profiles.tuning(config)["bootstrap_experiments"] else "",
+                               modern_reply=self._modern_reply.get(address, False))
       self._set(state="wifi_start")
       result = boot.run(lambda credentials: lease.acquire(credentials, cancelled=boot.join_is_cancelled), cancelled=self._stop.is_set)
     except Exception as error:
       if _stray_link(error):
         raise StrayLinkError(f"Bluetooth link to the car is stuck: {error}") from error  # says nothing about the cached channel
+      if boot is not None and boot.silent_after_modern_version(error):
+        self._modern_reply[address] = not self._modern_reply.get(address, False)  # try the other version reply next
+        self.log("bootstrap_reply_switched", modern=self._modern_reply[address])
       if source == "cache" and not self._stop.is_set() and self._status["last_stage"] in ("rfcomm", "wifi_start") and car_never_answered(error):
         self._remember_channel(address, None)  # the car never answered there; ask it over SDP next time
         self.log("rfcomm_cache_dropped", channel=channel)
diff --git a/openpilot/starpilot/system/starport/tests/test_bootstrap_receivers.py b/openpilot/starpilot/system/starport/tests/test_bootstrap_receivers.py
index c61051d162..4c41072a91 100644
--- a/openpilot/starpilot/system/starport/tests/test_bootstrap_receivers.py
+++ b/openpilot/starpilot/system/starport/tests/test_bootstrap_receivers.py
@@ -14,9 +14,10 @@ INFO = field(1, "AAWireless") + field(2, "secret-key") + field(3, "AA:BB:CC:DD:E
 SETUP_INFO = field(4, ENDPOINT) + field(5, field(1, "AAWireless") + field(3, "secret-key") + field(4, 8))
 
 
-def scripted(frames, *, ping_interval=bs.JOIN_PING_INTERVAL):
+def scripted(frames, *, ping_interval=bs.JOIN_PING_INTERVAL, experiment=""):
   """A bootstrap whose car sends `frames` in order, then stays silent; records what the comma sent."""
-  boot = bs.WirelessBootstrap(None, lambda *a, **k: None, stage_timeout=2, join_ping_interval=ping_interval)
+  boot = bs.WirelessBootstrap(None, lambda *a, **k: None, stage_timeout=2, join_ping_interval=ping_interval,
+                          experiment=experiment)
   sent = []
   boot.send = Mock(side_effect=lambda message_id, payload=b"": sent.append(message_id))
   queue = list(frames)
@@ -100,3 +101,100 @@ def test_stop_during_the_join_is_not_reported_as_connected():
   with pytest.raises(bs.BootstrapError, match="cancelled"):
     boot.run(join, cancelled=stop.is_set)
   assert bs.WIFI_CONNECT_STATUS not in sent
+
+
+VERSION_F6 = (field(1, 1) + field(2, 7) + field(4, 5180) + field(5, field(1, "Link") + field(5, "CarLetter")) +
+              field(6, field(1, "192.168.43.158") + field(2, 40707)))
+
+
+def test_version_endpoint_in_field_six_is_read_only_when_asked():
+  assert bs.parse_version_request(VERSION_F6)[2] is None
+  assert bs.parse_version_request(VERSION_F6, (6,))[2] == bs.Endpoint("192.168.43.158", 40707)
+
+
+def test_start_request_is_answered_early_only_by_the_experiment():
+  for experiment, early in (("", False), ("start_response_first", True), ("all", True)):
+    boot, sent = scripted([(bs.WIFI_START_REQUEST, ENDPOINT), (bs.WIFI_INFO_RESPONSE, INFO)], experiment=experiment)
+    boot.run(slow_join(0, []))
+    assert (sent[:2] == [bs.WIFI_START_RESPONSE, bs.WIFI_INFO_REQUEST]) is early
+
+
+def test_experiment_logs_frames_but_never_credentials():
+  events = []
+  boot = bs.WirelessBootstrap(None, lambda name, **v: events.append((name, v)), experiment="all")
+  boot.sock = Mock()
+  boot.send(bs.WIFI_START_RESPONSE, b"\x18\x00")
+  boot.queue = [(bs.WIFI_INFO_RESPONSE, INFO), (bs.WIFI_START_REQUEST, ENDPOINT)]
+  boot.next_frame(1)
+  boot.next_frame(1)
+  dumped = [v for name, v in events if name == "bootstrap_frame_hex"]
+  assert [d["message"] for d in dumped] == ["WifiStartResponse", "WifiStartRequest"]
+  assert INFO.hex() not in str(events)
+  assert bs.WirelessBootstrap(None, lambda *a, **k: events.append(a), experiment="bogus").experiment == ""
+
+
+def test_a_car_that_keeps_refusing_gets_more_time_but_not_forever():
+  refusal = field(3, 1)
+  boot, sent = scripted([(bs.WIFI_START_RESPONSE, refusal)] * 3 + [(bs.WIFI_START_REQUEST, ENDPOINT), (bs.WIFI_INFO_RESPONSE, INFO)])
+  boot.stage_timeout = 0.2
+  boot.start_request_delay = 0.01
+  assert boot.run(slow_join(0, [])).endpoint.port == 5288
+  silent, _ = scripted([])
+  silent.stage_timeout = 0.2
+  idle, late = silent.next_frame, [True]
+
+  def refuse_late(timeout):
+    if late:
+      late.clear()
+      time.sleep(0.15)  # just before the original deadline
+      return bs.WIFI_START_RESPONSE, refusal
+    return idle(timeout)
+
+  silent.next_frame = refuse_late
+  started = time.monotonic()
+  with pytest.raises(bs.BootstrapTimeout):
+    silent.run(slow_join(0, []))
+  elapsed = time.monotonic() - started
+  assert 0.3 < elapsed < 0.2 * bs.REFUSAL_PATIENCE + 0.5
+
+
+KIA_V41 = field(1, 4) + field(2, 1) + field(3, 0) + field(4, 5745) + field(5, field(1, "KIA") + field(5, "MOBIS"))
+DHU_V42 = field(1, 4) + field(2, 2) + field(3, 2) + field(5, field(1, "Google") + field(6, "Desktop Head Unit"))
+FORD_V16 = field(1, 1) + field(2, 6) + field(3, 0) + field(4, 5180) + field(4, 5745) + field(5, field(1, "Ford"))
+
+
+def version_reply(request, modern=True):
+  boot, _ = scripted([])
+  boot.modern_reply = modern
+  sent = []
+  boot.send = Mock(side_effect=lambda message_id, payload=b"": sent.append(payload))
+  boot.next_frame = Mock(side_effect=[(bs.WIFI_VERSION_REQUEST, request), bs.BootstrapError("wifi_start", "stop")])
+  with pytest.raises(bs.BootstrapError):
+    boot.run(slow_join(0, []))
+  return bs.parse_fields(sent[0])
+
+
+def test_version_four_head_units_get_a_phone_shaped_version_reply():
+  kia, dhu = version_reply(KIA_V41), version_reply(DHU_V42)
+  assert kia[1] == [4] and kia[2] == [1] and kia[4] == [1] and kia[5] == [bs.CHANNEL_5GHZ]
+  assert dhu[4] == [1] and dhu[5] == [bs.CHANNEL_24GHZ]
+  session = bs.parse_fields(kia[6][0])
+  assert bs.text(session, 1) == "starpilot" and len(bs.text(session, 2)) == 32
+
+
+def test_older_head_units_and_the_first_try_keep_the_reply_that_works_today():
+  for reply in (version_reply(FORD_V16), version_reply(KIA_V41, modern=False)):
+    assert reply[4] == [0] and 5 not in reply and 6 not in reply
+
+
+def test_only_a_silent_v4_head_unit_asks_for_the_other_reply():
+  timeout = bs.BootstrapTimeout("wifi_start", "head unit did not answer in time")
+  boot, _ = scripted([])
+  boot.version_major = 4
+  assert boot.silent_after_modern_version(timeout)
+  boot.car_started = True
+  assert not boot.silent_after_modern_version(timeout)
+  boot.car_started, boot.version_major = False, 1
+  assert not boot.silent_after_modern_version(timeout)
+  boot.version_major = 4
+  assert not boot.silent_after_modern_version(bs.BootstrapTimeout("wifi_info", "head unit did not answer in time"))
diff --git a/openpilot/starpilot/system/starport/tests/test_car_profiles.py b/openpilot/starpilot/system/starport/tests/test_car_profiles.py
index 70bbb793b9..68183cab20 100644
--- a/openpilot/starpilot/system/starport/tests/test_car_profiles.py
+++ b/openpilot/starpilot/system/starport/tests/test_car_profiles.py
@@ -39,7 +39,8 @@ def config(**values):
 def test_aawireless_tuning_applies_only_when_chosen():
   chosen = config(car_profile_override="aawireless", receiver_name="AAWireless-4F2A")
   assert car_profiles.resolve(chosen) == ("aawireless", "override")
-  assert car_profiles.tuning(chosen) == {"connect_delay_s": 0.0, "max_window": 30, "phone_services": True, "phone_frames": True}
+  assert car_profiles.tuning(chosen) == {"connect_delay_s": 0.0, "max_window": 30, "phone_services": True, "phone_frames": True,
+                                          "bootstrap_experiments": False}
   assert car_profiles.summary(chosen)["car_profile_label"] == "AAWireless"
   for other in (config(receiver_name="AAWireless-4F2A"), config(car_profile_override="default")):
     assert car_profiles.tuning(other) == car_profiles.DEFAULTS
@@ -221,3 +222,10 @@ def test_a_new_adapter_setup_is_not_migrated(tmp_path):
   path = tmp_path / "config.json"
   path.write_text(json.dumps({"config_version": identity_store.CONFIG_VERSION, "car_type": "adapter"}))
   assert identity_store.load_config(path)["car_profile_override"] == ""
+
+
+def test_unofficial_dongle_turns_on_the_handshake_experiments_only_when_chosen():
+  assert car_profiles.valid_override("unofficial")
+  assert car_profiles.tuning(config(car_profile_override="unofficial"))["bootstrap_experiments"] is True
+  for other in (config(), config(car_profile_override="default"), config(car_profile_override="aawireless")):
+    assert car_profiles.tuning(other)["bootstrap_experiments"] is False

From b8f3bcebcbdde0b06428c3096c964d5baafe83ce Mon Sep 17 00:00:00 2001
From: Danny <dannyirwin31@yahoo.com>
Date: Fri, 30 Oct 2026 18:01:28 -0700
Subject: [PATCH 02/38] StarPort: Remember which version reply each v4 head
 unit started with

---
 .../starpilot/system/starport/identity.py     |  3 ++
 .../starpilot/system/starport/supervisor.py   | 29 +++++++++++++++----
 .../system/starport/tests/test_forget_car.py  | 10 +++++++
 .../starport/tests/test_identity_migration.py |  8 +++++
 4 files changed, 45 insertions(+), 5 deletions(-)

diff --git a/openpilot/starpilot/system/starport/identity.py b/openpilot/starpilot/system/starport/identity.py
index 425ea86308..6859db0cf3 100644
--- a/openpilot/starpilot/system/starport/identity.py
+++ b/openpilot/starpilot/system/starport/identity.py
@@ -146,6 +146,7 @@ DEFAULT_CONFIG = {
   "phone_class": True,         # while pairing/connecting, present as a phone: HFP gateway + smartphone Class of Device
   "auto_connect": True,        # start projection on its own when the chosen car is on (onroad, or it reaches the comma)
   "rfcomm_cache": {},          # car address -> Android Auto RFCOMM channel learned over SDP, to skip discovery next time
+  "modern_reply_cache": {},    # car address -> True when its v4+ head unit only started after the phone-style version reply
   "car_type": "",              # wireless setup shown in Galaxy: "builtin" or "adapter"; "" = work it out from the saved companion car
   "car_profile_override": "",  # "" = pick by fingerprint (a wireless adapter must choose); "default" = standard; otherwise a car_profiles id
   "car_fingerprint": {},       # what the chosen car's head unit reported last time, used to pick a profile before it connects
@@ -193,6 +194,8 @@ def load_config(path: Path | None = None) -> dict:
   config["render_profile_kb"] = max(16, min(4096, int(config["render_profile_kb"])))
   config["rfcomm_cache"] = {str(address).upper(): channel for address, channel in config["rfcomm_cache"].items()
                             if type(channel) is int and 1 <= channel <= 30}
+  config["modern_reply_cache"] = {str(address).upper(): True for address, modern in config["modern_reply_cache"].items()
+                                  if modern is True}
   return config
 
 
diff --git a/openpilot/starpilot/system/starport/supervisor.py b/openpilot/starpilot/system/starport/supervisor.py
index 246202f3ab..e7673e2b69 100644
--- a/openpilot/starpilot/system/starport/supervisor.py
+++ b/openpilot/starpilot/system/starport/supervisor.py
@@ -35,7 +35,7 @@ from typing import Any
 from openpilot.common.hardware import COMMA_HARDWARE
 from openpilot.starpilot.system.starport import car_profiles, device_health, identity as identity_store, system_slice
 from openpilot.starpilot.system.starport.auto_connect import AutoConnectPolicy
-from openpilot.starpilot.system.starport.bootstrap import NAMES, BootstrapError, WirelessBootstrap
+from openpilot.starpilot.system.starport.bootstrap import MODERN_MAJOR, NAMES, BootstrapError, WirelessBootstrap
 from openpilot.starpilot.system.starport.bugsink_report import PairingAttempt
 from openpilot.starpilot.system.starport.frame_source import (DEFAULT_PATH as DEFAULT_FRAME_PATH, FLAG_ASYNC_READBACK, FLAG_NV12,
                                                                   FORMAT_NV12, FrameRequest)
@@ -498,11 +498,13 @@ class Supervisor:
       self.stop()
     with self._lock:
       companion = self.config.get("companion_address", "").upper() == address
-      cache = dict(self.config["rfcomm_cache"])
+      cache, replies = dict(self.config["rfcomm_cache"]), dict(self.config.get("modern_reply_cache", {}))
       cached = cache.pop(address, None) is not None
+      cached = replies.pop(address, None) is not None or cached
       if not (chosen or companion or cached):
         return False  # nothing of this device was kept
-      self.config["rfcomm_cache"] = cache
+      self.config.update(rfcomm_cache=cache, modern_reply_cache=replies)
+      self._modern_reply.pop(address, None)
       if chosen:
         if self._bluez is not None:
           self._bluez.release()
@@ -987,6 +989,21 @@ class Supervisor:
     else:
       bluez.restore_class()
 
+  def _remember_reply(self, address: str, modern: bool) -> None:
+    """Keep the version reply a v4+ head unit started with, so the next session leads with it."""
+    with self._lock:
+      self._modern_reply[address] = modern
+      replies = dict(self.config.get("modern_reply_cache", {}))
+      if modern == replies.get(address, False):
+        return
+      if modern:
+        replies[address] = True
+      else:
+        replies.pop(address, None)
+      self.config["modern_reply_cache"] = replies
+      identity_store.save_config(self.config)
+    self.log("bootstrap_reply_remembered", modern=modern)
+
   def _remember_channel(self, address: str, channel: int | None) -> None:
     with self._lock:
       cache = dict(self.config["rfcomm_cache"])
@@ -1242,14 +1259,14 @@ class Supervisor:
       boot = WirelessBootstrap(rfcomm, self._bootstrap_log, device_serial=config["device_name"],
                                version_status=int(config.get("version_status", 0)),
                                experiment="all" if car_profiles.tuning(config)["bootstrap_experiments"] else "",
-                               modern_reply=self._modern_reply.get(address, False))
+                               modern_reply=self._modern_reply.get(address, config.get("modern_reply_cache", {}).get(address, False)))
       self._set(state="wifi_start")
       result = boot.run(lambda credentials: lease.acquire(credentials, cancelled=boot.join_is_cancelled), cancelled=self._stop.is_set)
     except Exception as error:
       if _stray_link(error):
         raise StrayLinkError(f"Bluetooth link to the car is stuck: {error}") from error  # says nothing about the cached channel
       if boot is not None and boot.silent_after_modern_version(error):
-        self._modern_reply[address] = not self._modern_reply.get(address, False)  # try the other version reply next
+        self._modern_reply[address] = not boot.modern_reply  # try the other version reply next
         self.log("bootstrap_reply_switched", modern=self._modern_reply[address])
       if source == "cache" and not self._stop.is_set() and self._status["last_stage"] in ("rfcomm", "wifi_start") and car_never_answered(error):
         self._remember_channel(address, None)  # the car never answered there; ask it over SDP next time
@@ -1257,6 +1274,8 @@ class Supervisor:
       raise
     if source == "sdp":
       self._remember_channel(address, channel)
+    if boot.version_major >= MODERN_MAJOR:
+      self._remember_reply(address, boot.modern_reply)
     self._set(head_unit=result.head_unit)
     self._remember_fingerprint(result.head_unit)
     bluez.restore_class()  # the car has accepted the comma; stop looking like a phone to everything else
diff --git a/openpilot/starpilot/system/starport/tests/test_forget_car.py b/openpilot/starpilot/system/starport/tests/test_forget_car.py
index 541594d3cb..d20bf89df7 100644
--- a/openpilot/starpilot/system/starport/tests/test_forget_car.py
+++ b/openpilot/starpilot/system/starport/tests/test_forget_car.py
@@ -67,3 +67,13 @@ def test_forget_car_edits_the_saved_config_when_the_daemon_is_not_running(tmp_pa
   assert saved()["companion_address"] == "" and saved()["receiver_address"] == ADAPTER
   assert protocol.forget_car(ADAPTER.lower(), client) is True
   assert saved()["receiver_address"] == "" and saved()["rfcomm_cache"] == {}
+
+
+def test_the_version_reply_a_car_started_with_is_kept_and_forgotten_with_it(sup):
+  sup._remember_reply(ADAPTER, True)
+  sup._remember_reply(OTHER, True)
+  assert saved()["modern_reply_cache"] == {ADAPTER: True, OTHER: True}
+  sup._remember_reply(OTHER, False)
+  assert saved()["modern_reply_cache"] == {ADAPTER: True}
+  daemon.handle(sup, {"command": "forget_receiver", "address": ADAPTER})
+  assert saved()["modern_reply_cache"] == {} and ADAPTER not in sup._modern_reply
diff --git a/openpilot/starpilot/system/starport/tests/test_identity_migration.py b/openpilot/starpilot/system/starport/tests/test_identity_migration.py
index 05731ea7cc..837adf77f4 100644
--- a/openpilot/starpilot/system/starport/tests/test_identity_migration.py
+++ b/openpilot/starpilot/system/starport/tests/test_identity_migration.py
@@ -28,3 +28,11 @@ def test_existing_identity_survives_directory_migration(tmp_path, monkeypatch, o
 
   assert directory == (legacy if outcome == 'denied' else current)
   assert (directory / 'certificate').read_bytes() == b'existing identity'
+
+
+def test_remembered_version_replies_load_only_as_true_per_address(tmp_path):
+  path = tmp_path / "config.json"
+  path.write_text('{"config_version": 7, "modern_reply_cache": {"aa:bb:cc:dd:ee:01": true, "AA:BB:CC:DD:EE:02": false, "x": 1}}')
+  assert identity.load_config(path)["modern_reply_cache"] == {"AA:BB:CC:DD:EE:01": True}
+  path.write_text('{"config_version": 7}')
+  assert identity.load_config(path)["modern_reply_cache"] == {}

From 085aa2a173d18c1b65a710b0b29cb741458f6972 Mon Sep 17 00:00:00 2001
From: dirwin31 <83434411+dirwin31@users.noreply.github.com>
Date: Thu, 29 Oct 2026 22:18:58 -0700
Subject: [PATCH 03/38] Send StarPort logs from Logs & Diagnostics

Adds a Send logs card to the StarPort Logs page so a user can report a
problem with all of their reportable logs: an optional note of up to 60
characters, and the same zip as Download all logs, sent from the device to
the developer's log inbox. Each device keeps its own thread, titled with the
car fingerprint and a hashed device tag. Manual sends only; no automatic
failure reports. If the zip is over the 10 MB size limit, it is resent
without the device snapshot.
---
 openpilot/starpilot/galaxy/server.py          |  38 ++-
 openpilot/starpilot/galaxy/starport_logs.py   |   4 +-
 openpilot/starpilot/galaxy/starport_send.py   | 261 ++++++++++++++++++
 .../galaxy/tests/test_starport_send.mjs       |  62 +++++
 .../galaxy/tests/test_starport_send.py        | 211 ++++++++++++++
 openpilot/starpilot/galaxy/web/css/galaxy.css |   3 +
 openpilot/starpilot/galaxy/web/js/logs.js     |  26 +-
 .../starpilot/galaxy/web/js/starport-logs.js  |  74 +++++
 8 files changed, 670 insertions(+), 9 deletions(-)
 create mode 100644 openpilot/starpilot/galaxy/starport_send.py
 create mode 100644 openpilot/starpilot/galaxy/tests/test_starport_send.mjs
 create mode 100644 openpilot/starpilot/galaxy/tests/test_starport_send.py

diff --git a/openpilot/starpilot/galaxy/server.py b/openpilot/starpilot/galaxy/server.py
index 9de5434177..7423609558 100644
--- a/openpilot/starpilot/galaxy/server.py
+++ b/openpilot/starpilot/galaxy/server.py
@@ -97,7 +97,7 @@ def make_server(*, port=8082, host='127.0.0.1', monitor=None, owner=None, crashe
                 sounds=None, software_operations=None, drive_stats=None, layout_preview_socket=None, controllers_socket=None,
                 remote_pairing=None, parked=None, camera_snapshot=None, clock=time.monotonic, starport_setup=None,
                 starport_client=None, navigation=None, offline_maps=None, drive_state=None, cloud_provider=None, cloud_offroad=None, projection_layout=None,
-                local_access=None, tmux_live=None, starport_logs=None, hotspot=None, toyota_tools=None, replay_client=None, replay_root=None,
+                local_access=None, tmux_live=None, starport_logs=None, starport_log_sender=None, hotspot=None, toyota_tools=None, replay_client=None, replay_root=None,
                 spotify_setup=None, companion=None, phone_location=None, reverse_proxy=None):
   from openpilot.starpilot.galaxy.companion import CompanionRegistry, APK_PATH
   from openpilot.starpilot.gps.phone import PhoneGpsPublisher
@@ -139,6 +139,17 @@ def make_server(*, port=8082, host='127.0.0.1', monitor=None, owner=None, crashe
       from openpilot.starpilot.galaxy.starport_logs import StarPortLogs
       starport_logs_source = StarPortLogs()
     return starport_logs_source
+  starport_log_sender_source = starport_log_sender
+  starport_log_sender_lock = threading.Lock()
+
+  def starport_log_sender():
+    nonlocal starport_log_sender_source
+    with starport_log_sender_lock:
+      if starport_log_sender_source is None:
+        from openpilot.starpilot.galaxy.starport_send import StarPortLogSender, device_summary
+        source = starport_logs()
+        starport_log_sender_source = StarPortLogSender(source.bundle, summary=lambda: device_summary(source.directory))
+    return starport_log_sender_source
   software_source = software
   software_operations_source = software_operations
   software_lock = threading.Lock()
@@ -928,6 +939,9 @@ def make_server(*, port=8082, host='127.0.0.1', monitor=None, owner=None, crashe
           # immediately before sending potentially sensitive content.
           if self.require_session():
             self.json(200, result)
+      elif path == '/api/starport/logs/send':
+        if self.require_session():
+          self.json(200, starport_log_sender().status())
       elif path == '/api/starport/logs' or path.startswith('/api/starport/logs/'):
         if not self.require_session():
           return
@@ -1635,6 +1649,7 @@ def make_server(*, port=8082, host='127.0.0.1', monitor=None, owner=None, crashe
                       '/api/replay/export-start',
                       '/api/galaxy/pair', '/api/galaxy/unpair', '/api/galaxy/device-name', '/api/galaxy/hotspot', '/api/cameras/snapshot',
                       '/api/starport/layout', '/api/starport/enable', '/api/starport/control', '/api/starport/pairing',
+                      '/api/starport/logs/send',
                       '/api/starport/pairing/response', '/api/starport/pairing/cancel', '/api/starport/pairing/select',
                       '/api/spotify/enable', '/api/spotify/key', '/api/spotify/preferences', '/api/spotify/control', '/api/spotify/maintenance',
                       '/api/ui/layout', '/api/ui/layout/preview', '/api/favorites/slots',
@@ -2314,6 +2329,27 @@ def make_server(*, port=8082, host='127.0.0.1', monitor=None, owner=None, crashe
           else:
             self.json(401, {'error': 'Sign in to Galaxy'})
         return
+      if path == '/api/starport/logs/send':
+        if type(payload) is not dict or set(payload) != {'message'}:
+          self.json(400, {'error': 'Invalid StarPort log send request'})
+          return
+        identity = self.settings_session()
+        if identity is None:
+          self.json(401, {'error': 'Sign in to Galaxy'})
+          return
+        from openpilot.starpilot.galaxy.starport_send import SendBusy, SendRejected
+        try:
+          result = starport_log_sender().start(payload['message'])
+        except SendRejected as error:
+          self.json(400, {'error': str(error)})
+        except SendBusy as error:
+          self.json(409, {'error': str(error)})
+        else:
+          if self.settings_session() == identity:
+            self.json(202, result)
+          else:
+            self.json(401, {'error': 'Sign in to Galaxy'})
+        return
       if path == '/api/starport/enable':
         if type(payload) is not dict or set(payload) not in ({'enabled'}, {'enabled', 'enableBluetooth'}) or \
            type(payload['enabled']) is not bool or type(payload.get('enableBluetooth', False)) is not bool or \
diff --git a/openpilot/starpilot/galaxy/starport_logs.py b/openpilot/starpilot/galaxy/starport_logs.py
index 0da2ecb800..eab7fc67e1 100644
--- a/openpilot/starpilot/galaxy/starport_logs.py
+++ b/openpilot/starpilot/galaxy/starport_logs.py
@@ -71,9 +71,9 @@ class StarPortLogs:
     except OSError:
       raise LogsUnavailable from None
 
-  def bundle(self, now: datetime | None = None) -> tuple[str, bytes]:
+  def bundle(self, now: datetime | None = None, *, system_snapshot: bool = True) -> tuple[str, bytes]:
     try:
-      data = compat_report.bundle(self.directory, self.config_path)
+      data = compat_report.bundle(self.directory, self.config_path, **({} if system_snapshot else {"snapshot": None}))
     except OSError:
       raise LogsUnavailable from None
     stamp = (now or datetime.now()).strftime("%Y%m%d-%H%M%S")
diff --git a/openpilot/starpilot/galaxy/starport_send.py b/openpilot/starpilot/galaxy/starport_send.py
new file mode 100644
index 0000000000..332bee4fba
--- /dev/null
+++ b/openpilot/starpilot/galaxy/starport_send.py
@@ -0,0 +1,261 @@
+"""Send StarPort Logs: post the "Download all logs" zip to the developer's Discord, from Logs & Diagnostics.
+
+Only sent when the user presses Send; there are no automatic reports. Each device gets its own forum
+thread, titled with its car and a short hashed device tag, and later sends from the same device go to
+that thread. The webhook URL is built in, encoded so repository scanners don't pick it up; a URL in
+WEBHOOK_OVERRIDE_PATH on the device replaces it without a code change.
+"""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import json
+import os
+import re
+import tempfile
+import threading
+import time
+from collections.abc import Callable
+from pathlib import Path
+from urllib.parse import parse_qsl, urlencode, urlsplit, urlunsplit
+
+from openpilot.starpilot.system.starport import identity as identity_store
+
+MESSAGE_LIMIT = 60
+WEBHOOK_OVERRIDE_PATH = identity_store.DATA_DIR / "webhook_url"
+THREAD_DIR = identity_store.DATA_DIR / "discord_threads"
+# The Discord webhook URL that receives StarPort logs, XORed with _WEBHOOK_KEY and base64-encoded so it is not
+# stored in plain text ("" = sending not set up). Obfuscation only: the device has to be able to decode it.
+_WEBHOOK_KEY = b"starport-logs"
+_WEBHOOK_DATA = "".join(("GwAVAgNVXVtJBRwEHAEQTxEfAl0VXQVAEBYRHA4dGxxdRRhaWlJLREBYRkZcS0UcXl1QQVwAEEIzAydBSA",
+                         "4KIjQjDShfJj0ZRkA6OjEbMi4JRzE6Rh1sOxo/HCVCDRMlCzRBHyIhUgQFTDAfChwdAGkpWR0HES0ZJw=="))
+DISCORD_FILE_LIMIT = 10 * 1024 * 1024 - 64 * 1024  # 10 MiB attachment limit, with room for the form fields
+THREAD_CACHE_WARNING = "The forum thread could not be remembered on this device. The next upload may create another post."
+CONTROL = re.compile(r"[\x00-\x1f\x7f]+")
+
+
+class SendRejected(Exception):
+  pass
+
+
+class SendBusy(Exception):
+  pass
+
+
+def webhook_url(override_path: Path = WEBHOOK_OVERRIDE_PATH) -> str:
+  try:
+    override = override_path.read_text().strip()
+  except OSError:
+    override = ""
+  if override:
+    return override
+  if not _WEBHOOK_DATA:
+    return ""
+  data = base64.b64decode(_WEBHOOK_DATA)
+  return bytes(byte ^ _WEBHOOK_KEY[index % len(_WEBHOOK_KEY)] for index, byte in enumerate(data)).decode()
+
+
+def clean_message(value) -> str:
+  if not isinstance(value, str):
+    raise SendRejected("The message must be text.")
+  message = CONTROL.sub(" ", value).strip()
+  if len(message) > MESSAGE_LIMIT:
+    raise SendRejected(f"Keep the message to {MESSAGE_LIMIT} characters.")
+  return message
+
+
+def _car_fingerprint() -> str:
+  from openpilot.common.params import Params
+  from openpilot.starpilot.saved_source import read_saved
+  raw, readable = read_saved(Params(), "CarParamsPersistent", 1 << 20)
+  if not readable or not raw:
+    return ""
+  from openpilot.cereal import messaging
+  from opendbc.car.structs import car
+  from openpilot.starpilot.schema_cache import inspect_cache
+  inspected = inspect_cache("CarParamsPersistent", raw)
+  if inspected.status != "valid" or inspected.payload is None:
+    return ""
+  fingerprint = str(messaging.log_from_bytes(inspected.payload, car.CarParams).carFingerprint or "").strip()
+  return "" if fingerprint == "MOCK" else fingerprint
+
+
+def _head_unit(log_dir: Path | None, logs_to_check: int = 3) -> str:
+  """The car's head unit from the newest session log that identified it, or ''."""
+  from openpilot.starpilot.system.starport import compat_report
+  for path in compat_report.session_logs(log_dir or identity_store.LOG_DIR)[:logs_to_check]:
+    car = compat_report.summarize(compat_report.load_events(path))["car"]
+    name = " ".join(part for part in (car.get("head_unit_make"), car.get("head_unit_model")) if part)
+    name = name or car.get("display_name") or car.get("bluetooth_name") or ""
+    if name:
+      return name
+  return ""
+
+
+def device_summary(log_dir: Path | None = None) -> dict:
+  from openpilot.starpilot.system.starport.bugsink_transport import device_metadata
+  summary = device_metadata()
+  for key, read in (("car_fingerprint", _car_fingerprint), ("head_unit", lambda: _head_unit(log_dir))):
+    try:
+      summary[key] = read()
+    except Exception as error:
+      summary[f"{key}_error"] = str(error)
+  return summary
+
+
+def device_tag(summary: dict) -> str:
+  """8 characters of a hash of the dongle ID: tells devices apart without showing the ID."""
+  dongle_id = summary.get("device_id") or ""
+  return hashlib.sha256(f"starpilot-auto:{dongle_id}".encode()).hexdigest()[:8]
+
+
+def thread_title(summary: dict) -> str:
+  return f"{summary.get('car_fingerprint') or 'Device'} {device_tag(summary)}"[:100]
+
+
+def _response_json(response) -> dict:
+  try:
+    value = response.json()
+  except (AttributeError, ValueError):
+    return {}
+  return value if isinstance(value, dict) else {}
+
+
+def _save_thread_id(path: Path, key: str, thread_id: str) -> None:
+  path.parent.mkdir(parents=True, exist_ok=True)
+  # A power loss during a write must not truncate the previous cache entry.
+  with tempfile.NamedTemporaryFile(mode="w", dir=path.parent, delete=False) as temporary:
+    temporary_path = Path(temporary.name)
+    try:
+      json.dump({"key": key, "thread_id": thread_id}, temporary)
+      temporary.flush()
+      os.fsync(temporary.fileno())
+      os.replace(temporary_path, path)
+    finally:
+      temporary_path.unlink(missing_ok=True)
+
+
+def send(data: bytes, name: str, note: str, summary: dict, url: str | None = None, post=None,
+         thread_dir: Path | None = None) -> str | None:
+  """Post the zip; return a cache warning after success, or raise SendRejected on an upload failure."""
+  url = webhook_url() if url is None else url
+  if not url:
+    raise SendRejected("Sending isn't set up on this build. Use Download all logs and send the file instead.")
+  if len(data) > DISCORD_FILE_LIMIT:
+    raise SendRejected(f"The logs are {len(data) / 1e6:.1f} MB, over Discord's 10 MB limit. Use Download all logs instead.")
+  if post is None:
+    import requests
+    post = requests.post
+  dongle_id = summary.get("device_id") or "device"
+  lines = [f"**StarPort logs from {device_tag(summary)}**",
+           f"Car: {summary.get('car_fingerprint') or 'unknown'}",
+           f"Head unit: {summary.get('head_unit') or 'unknown'}",
+           f"Branch {summary.get('branch', '?')} @ {str(summary.get('commit', '?'))[:10]}",
+           f"Note: {note.strip() or '(none)'}"]
+  payload = {"content": "\n".join(lines)[:1900], "username": "StarPilot diagnostics", "allowed_mentions": {"parse": []}}
+
+  parts = urlsplit(url)
+  query = dict(parse_qsl(parts.query, keep_blank_values=True))
+  explicit_thread = bool(query.get("thread_id"))
+  # Ignore query options when identifying a webhook, and never store its token in the cache.
+  cache_key = hashlib.sha256(json.dumps([parts.scheme, parts.netloc, parts.path.rstrip("/"), dongle_id]).encode()).hexdigest()
+  thread_path = (THREAD_DIR if thread_dir is None else thread_dir) / f"{cache_key}.json"
+  cached_id = None
+  if not explicit_thread:
+    query.pop("thread_id", None)
+    try:
+      entry = json.loads(thread_path.read_text())
+      if isinstance(entry, dict) and entry.get("key") == cache_key:
+        candidate = entry.get("thread_id")
+        if isinstance(candidate, str) and candidate.isascii() and candidate.isdigit():
+          cached_id = candidate
+    except (OSError, ValueError):
+      pass
+
+  # Always wait for confirmation, including uploads to an existing thread.
+  query["wait"] = "true"
+  for attempt in range(2):
+    if not explicit_thread and cached_id:
+      query["thread_id"] = cached_id
+    elif not explicit_thread:
+      query.pop("thread_id", None)
+      payload["thread_name"] = thread_title(summary)
+    post_url = urlunsplit(parts._replace(query=urlencode(query)))
+
+    try:
+      response = post(post_url, data={"payload_json": json.dumps(payload)}, files={"files[0]": (name, data, "application/zip")}, timeout=120)
+    except Exception as error:
+      raise SendRejected(f"Could not send the logs: {type(error).__name__}. Check the internet connection, or use Download all logs.") from error
+
+    # Unknown Channel means the cached thread was deleted (Discord answers 400 for webhooks, 404 elsewhere).
+    # Unknown Webhook does not.
+    if attempt == 0 and cached_id and response.status_code in (400, 404) and _response_json(response).get("code") == 10003:
+      cached_id = None  # Retry from memory even if the cache cannot be removed.
+      try:
+        thread_path.unlink(missing_ok=True)
+      except OSError:
+        pass
+      continue
+    break
+
+  if response.status_code not in (200, 204):
+    reason = str(_response_json(response).get("message") or "")[:120]
+    detail = f"HTTP {response.status_code}{f': {reason}' if reason else ''}"
+    raise SendRejected(f"Discord refused the logs ({detail}). Use Download all logs instead.")
+
+  if not explicit_thread and not cached_id:
+    new_thread_id = _response_json(response).get("channel_id")
+    if not isinstance(new_thread_id, str) or not new_thread_id.isascii() or not new_thread_id.isdigit():
+      return THREAD_CACHE_WARNING
+    try:
+      _save_thread_id(thread_path, cache_key, new_thread_id)
+    except OSError:
+      return THREAD_CACHE_WARNING
+  return None
+
+
+class StarPortLogSender:
+  """One send at a time, off the request thread; the page polls status()."""
+
+  def __init__(self, bundle: Callable[..., tuple[str, bytes]], *, sender: Callable[..., str | None] = send,
+               summary: Callable[[], dict] = device_summary, url: Callable[[], str] = webhook_url):
+    self._bundle, self._sender, self._summary, self._url = bundle, sender, summary, url
+    self._lock = threading.Lock()
+    self._thread: threading.Thread | None = None
+    self._state = {"state": "idle", "message": ""}
+
+  def status(self) -> dict:
+    with self._lock:
+      return {**self._state, "available": bool(self._url()), "messageLimit": MESSAGE_LIMIT}
+
+  def start(self, message) -> dict:
+    note = clean_message(message)
+    with self._lock:
+      if self._thread is not None and self._thread.is_alive():
+        raise SendBusy("StarPort logs are already being sent.")
+      self._state = {"state": "sending", "message": "Collecting logs"}
+      self._thread = threading.Thread(target=self._run, args=(note,), name="starport_log_send", daemon=True)
+      self._thread.start()
+    return self.status()
+
+  def _set(self, **values) -> None:
+    with self._lock:
+      self._state.update(values)
+
+  def _run(self, note: str) -> None:
+    try:
+      summary = self._summary()
+      name, data = self._bundle()
+      left_out = ""
+      if len(data) > DISCORD_FILE_LIMIT:
+        # The device snapshot is the optional, bulky part; the session logs are what matter.
+        name, data = self._bundle(system_snapshot=False)
+        left_out = " The device snapshot was left out to fit Discord's 10 MB limit."
+      self._set(message="Sending logs")
+      warning = self._sender(data, name, note, summary)
+      self._set(state="sent", message=f"Logs sent.{left_out} {warning or 'Thanks!'}".strip(), sentAt=int(time.time()))
+    except SendRejected as error:
+      self._set(state="failed", message=str(error)[:400])
+    except Exception as error:
+      self._set(state="failed", message=f"Could not send the logs: {type(error).__name__}. Use Download all logs instead.")
diff --git a/openpilot/starpilot/galaxy/tests/test_starport_send.mjs b/openpilot/starpilot/galaxy/tests/test_starport_send.mjs
new file mode 100644
index 0000000000..91175e7446
--- /dev/null
+++ b/openpilot/starpilot/galaxy/tests/test_starport_send.mjs
@@ -0,0 +1,62 @@
+import assert from "node:assert/strict"
+import { StarPortLogSend, SEND_URL, MESSAGE_LIMIT } from "../web/js/starport-logs.js"
+
+const flush = async () => { for (let i = 0; i < 8; i++) await Promise.resolve() }
+function fixture() {
+  const requests = [], states = [], timers = []
+  let unauthorized = 0
+  const client = new StarPortLogSend({ publish: (state) => states.push(state), unauthorized: () => { unauthorized++ },
+    fetcher: (url, options) => new Promise((resolve) => requests.push({ url, options, resolve })),
+    schedule: (fn) => { timers.push(fn); return timers.length }, cancel: () => {} })
+  const reply = async (index, body, status = 200) => {
+    requests[index].resolve({ ok: status >= 200 && status < 300, status, json: async () => body })
+    await flush()
+  }
+  return { client, requests, states, timers, reply, get unauthorized() { return unauthorized } }
+}
+
+assert.equal(SEND_URL, "./api/starport/logs/send")
+assert.equal(MESSAGE_LIMIT, 60)
+
+// Status on open, then a send that is polled until it finishes.
+const normal = fixture()
+normal.client.start()
+assert.equal(normal.requests[0].url, SEND_URL)
+await normal.reply(0, { state: "idle", message: "", available: true })
+assert.equal(normal.states.at(-1).state, "idle")
+const sending = normal.client.send("  Black screen  ")
+assert.equal(normal.states.at(-1).state, "sending")
+assert.equal(normal.requests[1].options.method, "POST")
+assert.deepEqual(JSON.parse(normal.requests[1].options.body), { message: "Black screen" })
+await normal.reply(1, { state: "sending", message: "Collecting logs" }, 202)
+assert.equal(await sending, true)
+assert.equal(normal.timers.length, 1)
+normal.timers[0]()
+await normal.reply(2, { state: "sent", message: "Logs sent. Thanks!" })
+assert.equal(normal.states.at(-1).state, "sent")
+assert.equal(normal.timers.length, 1)
+
+// Too long is refused locally; a busy device reports its error.
+const limited = fixture()
+limited.client.start()
+await limited.reply(0, { state: "idle" })
+assert.equal(await limited.client.send("x".repeat(61)), false)
+assert.equal(limited.requests.length, 1)
+assert.match(limited.states.at(-1).error, /60 characters/)
+const busy = limited.client.send("hi")
+await limited.reply(1, { error: "StarPort logs are already being sent." }, 409)
+assert.equal(await busy, false)
+assert.equal(limited.states.at(-1).error, "StarPort logs are already being sent.")
+
+// Signed out.
+const signedOut = fixture()
+signedOut.client.start()
+await signedOut.reply(0, {}, 401)
+assert.equal(signedOut.unauthorized, 1)
+assert.equal(await signedOut.client.send("hi"), false)
+
+// Sending unavailable on this build hides the card.
+const unset = fixture()
+unset.client.start()
+await unset.reply(0, { state: "idle", available: false })
+assert.equal(unset.states.at(-1).available, false)
diff --git a/openpilot/starpilot/galaxy/tests/test_starport_send.py b/openpilot/starpilot/galaxy/tests/test_starport_send.py
new file mode 100644
index 0000000000..aceff896c0
--- /dev/null
+++ b/openpilot/starpilot/galaxy/tests/test_starport_send.py
@@ -0,0 +1,211 @@
+"""Send StarPort Logs: the Discord upload, its per-device thread cache, the background job and its routes."""
+
+import http.client
+import json
+import tempfile
+import threading
+import time
+import unittest
+from pathlib import Path
+from unittest import mock
+from urllib.parse import parse_qs, urlsplit
+
+from openpilot.starpilot.galaxy import starport_send
+from openpilot.starpilot.galaxy.access import GalaxyAccessOwner
+from openpilot.starpilot.galaxy.server import make_server
+from openpilot.starpilot.galaxy.starport_send import (DISCORD_FILE_LIMIT, MESSAGE_LIMIT, SendBusy, SendRejected, StarPortLogSender,
+                                                      clean_message, send, thread_title)
+
+URL = "https://discord.example/api/webhooks/1/token"
+SUMMARY = {"device_id": "0123456789abcdef", "car_fingerprint": "HONDA_CIVIC_2022", "head_unit": "Honda Display Audio",
+           "branch": "Dom", "commit": "abcdef1234567890"}
+
+
+class Response:
+  def __init__(self, status_code=200, body=None):
+    self.status_code, self.body = status_code, body if body is not None else {"channel_id": "555"}
+
+  def json(self):
+    return self.body
+
+
+class Poster:
+  def __init__(self, *responses):
+    self.responses, self.calls = list(responses), []
+
+  def __call__(self, url, data, files, timeout):
+    self.calls.append({"url": url, "payload": json.loads(data["payload_json"]), "files": files})
+    return self.responses.pop(0)
+
+
+def query(call):
+  return {key: values[0] for key, values in parse_qs(urlsplit(call["url"]).query).items()}
+
+
+class SendTest(unittest.TestCase):
+  def setUp(self):
+    temporary = tempfile.TemporaryDirectory()
+    self.addCleanup(temporary.cleanup)
+    self.threads = Path(temporary.name)
+
+  def send(self, post, note="Dropped at the light", data=b"zip"):
+    return send(data, "logs.zip", note, SUMMARY, url=URL, post=post, thread_dir=self.threads)
+
+  def test_first_send_opens_a_device_thread_and_later_sends_reuse_it(self):
+    first = Poster(Response(body={"channel_id": "555"}))
+    self.assertIsNone(self.send(first))
+    call = first.calls[0]
+    self.assertEqual(call["payload"]["thread_name"], thread_title(SUMMARY))
+    self.assertTrue(call["payload"]["thread_name"].startswith("HONDA_CIVIC_2022 "))
+    self.assertEqual(call["payload"]["allowed_mentions"], {"parse": []})
+    self.assertIn("Note: Dropped at the light", call["payload"]["content"])
+    self.assertIn("Head unit: Honda Display Audio", call["payload"]["content"])
+    self.assertNotIn(SUMMARY["device_id"], call["payload"]["content"])
+    self.assertEqual(query(call), {"wait": "true"})
+    self.assertEqual(call["files"]["files[0]"], ("logs.zip", b"zip", "application/zip"))
+    self.assertNotIn("token", "".join(path.read_text() for path in self.threads.iterdir()))
+
+    second = Poster(Response())
+    self.assertIsNone(self.send(second))
+    self.assertEqual(query(second.calls[0])["thread_id"], "555")
+    self.assertNotIn("thread_name", second.calls[0]["payload"])
+
+  def test_deleted_thread_is_forgotten_and_a_new_one_opened(self):
+    self.send(Poster(Response(body={"channel_id": "555"})))
+    poster = Poster(Response(404, {"code": 10003}), Response(body={"channel_id": "777"}))
+    self.assertIsNone(self.send(poster))
+    self.assertEqual(query(poster.calls[0])["thread_id"], "555")
+    self.assertNotIn("thread_id", query(poster.calls[1]))
+    self.assertEqual(poster.calls[1]["payload"]["thread_name"], thread_title(SUMMARY))
+    third = Poster(Response())
+    self.send(third)
+    self.assertEqual(query(third.calls[0])["thread_id"], "777")
+
+  def test_refusals_and_oversize_raise_without_posting(self):
+    with self.assertRaisesRegex(SendRejected, "HTTP 401: Invalid Webhook Token"):
+      self.send(Poster(Response(401, {"message": "Invalid Webhook Token"})))
+    poster = Poster()
+    with self.assertRaisesRegex(SendRejected, "10 MB"):
+      self.send(poster, data=b"x" * (DISCORD_FILE_LIMIT + 1))
+    self.assertEqual(poster.calls, [])
+    with self.assertRaisesRegex(SendRejected, "isn't set up"):
+      send(b"zip", "logs.zip", "", SUMMARY, url="", post=poster, thread_dir=self.threads)
+
+  def test_message_is_limited_and_single_line(self):
+    self.assertEqual(MESSAGE_LIMIT, 60)
+    self.assertEqual(clean_message("  car\nwent black  "), "car went black")
+    self.assertEqual(clean_message("x" * 60), "x" * 60)
+    for bad in ("x" * 61, None, 5):
+      with self.assertRaises(SendRejected):
+        clean_message(bad)
+
+  def test_built_in_webhook_and_override(self):
+    self.assertTrue(starport_send.webhook_url(self.threads / "absent").startswith("https://discord.com/api/webhooks/"))
+    override = self.threads / "webhook_url"
+    override.write_text(f"{URL}\n")
+    self.assertEqual(starport_send.webhook_url(override), URL)
+
+
+class SenderJobTest(unittest.TestCase):
+  def wait(self, job):
+    deadline = time.monotonic() + 2
+    while job.status()["state"] == "sending" and time.monotonic() < deadline:
+      time.sleep(0.01)
+    return job.status()
+
+  def test_sends_in_the_background_and_drops_the_snapshot_when_too_big(self):
+    bundles, sent = [], []
+
+    def bundle(system_snapshot=True):
+      bundles.append(system_snapshot)
+      return "logs.zip", b"x" * (DISCORD_FILE_LIMIT + 1 if system_snapshot else 10)
+
+    job = StarPortLogSender(bundle, sender=lambda *args: sent.append(args), summary=lambda: SUMMARY, url=lambda: URL)
+    self.assertEqual(job.start("hello")["state"], "sending")
+    status = self.wait(job)
+    self.assertEqual(status["state"], "sent")
+    self.assertIn("snapshot was left out", status["message"])
+    self.assertEqual(bundles, [True, False])
+    self.assertEqual(sent[0][2], "hello")
+
+  def test_one_send_at_a_time_and_failures_are_reported(self):
+    release = threading.Event()
+
+    def sender(*_):
+      release.wait(2)
+      raise SendRejected("Discord refused the logs (HTTP 500).")
+
+    job = StarPortLogSender(lambda **_: ("logs.zip", b"zip"), sender=sender, summary=lambda: SUMMARY, url=lambda: URL)
+    job.start("")
+    with self.assertRaises(SendBusy):
+      job.start("again")
+    release.set()
+    self.assertEqual(self.wait(job), {"state": "failed", "message": "Discord refused the logs (HTTP 500).", "available": True,
+                                      "messageLimit": 60})
+
+
+class SendHTTPTest(unittest.TestCase):
+  def setUp(self):
+    temporary = tempfile.TemporaryDirectory()
+    self.addCleanup(temporary.cleanup)
+    self.owner = GalaxyAccessOwner(Path(temporary.name) / "access")
+    self.job = mock.Mock()
+    self.job.status.return_value = {"state": "idle", "message": "", "available": True, "messageLimit": 60}
+    self.job.start.return_value = {"state": "sending", "message": "Collecting logs", "available": True, "messageLimit": 60}
+    self.server = make_server(port=0, owner=self.owner, starport_log_sender=self.job)
+    self.thread = threading.Thread(target=self.server.serve_forever, kwargs={"poll_interval": 0.01}, daemon=True)
+    self.thread.start()
+    self.addCleanup(self.close_server)
+    self.assertTrue(self.owner.configure("password123", lambda: True))
+
+  def close_server(self):
+    self.server.shutdown()
+    self.thread.join(timeout=2)
+    self.server.server_close()
+
+  def request(self, path, *, method="GET", body=None, headers=None):
+    connection = http.client.HTTPConnection("127.0.0.1", self.server.server_port, timeout=2)
+    try:
+      origin = {"Origin": f"http://127.0.0.1:{self.server.server_port}"} if method == "POST" else {}
+      connection.request(method, path, body=body, headers={"Forwarded": "for=203.0.113.8", **origin, **(headers or {})})
+      response = connection.getresponse()
+      return response.status, response.read(), dict(response.getheaders())
+    finally:
+      connection.close()
+
+  def post(self, body, cookie=None):
+    headers = {"Content-Type": "application/json", **({"Cookie": cookie} if cookie else {})}
+    return self.request("/api/starport/logs/send", method="POST", body=json.dumps(body), headers=headers)
+
+  def login(self):
+    status, _, headers = self.post_login()
+    self.assertEqual(status, 200)
+    return headers["Set-Cookie"].split(";", 1)[0]
+
+  def post_login(self):
+    return self.request("/api/auth/login", method="POST", body=json.dumps({"password": "password123"}),
+                        headers={"Content-Type": "application/json"})
+
+  def test_requires_a_session(self):
+    self.assertEqual(self.request("/api/starport/logs/send")[0], 401)
+    self.assertEqual(self.post({"message": "hi"})[0], 401)
+    self.job.start.assert_not_called()
+
+  def test_status_start_and_rejections(self):
+    cookie = self.login()
+    status, body, _ = self.request("/api/starport/logs/send", headers={"Cookie": cookie})
+    self.assertEqual((status, json.loads(body)["state"]), (200, "idle"))
+
+    status, body, _ = self.post({"message": "Black screen after unlock"}, cookie)
+    self.assertEqual((status, json.loads(body)["state"]), (202, "sending"))
+    self.job.start.assert_called_once_with("Black screen after unlock")
+
+    self.assertEqual(self.post({"message": "hi", "extra": 1}, cookie)[0], 400)
+    self.job.start.side_effect = SendRejected("Keep the message to 60 characters.")
+    self.assertEqual(self.post({"message": "x" * 61}, cookie)[0], 400)
+    self.job.start.side_effect = SendBusy("StarPort logs are already being sent.")
+    self.assertEqual(self.post({"message": "hi"}, cookie)[0], 409)
+
+
+if __name__ == "__main__":
+  unittest.main()
diff --git a/openpilot/starpilot/galaxy/web/css/galaxy.css b/openpilot/starpilot/galaxy/web/css/galaxy.css
index 1b167d526e..b6347847cf 100644
--- a/openpilot/starpilot/galaxy/web/css/galaxy.css
+++ b/openpilot/starpilot/galaxy/web/css/galaxy.css
@@ -1060,6 +1060,9 @@ button.gx-chip:hover {
 .gx-starport-log__download { flex: none; width: var(--touch-target); height: var(--touch-target); border: 1px solid var(--glass-border); background: var(--primary-container); color: var(--on-primary-container); }
 .gx-starport-log__download:hover { background: var(--primary); color: var(--on-primary); }
 .gx-starport-logs__section-title { margin: var(--sp-6) 0 var(--sp-3); }
+.gx-starport-send__row { display: flex; flex-wrap: wrap; align-items: center; gap: var(--sp-3); margin-top: var(--sp-3); }
+.gx-starport-send__row .gx-field { flex: 1 1 220px; min-width: 0; }
+.gx-starport-send__count { font-size: var(--fs-xs); opacity: .7; font-variant-numeric: tabular-nums; }
 
 @media (max-width: 700px) {
   .gx-starport-log { gap: var(--sp-3); padding: var(--sp-3); }
diff --git a/openpilot/starpilot/galaxy/web/js/logs.js b/openpilot/starpilot/galaxy/web/js/logs.js
index e15cc72f31..9d1e0a3f94 100644
--- a/openpilot/starpilot/galaxy/web/js/logs.js
+++ b/openpilot/starpilot/galaxy/web/js/logs.js
@@ -5,7 +5,7 @@ import { navigate } from "./router.js"
 import { SystemMonitor } from "./system-monitor.js"
 import { CrashReportsFeed } from "./crash-reports.js"
 import { storedSize } from "./record-deletion.js"
-import { StarPortLogsFeed, BUNDLE_URL, fileUrl, outcomeLabel } from "./starport-logs.js"
+import { StarPortLogsFeed, StarPortLogSend, BUNDLE_URL, MESSAGE_LIMIT, fileUrl, outcomeLabel } from "./starport-logs.js"
 import { MenuTile } from "./menu-tile.js"
 import { BluetoothNotice, bluetoothConnection } from "./bluetooth-notice.js"
 
@@ -15,25 +15,27 @@ export const Logs = {
   props: { path: { type: String, required: true }, mode: { type: String, required: true }, unauthorized: { type: Function, required: true },
     tools: { type: Array, required: true } },
   data: () => ({ crashes: { reports: [], scanIncomplete: false, listLimited: false, status: "idle", error: "", selected: null, preview: null, previewStatus: "idle", deleting: false, storageBytes: 0, reportCount: 0 }, search: "",
-    starportLogs: { sessions: [], others: [], status: "idle", error: "" }, bluetooth: bluetoothConnection() }),
+    starportLogs: { sessions: [], others: [], status: "idle", error: "" }, bluetooth: bluetoothConnection(),
+    logSend: { state: "idle", message: "", available: true, error: "" }, sendNote: "", messageLimit: MESSAGE_LIMIT }),
   computed: {
     visibleReports() { return this.crashes.reports.filter((item) => item.name.toLowerCase().includes(this.search.toLowerCase())) },
   },
   created() {
     this.crashFeed = new CrashReportsFeed({ publish: (update) => Object.assign(this.crashes, update), unauthorized: this.unauthorized })
     this.starportFeed = new StarPortLogsFeed({ publish: (update) => Object.assign(this.starportLogs, update), unauthorized: this.unauthorized })
+    this.sendFeed = new StarPortLogSend({ publish: (update) => Object.assign(this.logSend, update), unauthorized: this.unauthorized })
   },
   mounted() {
     if (this.path === "/logs/crashes" && this.mode === "local") this.crashFeed.start()
-    if (this.path === "/logs/starport" && this.mode === "local") this.starportFeed.start()
+    if (this.path === "/logs/starport" && this.mode === "local") { this.starportFeed.start(); this.sendFeed.start() }
   },
-  beforeUnmount() { this.crashFeed.stop(); this.starportFeed.stop() },
+  beforeUnmount() { this.crashFeed.stop(); this.starportFeed.stop(); this.sendFeed.stop() },
   watch: {
     path(next, previous) {
       if (next === "/logs/crashes" && this.mode === "local") this.crashFeed.start()
       else if (previous === "/logs/crashes") { this.crashFeed.stop(); this.search = "" }
-      if (next === "/logs/starport" && this.mode === "local") this.starportFeed.start()
-      else if (previous === "/logs/starport") this.starportFeed.stop()
+      if (next === "/logs/starport" && this.mode === "local") { this.starportFeed.start(); this.sendFeed.start() }
+      else if (previous === "/logs/starport") { this.starportFeed.stop(); this.sendFeed.stop() }
     },
   },
   methods: {
@@ -42,6 +44,9 @@ export const Logs = {
     bundleUrl: () => BUNDLE_URL,
     fileUrl,
     outcomeLabel,
+    async sendLogs() {
+      if (await this.sendFeed.send(this.sendNote)) this.sendNote = ""
+    },
     reportDate(seconds) { return new Date(seconds * 1000).toLocaleString() },
     reportSize(bytes) { return `${(bytes / 1024).toFixed(1)} KiB` },
     async copyPreview() {
@@ -94,6 +99,15 @@ export const Logs = {
           <p>The last 20 connection sessions, newest first. The archive includes every session, a readable report for each, StarPort settings, the car view's renderer logs, and a snapshot of the device (Wi-Fi, Bluetooth and kernel logs, build, CPU load). Hardware addresses are masked.</p></div></header>
         <BluetoothNotice v-if="bluetooth" feature="Log downloads">Log summaries remain available.</BluetoothNotice>
         <div class="gx-settings__controls gx-actions"><a v-if="!bluetooth" class="gx-btn" :href="bundleUrl()" download><i class="bi bi-file-earmark-zip" aria-hidden="true"></i><span>Download all logs</span><span class="gx-starport-logs__format">ZIP</span></a><button type="button" class="gx-btn gx-btn--tonal" @click="starportFeed.load()"><i class="bi bi-arrow-clockwise" aria-hidden="true"></i><span>Refresh</span></button></div>
+        <section v-if="logSend.available" class="gx-card gx-panel gx-starport-send" aria-labelledby="gx-starport-send-title">
+          <div class="gx-section__header"><i class="bi bi-send" aria-hidden="true"></i><span id="gx-starport-send-title" class="gx-section__title">Send logs to the developer</span></div>
+          <p class="gx-note">Sends the same archive as Download all logs straight from the device. Add a short note about what happened.</p>
+          <div class="gx-starport-send__row"><input class="gx-field" type="text" v-model="sendNote" :maxlength="messageLimit" placeholder="What happened? (optional)" aria-label="Note for the developer" :disabled="logSend.state === 'sending'" @keydown.enter="sendLogs"><span class="gx-starport-send__count" aria-live="polite">{{ sendNote.length }}/{{ messageLimit }}</span><button type="button" class="gx-btn" :disabled="logSend.state === 'sending'" @click="sendLogs"><i class="bi bi-send" aria-hidden="true"></i><span>Send logs</span></button></div>
+          <GxState v-if="logSend.state === 'sending'" loading>{{ logSend.message || 'Sending logs' }}…</GxState>
+          <GxNotice v-else-if="logSend.state === 'sent'" tone="success">{{ logSend.message }}</GxNotice>
+          <GxNotice v-else-if="logSend.state === 'failed'" tone="danger">{{ logSend.message }}</GxNotice>
+          <GxNotice v-if="logSend.error" tone="danger">{{ logSend.error }}</GxNotice>
+        </section>
 
         <GxState v-if="starportLogs.status === 'loading'" loading>Loading StarPort logs…</GxState>
         <GxNotice v-else-if="starportLogs.status === 'unavailable'" tone="danger">{{ starportLogs.error || 'StarPort logs are unavailable.' }}</GxNotice>
diff --git a/openpilot/starpilot/galaxy/web/js/starport-logs.js b/openpilot/starpilot/galaxy/web/js/starport-logs.js
index f88355d5ff..6c2e7de660 100644
--- a/openpilot/starpilot/galaxy/web/js/starport-logs.js
+++ b/openpilot/starpilot/galaxy/web/js/starport-logs.js
@@ -68,3 +68,77 @@ export class StarPortLogsFeed {
     }
   }
 }
+
+export const SEND_URL = `${LOGS_URL}/send`
+export const MESSAGE_LIMIT = 60
+const POLL_MS = 1500
+
+// "Send logs": the device builds the same zip as Download all logs and posts it to the developer's Discord.
+// Only small JSON crosses the connection, so this also works over Bluetooth.
+export class StarPortLogSend {
+  constructor({ publish, unauthorized = () => {}, fetcher = (...args) => fetch(...args), schedule = (fn, ms) => setTimeout(fn, ms),
+    cancel = (id) => clearTimeout(id) }) {
+    Object.assign(this, { publish, unauthorized, fetcher, schedule, cancel })
+    this.active = false
+    this.timer = null
+  }
+
+  stop() {
+    this.active = false
+    if (this.timer !== null) this.cancel(this.timer)
+    this.timer = null
+  }
+
+  start() {
+    this.stop()
+    this.active = true
+    return this.poll()
+  }
+
+  async call(options) {
+    const response = await this.fetcher(SEND_URL, { cache: "no-store", credentials: "same-origin", ...options })
+    if (response.status === 401) {
+      this.stop()
+      this.unauthorized()
+      return null
+    }
+    const body = await response.json().catch(() => null)
+    if (!response.ok) throw new Error(body?.error || "Sending StarPort logs is unavailable")
+    return body
+  }
+
+  apply(body) {
+    if (!this.active || !body) return
+    this.publish({ state: body.state, message: body.message || "", available: body.available !== false, error: "" })
+    if (this.timer !== null) this.cancel(this.timer)
+    this.timer = body.state === "sending" ? this.schedule(() => { this.timer = null; this.poll() }, POLL_MS) : null
+  }
+
+  async poll() {
+    if (!this.active) return
+    try {
+      this.apply(await this.call({}))
+    } catch (error) {
+      if (this.active) this.publish({ error: error?.message || "Sending StarPort logs is unavailable" })
+    }
+  }
+
+  async send(message) {
+    if (!this.active) return false
+    const text = String(message ?? "").trim()
+    if (text.length > MESSAGE_LIMIT) {
+      this.publish({ error: `Keep the message to ${MESSAGE_LIMIT} characters.` })
+      return false
+    }
+    this.publish({ state: "sending", message: "Starting", error: "" })
+    try {
+      const body = await this.call({ method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ message: text }) })
+      if (body === null) return false
+      this.apply(body)
+      return true
+    } catch (error) {
+      if (this.active) this.publish({ state: "idle", error: error?.message || "Sending StarPort logs is unavailable" })
+      return false
+    }
+  }
+}

From 745b1e94de92311f45df18c9353358d37c49f666 Mon Sep 17 00:00:00 2001
From: dirwin31 <83434411+dirwin31@users.noreply.github.com>
Date: Sun, 1 Nov 2026 13:26:31 -0800
Subject: [PATCH 04/38] Send the comma's Bluetooth address in the head unit
 pairing request

LeaseAwarePhone (used for every wireless session) had no adapter() method,
so Supervisor._adapter_address() hit AttributeError, swallowed it, and
returned "". The Bluetooth-service pairing request was therefore never sent
(bluetooth_opened always logged phone_address: "").

A 2020 myChevrolet (head unit 2.46.1.6) through an AAWireless Two+ then
accepted and acknowledged video but never showed it. A real phone sends the
pairing request about 1 s into the session; the car shows Android Auto once
its hands-free link to that address is up.

Pass adapter() through to the wrapped BluezPhone. It is a read-only property
lookup, so it needs no phone-role lease, like devices() and device().
_adapter_address() now logs adapter_address_unavailable instead of failing
silently.

Tested on the car (session-000052): phone_address sent, pairing response
received, picture displayed, touch input worked, 20-29 fps fully acked.

Co-authored-by: droobah <34214975+droobah@users.noreply.github.com>
---
 openpilot/starpilot/system/starport/bluetooth_bridge.py       | 1 +
 openpilot/starpilot/system/starport/supervisor.py             | 4 +++-
 .../starpilot/system/starport/tests/test_bluetooth_bridge.py  | 4 ++++
 3 files changed, 8 insertions(+), 1 deletion(-)

diff --git a/openpilot/starpilot/system/starport/bluetooth_bridge.py b/openpilot/starpilot/system/starport/bluetooth_bridge.py
index 4a8dc08883..7d09cb748b 100644
--- a/openpilot/starpilot/system/starport/bluetooth_bridge.py
+++ b/openpilot/starpilot/system/starport/bluetooth_bridge.py
@@ -830,6 +830,7 @@ class LeaseAwarePhone:
   def devices(self): return self.phone.devices()
   def device(self, address): return self.phone.device(address)
   def snapshot(self, address): return self.phone.snapshot(address)
+  def adapter(self): return self.phone.adapter()  # this comma's address, for the head unit's pairing request
 
   def acquire(self, phone_class: bool = True) -> None:
     if self.lease is None:
diff --git a/openpilot/starpilot/system/starport/supervisor.py b/openpilot/starpilot/system/starport/supervisor.py
index e7673e2b69..8e69a8f5c4 100644
--- a/openpilot/starpilot/system/starport/supervisor.py
+++ b/openpilot/starpilot/system/starport/supervisor.py
@@ -1489,7 +1489,9 @@ class Supervisor:
     """This comma's Bluetooth address for the head unit's pairing request; empty when BlueZ is not up."""
     try:
       return str(self._bluez.adapter()[1].get("Address", "")).upper() if self._bluez is not None else ""
-    except Exception:  # DBus errors vary; the pairing request is optional
+    except Exception as error:  # DBus errors vary; the pairing request is optional
+      # Never silent: a missing adapter() once left every wireless session without the request (no address, no picture).
+      self.log("adapter_address_unavailable", kind=type(error).__name__, error=str(error)[:120])
       return ""
 
   def _project(self, result, lease, ident, connect=None, fragment_acks: bool = False) -> None:
diff --git a/openpilot/starpilot/system/starport/tests/test_bluetooth_bridge.py b/openpilot/starpilot/system/starport/tests/test_bluetooth_bridge.py
index 893f630b30..f65e913621 100644
--- a/openpilot/starpilot/system/starport/tests/test_bluetooth_bridge.py
+++ b/openpilot/starpilot/system/starport/tests/test_bluetooth_bridge.py
@@ -261,8 +261,12 @@ def test_donor_phone_uses_same_lease_and_does_not_take_over_independently(tmp_pa
     def devices(self):
       return []
 
+    def adapter(self):
+      return '/org/bluez/hci0', {'Address': '39:90:21:64:07:00'}
+
   phone = FakePhone()
   wrapper = LeaseAwarePhone(shared, state['session'], lambda *a, **k: None, lambda log: phone)
+  assert wrapper.adapter()[1]['Address'] == '39:90:21:64:07:00'  # read before any lease, for the pairing request
   with pytest.raises(BluetoothAdmissionError, match='not active'):
     wrapper.register_hfp()
   wrapper.acquire_pairing()

From fd660ef6f73b1978de02948081e5e0353a88a99a Mon Sep 17 00:00:00 2001
From: dirwin31 <83434411+dirwin31@users.noreply.github.com>
Date: Sun, 1 Nov 2026 13:29:15 -0800
Subject: [PATCH 05/38] Report the chosen setup, the car's offered video modes
 and the working strategy

Reports could not tell a built-in unit from a dongle, and offers and
handshakes were only visible in failure text, so there was nothing to
compare working pairings against.

session_start now records the setup type (builtin/adapter/usb/app), the
resolved profile and whether it was chosen or detected. Session reports
carry every video mode the head unit offered, whether the comma's address
reached the car in the pairing request, and, for streaming sessions, the
strategy that worked (window, reply style, Wi-Fi channel type). The drive
report gains low-cardinality tags (aa.setup_type, aa.adapter_model,
aa.profile_source, aa.phone_address_sent); long values stay in contexts.
Old logs without these fields still report. aa.schema is now 3.
---
 .../system/starport/bugsink_report.py         | 69 +++++++++++++++++++
 .../system/starport/bugsink_transport.py      |  2 +-
 .../starpilot/system/starport/supervisor.py   |  6 +-
 .../starport/tests/test_bugsink_report.py     | 51 ++++++++++++++
 4 files changed, 126 insertions(+), 2 deletions(-)

diff --git a/openpilot/starpilot/system/starport/bugsink_report.py b/openpilot/starpilot/system/starport/bugsink_report.py
index 4f341c8202..c4860ff879 100644
--- a/openpilot/starpilot/system/starport/bugsink_report.py
+++ b/openpilot/starpilot/system/starport/bugsink_report.py
@@ -161,6 +161,61 @@ def bounded_trace(trace: list[dict], limit: int) -> dict:
   return {"events": kept, "omitted": len(trace) - len(kept)}
 
 
+MAX_OFFERED_MODES = 16
+SETUP_TYPES = ("builtin", "adapter", "usb", "app")
+
+
+def offered_modes(events: list[dict]) -> list[str]:
+  """Every video mode the head unit offered, e.g. "1280x720 H.264 margins 0x240", from its service discovery.
+
+  Kept for working pairings too, so the choice of mode can later be replayed against real cars."""
+  from openpilot.starpilot.system.starport.session import CODEC_H264_BP, CODEC_NAMES, RESOLUTION_NAMES
+  found = next((event for event in events if event["event"] == "discovered"), {})
+  modes: list[str] = []
+  for channel in found.get("channels") or []:
+    for config in (channel.get("video_configs") or []) if isinstance(channel, dict) else []:
+      if not isinstance(config, dict):
+        continue
+
+      def field(number, default=None):
+        values = config.get(str(number), config.get(number))
+        return values[0] if isinstance(values, list) and values and isinstance(values[0], int) else default
+
+      resolution, codec = field(1), field(10, CODEC_H264_BP)
+      text = f"{RESOLUTION_NAMES.get(resolution, f'resolution {resolution}')} {CODEC_NAMES.get(codec, f'codec {codec}')}"
+      if field(3, 0) or field(4, 0):
+        text += f" margins {field(3, 0)}x{field(4, 0)}"
+      modes.append(text)
+  return modes[:MAX_OFFERED_MODES]
+
+
+def session_setup(events: list[dict]) -> dict:
+  """The setup type and profile the owner chose, as recorded when the session started."""
+  start = next((event for event in events if event["event"] == "session_start"), {})
+  setup = start.get("setup") if isinstance(start.get("setup"), dict) else {}
+  kind = setup.get("type")
+  return {key: value for key, value in (
+    ("type", kind if kind in SETUP_TYPES else None),
+    ("profile", scrub(setup.get("profile", ""), 40) or None),
+    ("profile_source", setup.get("profile_source") if setup.get("profile_source") in ("override", "detected", "standard") else None),
+  ) if value}
+
+
+def session_strategy(events: list[dict], setup: dict) -> dict:
+  """What a streaming session ran with; the raw material for "this head unit usually likes this profile"."""
+  if not any(event["event"] == "video_acknowledged" for event in events):
+    return {}
+  ready = next((event for event in reversed(events) if event["event"] == "video_setup"), {})
+  reply = next((event for event in events if event["event"] == "bootstrap_version_reply"), {})
+  mode = ready.get("mode") if isinstance(ready.get("mode"), dict) else {}
+  # Only a wireless bootstrap has a version reply; the modern one is logged, the standard one is its absence.
+  style = reply.get("style") or ("standard" if any(event["event"] == "bootstrap_start_response" for event in events) else None)
+  strategy = {"profile": setup.get("profile"), "window_offered": ready.get("window"), "window_used": ready.get("used_window"),
+              "reply_style": style, "channel_type": reply.get("channel_type"),
+              "config_index": mode.get("config_index")}
+  return {key: value for key, value in strategy.items() if value is not None}
+
+
 def session_record(path: Path) -> dict:
   """One finished session log reduced to its outcome, stage timings, video and the car it talked to."""
   from openpilot.starpilot.system.starport import compat_report
@@ -184,7 +239,14 @@ def session_record(path: Path) -> dict:
   car = report["car"]
   start = next((e for e in events if e["event"] == "session_start"), {})
   software, settings = start.get("software", {}), start.get("settings")
+  setup = session_setup(events)
+  opened = next((e for e in events if e["event"] == "bluetooth_opened"), None)
   record = {
+    "setup": setup,
+    "offered_modes": offered_modes(events),
+    # True when the comma's address went to the car in the pairing request; None when the car never opened that channel.
+    "phone_address_sent": bool(opened.get("phone_address")) if opened is not None else None,
+    "strategy": session_strategy(events, setup),
     "software": {key: str(software.get(key) or "unknown") for key in ("commit", "branch")} if isinstance(software, dict) else {},
     "settings": settings if isinstance(settings, dict) else {},
     "seq": _session_number(path),
@@ -395,6 +457,8 @@ def drive_event(sessions: list[dict]) -> dict:
   head_unit = next((s["head_unit"] for s in reversed(sessions) if s["head_unit"]), {})
   video = next((s["video"] for s in reversed(sessions) if s["video"].get("resolution")), {})
   label = _head_unit_label(head_unit)
+  setup = next((s["setup"] for s in reversed(sessions) if s.get("setup")), {})
+  sent = next((s["phone_address_sent"] for s in reversed(sessions) if s.get("phone_address_sent") is not None), None)
   failures = [failure_detail(failure) for failure in drive_failures(sessions)]
   failed = [session for session in sessions if session["seq"] in {failure["session"] for failure in failures}]
   heading = "failures" if failures else "sessions"
@@ -425,6 +489,11 @@ def drive_event(sessions: list[dict]) -> dict:
              "aa.encoder": video.get("encoder", "unknown"),
              "aa.fps": str(summary["fps_avg"]) if summary["fps_avg"] is not None else "none",
              "aa.failures": str(len(failures)),
+             # Low-cardinality choices only; long values (offered modes, strategy) live in the contexts below.
+             **({"aa.setup_type": setup["type"]} if setup.get("type") else {}),
+             **({"aa.adapter_model": setup["profile"]} if setup.get("profile") else {}),
+             **({"aa.profile_source": setup["profile_source"]} if setup.get("profile_source") else {}),
+             **({"aa.phone_address_sent": "yes" if sent else "no"} if sent is not None else {}),
              **({"aa.attention": ",".join(reasons)[:190]} if reasons else {}),
              **({"aa.cause": latest["cause"], "aa.stage": latest["stage"], "aa.error_kind": latest["error_kind"]} if latest else {})},
     "breadcrumbs": {"values": attempt_breadcrumbs(sessions)},
diff --git a/openpilot/starpilot/system/starport/bugsink_transport.py b/openpilot/starpilot/system/starport/bugsink_transport.py
index 0f5acf7364..969ba752ef 100644
--- a/openpilot/starpilot/system/starport/bugsink_transport.py
+++ b/openpilot/starpilot/system/starport/bugsink_transport.py
@@ -38,7 +38,7 @@ class Sender:
     self.opener = opener or urllib.request.build_opener(NoRedirect())
     self.active = active
     self.logger, self.client = logger, client
-    self.schema_tags = {"aa.schema": "2"} if schema_tags is None else schema_tags
+    self.schema_tags = {"aa.schema": "3"} if schema_tags is None else schema_tags
 
   def __call__(self, **event) -> bool:
     if not self.active():
diff --git a/openpilot/starpilot/system/starport/supervisor.py b/openpilot/starpilot/system/starport/supervisor.py
index 8e69a8f5c4..20152d392a 100644
--- a/openpilot/starpilot/system/starport/supervisor.py
+++ b/openpilot/starpilot/system/starport/supervisor.py
@@ -1134,9 +1134,13 @@ class Supervisor:
     receiver = {"wired": "usb", "headunitpad": "headunitpad", "openheadunit": "openheadunit"}.get(connection, self.config["receiver_name"])
     from openpilot.starpilot.system.starport.bugsink_transport import device_metadata
     software = device_metadata()
+    profile, profile_source = car_profiles.resolve(self.config)
     self.log("session_start", receiver=receiver, generation=generation, trigger=trigger,
              software={key: software.get(key, "unknown") for key in ("commit", "branch")},
-             settings={key: self.config.get(key) for key in REPORTED_SETTINGS})
+             settings={key: self.config.get(key) for key in REPORTED_SETTINGS},
+             # What the owner chose, so a report can tell a built-in unit from a dongle and say which profile applied.
+             setup={"type": {"wired": "usb", "headunitpad": "app", "openheadunit": "app"}.get(connection) or self.car_type(),
+                    "profile": profile, "profile_source": profile_source})
     lease = self._lease() if wireless else NoLease()
     attempt = 0
     car_first = trigger == "onroad" and wireless
diff --git a/openpilot/starpilot/system/starport/tests/test_bugsink_report.py b/openpilot/starpilot/system/starport/tests/test_bugsink_report.py
index d03e3e2e63..3221f8114b 100644
--- a/openpilot/starpilot/system/starport/tests/test_bugsink_report.py
+++ b/openpilot/starpilot/system/starport/tests/test_bugsink_report.py
@@ -441,3 +441,54 @@ def test_pairing_that_failed_carries_a_device_slice_but_success_does_not(tmp_pat
   assert event["contexts"]["starport_pairing_system"]["bluetooth"]["lines"] == ["bt '<name>' up"]
   assert calls[0][1] - calls[0][0] == 30
   assert "starport_pairing_system" not in br.pairing_event({**record, "result": "paired"}, collector)["contexts"]
+
+
+OFFER = {"channels": [{"id": 3, "video_configs": [
+  {"1": [2], "10": [3], "3": [0], "4": [240]},
+  {"1": [8], "10": [7], "3": [288], "4": [1378]},
+  {"1": [7], "10": [7], "3": [0], "4": [811]}]}], "head_unit": {"2": ["Honda"]}}
+
+
+def adapter_session():
+  events = [list(item) for item in STREAMED]
+  events[0] = (0, 0, "session_start", {"receiver": "AAWireless", "trigger": "auto",
+                                       "setup": {"type": "adapter", "profile": "aawireless", "profile_source": "override"}})
+  events[5] = (0, 10, "discovered", {**OFFER, "head_unit": STREAMED[5][3]["head_unit"]})
+  events.insert(6, (0, 10, "bootstrap_start_response", {}))
+  events.insert(7, (0, 10, "bootstrap_version_reply", {"style": "modern", "channel_type": 1}))
+  events.insert(8, (0, 10, "bluetooth_opened", {"channel": 6, "phone_address": "39:90:21:64:07:00"}))
+  events.insert(9, (0, 11, "video_setup", {"mode": {"config_index": 0}, "window": 30, "used_window": 30}))
+  return events
+
+
+def test_report_keeps_setup_offered_modes_and_the_working_strategy(tmp_path):
+  record = br.session_record(write_session(tmp_path, 1, adapter_session()))
+  assert record["setup"] == {"type": "adapter", "profile": "aawireless", "profile_source": "override"}
+  assert record["offered_modes"] == ["1280x720 H.264 margins 0x240", "1440x2560 H.265 margins 288x1378", "1080x1920 H.265 margins 0x811"]
+  assert record["phone_address_sent"] is True
+  assert record["strategy"] == {"profile": "aawireless", "window_offered": 30, "window_used": 30,
+                                "reply_style": "modern", "channel_type": 1, "config_index": 0}
+  event = br.drive_event([record])
+  tags = event["tags"]
+  assert (tags["aa.setup_type"], tags["aa.adapter_model"], tags["aa.profile_source"], tags["aa.phone_address_sent"]) == (
+    "adapter", "aawireless", "override", "yes")
+  context = event["contexts"]["starport_session_1"]
+  assert context["offered_modes"] == record["offered_modes"] and context["strategy"]["reply_style"] == "modern"
+  assert "39:90:21:64:07:00" not in json.dumps(event)  # the comma's own address is sanitized from every field
+
+
+def test_report_records_that_the_address_was_not_sent_and_old_logs_still_report(tmp_path):
+  events = [list(item) for item in STREAMED]
+  events.insert(6, (0, 10, "bluetooth_opened", {"channel": 6, "phone_address": ""}))
+  assert br.drive_event([br.session_record(write_session(tmp_path, 1, events))])["tags"]["aa.phone_address_sent"] == "no"
+  old = br.session_record(write_session(tmp_path, 2, STREAMED))  # a log written before these fields existed
+  assert old["setup"] == {} and old["offered_modes"] == [] and old["phone_address_sent"] is None and old["strategy"] == {}
+  tags = br.drive_event([old])["tags"]
+  assert not any(key in tags for key in ("aa.setup_type", "aa.adapter_model", "aa.profile_source", "aa.phone_address_sent"))
+
+
+def test_unknown_setup_values_are_dropped(tmp_path):
+  events = [list(item) for item in STREAMED]
+  events[0] = (0, 0, "session_start", {"setup": {"type": "<script>", "profile": "x" * 90, "profile_source": "guess"}})
+  setup = br.session_record(write_session(tmp_path, 1, events))["setup"]
+  assert "type" not in setup and "profile_source" not in setup and len(setup["profile"]) <= 40

From 8e0073f1105b71c08e971e3ccc223fb733206d9f Mon Sep 17 00:00:00 2001
From: dirwin31 <83434411+dirwin31@users.noreply.github.com>
Date: Sun, 1 Nov 2026 13:30:11 -0800
Subject: [PATCH 06/38] Show the chosen setup in the StarPort log send

The Discord post now names the setup type, profile and whether it was
chosen or detected, from the newest session log that recorded one, next to
the car and head unit. The zip already carries the same data in each
session log's session_start and discovery events.
---
 openpilot/starpilot/galaxy/starport_send.py        | 14 +++++++++++++-
 .../starpilot/galaxy/tests/test_starport_send.py   |  1 +
 2 files changed, 14 insertions(+), 1 deletion(-)

diff --git a/openpilot/starpilot/galaxy/starport_send.py b/openpilot/starpilot/galaxy/starport_send.py
index 332bee4fba..52ad1e0371 100644
--- a/openpilot/starpilot/galaxy/starport_send.py
+++ b/openpilot/starpilot/galaxy/starport_send.py
@@ -93,10 +93,21 @@ def _head_unit(log_dir: Path | None, logs_to_check: int = 3) -> str:
   return ""
 
 
+def _setup(log_dir: Path | None, logs_to_check: int = 3) -> str:
+  """The setup the owner chose (built-in / adapter / usb / app) and its profile, from the newest log that recorded one."""
+  from openpilot.starpilot.system.starport import compat_report
+  from openpilot.starpilot.system.starport.bugsink_report import session_setup
+  for path in compat_report.session_logs(log_dir or identity_store.LOG_DIR)[:logs_to_check]:
+    setup = session_setup(compat_report.load_events(path))
+    if setup:
+      return " / ".join(str(setup[key]) for key in ("type", "profile", "profile_source") if setup.get(key))
+  return ""
+
+
 def device_summary(log_dir: Path | None = None) -> dict:
   from openpilot.starpilot.system.starport.bugsink_transport import device_metadata
   summary = device_metadata()
-  for key, read in (("car_fingerprint", _car_fingerprint), ("head_unit", lambda: _head_unit(log_dir))):
+  for key, read in (("car_fingerprint", _car_fingerprint), ("head_unit", lambda: _head_unit(log_dir)), ("setup", lambda: _setup(log_dir))):
     try:
       summary[key] = read()
     except Exception as error:
@@ -151,6 +162,7 @@ def send(data: bytes, name: str, note: str, summary: dict, url: str | None = Non
   lines = [f"**StarPort logs from {device_tag(summary)}**",
            f"Car: {summary.get('car_fingerprint') or 'unknown'}",
            f"Head unit: {summary.get('head_unit') or 'unknown'}",
+           f"Setup: {summary.get('setup') or 'unknown'}",
            f"Branch {summary.get('branch', '?')} @ {str(summary.get('commit', '?'))[:10]}",
            f"Note: {note.strip() or '(none)'}"]
   payload = {"content": "\n".join(lines)[:1900], "username": "StarPilot diagnostics", "allowed_mentions": {"parse": []}}
diff --git a/openpilot/starpilot/galaxy/tests/test_starport_send.py b/openpilot/starpilot/galaxy/tests/test_starport_send.py
index aceff896c0..8a24310d8a 100644
--- a/openpilot/starpilot/galaxy/tests/test_starport_send.py
+++ b/openpilot/starpilot/galaxy/tests/test_starport_send.py
@@ -60,6 +60,7 @@ class SendTest(unittest.TestCase):
     self.assertEqual(call["payload"]["allowed_mentions"], {"parse": []})
     self.assertIn("Note: Dropped at the light", call["payload"]["content"])
     self.assertIn("Head unit: Honda Display Audio", call["payload"]["content"])
+    self.assertIn("Setup: unknown", call["payload"]["content"])  # no session log recorded a setup in this fixture
     self.assertNotIn(SUMMARY["device_id"], call["payload"]["content"])
     self.assertEqual(query(call), {"wait": "true"})
     self.assertEqual(call["files"]["files[0]"], ("logs.zip", b"zip", "application/zip"))

From 6854118aa2343c8ef5b142e5774088acea21ae71 Mon Sep 17 00:00:00 2001
From: dirwin31 <83434411+dirwin31@users.noreply.github.com>
Date: Sun, 1 Nov 2026 13:41:21 -0800
Subject: [PATCH 07/38] Wait out an unreachable car by why it was unreachable

Most failed drives in Bugsink never reached video and stopped at Bluetooth,
but one backoff treated a sleeping radio, a service that was not up yet and
this comma's own busy stack alike.

reachability.classify() separates a car that never answered a page (Host is
down, page timeout), a car that answered but refused or reset, and a local
Bluetooth failure. A sleeping car or busy controller now waits at least as
long as before and often longer; other failures wait exactly as before. A
sleeping car no longer makes the comma forget the cached RFCOMM channel.
The class is logged on attempt_failed and reported as aa.reach_class.

The 141 'unknown' failures at the discovering stage now get a diagnosis:
car_asleep, car_not_ready or bluetooth_stack_busy, with next steps.
---
 .../system/starport/bugsink_diagnosis.py      | 20 ++++++-
 .../system/starport/bugsink_report.py         | 10 ++--
 .../starpilot/system/starport/reachability.py | 52 ++++++++++++++++++
 .../starpilot/system/starport/supervisor.py   | 18 +++++--
 .../starport/tests/test_car_never_answered.py | 19 ++++++-
 .../starport/tests/test_reachability.py       | 54 +++++++++++++++++++
 6 files changed, 164 insertions(+), 9 deletions(-)
 create mode 100644 openpilot/starpilot/system/starport/reachability.py
 create mode 100644 openpilot/starpilot/system/starport/tests/test_reachability.py

diff --git a/openpilot/starpilot/system/starport/bugsink_diagnosis.py b/openpilot/starpilot/system/starport/bugsink_diagnosis.py
index 058b9505cf..9d5f060d31 100644
--- a/openpilot/starpilot/system/starport/bugsink_diagnosis.py
+++ b/openpilot/starpilot/system/starport/bugsink_diagnosis.py
@@ -86,7 +86,7 @@ def attempt_records(events):
     if name == "attempt_failed":
       current.update(failed_stage=str(event.get("stage", "")), error_kind=str(event.get("kind", "")),
                      error=sanitize(str(event.get("error", ""))), failed_at_s=elapsed(start, event),
-                     where=sanitize(event.get("where", [])[-4:]))
+                     where=sanitize(event.get("where", [])[-4:]), reach=str(event.get("reach", "")))
     if name == "session_ended":
       current["ended_by_car"] = str(event.get("reason", "")).startswith("Head unit ended projection")
       shutdown = shutdown or current["ended_by_car"]
@@ -130,11 +130,27 @@ def diagnosis(session):
     explanation = "Bluetooth connected and the version exchange ran, but the head unit stopped answering the Wi-Fi setup."
     actions = ["Read the attached handshake trace for the last messages the head unit sent and the ones it ignored.",
                "Compare the head unit make, model and protocol version with other reports before changing timings."]
-  elif stage in ("connecting_bluetooth", "rfcomm", "bootstrap"):
+  elif stage in ("connecting_bluetooth", "discovering", "rfcomm", "bootstrap"):
     category, confidence = "head_unit_unavailable", "suspected"
     explanation = "The Bluetooth/bootstrap exchange did not complete; the head unit may still be waking or already off."
     actions = ["Confirm the selected car is awake and inspect Bluetooth/bootstrap responses in the bundle.",
                "Retry while parked before considering re-pairing; preserve existing bonds for diagnosis."]
+    reach = session.get("reach", "")
+    if reach == "asleep":
+      category = "car_asleep"
+      explanation = "The car did not answer the Bluetooth page at all. Its radio is off or still waking, so waiting is the fix."
+      actions = ["Wait for the car to finish waking and let the retry run; the saved pairing and RFCOMM channel were kept.",
+                 "Only re-pair if the car is awake with its Bluetooth screen open and pages still go unanswered."]
+    elif reach == "not_ready":
+      category = "car_not_ready"
+      explanation = "The car answered Bluetooth but its Android Auto service refused or dropped the connection; it is not ready yet."
+      actions = ["Let the retry run; the car usually accepts a few seconds later.",
+                 "If it repeats on every drive, compare the head unit make and model with other reports."]
+    elif reach == "local":
+      category = "bluetooth_stack_busy"
+      explanation = "This comma's own Bluetooth stack was busy or refused, which says nothing about the car."
+      actions = ["Check for another process or a second pairing attempt holding the controller.",
+                 "Retry once the controller is idle; preserve existing bonds."]
   elif stage == "streaming":
     category, confidence = "projection_interrupted", "observed"
     explanation = "Projection was interrupted. EOF or a timeout alone cannot distinguish a car shutdown from link loss."
diff --git a/openpilot/starpilot/system/starport/bugsink_report.py b/openpilot/starpilot/system/starport/bugsink_report.py
index c4860ff879..dd28f84267 100644
--- a/openpilot/starpilot/system/starport/bugsink_report.py
+++ b/openpilot/starpilot/system/starport/bugsink_report.py
@@ -13,7 +13,7 @@ from collections.abc import Callable
 from datetime import UTC, datetime, timedelta
 from pathlib import Path
 
-from openpilot.starpilot.system.starport import identity as identity_store, system_slice
+from openpilot.starpilot.system.starport import identity as identity_store, reachability, system_slice
 from openpilot.starpilot.system.starport.bugsink_diagnosis import attempt_records, diagnosis, elapsed, sanitize
 from openpilot.starpilot.system.starport.bugsink_summary import batch_summary, failure_summary, pairing_summary, session_timeline, software_tags
 
@@ -258,6 +258,9 @@ def session_record(path: Path) -> dict:
     "furthest_stage": report["furthest_stage"],
     "failed_stage": str(last_failure.get("failed_stage", "")),
     "error_kind": str(last_failure.get("error_kind", "")),
+    "reach": str(last_failure.get("reach", "")) or (reachability.classify(
+      str(last_failure.get("failed_stage", "")), str(last_failure.get("error_kind", "")), str(last_failure.get("error", "")))
+      if last_failure else ""),
     "error": scrub(last_failure.get("error", "")),
     "failures": len(failures),
     "drops": len(drops),
@@ -401,7 +404,7 @@ def failure_detail(session: dict) -> dict:
     "title": f"{assessment['category']} at {stage}: {kind}",
     "session": session["seq"],
     "attempt": session.get("failed_attempt"),
-    "cause": assessment["category"], "stage": stage, "error_kind": kind,
+    "cause": assessment["category"], "stage": stage, "error_kind": kind, "reach": session.get("reach", ""),
     "summary": sanitize(failure_summary(assessment), names),
     "diagnosis": sanitize(assessment, names),
   }
@@ -495,7 +498,8 @@ def drive_event(sessions: list[dict]) -> dict:
              **({"aa.profile_source": setup["profile_source"]} if setup.get("profile_source") else {}),
              **({"aa.phone_address_sent": "yes" if sent else "no"} if sent is not None else {}),
              **({"aa.attention": ",".join(reasons)[:190]} if reasons else {}),
-             **({"aa.cause": latest["cause"], "aa.stage": latest["stage"], "aa.error_kind": latest["error_kind"]} if latest else {})},
+             **({"aa.cause": latest["cause"], "aa.stage": latest["stage"], "aa.error_kind": latest["error_kind"]} if latest else {}),
+             **({"aa.reach_class": latest["reach"]} if latest and latest.get("reach") else {})},
     "breadcrumbs": {"values": attempt_breadcrumbs(sessions)},
     "contexts": {"starport_drive": summary, "starport_head_unit": head_unit,
                  **{f"starport_session_{index + 1}": _public(session) for index, session in enumerate(sessions)},
diff --git a/openpilot/starpilot/system/starport/reachability.py b/openpilot/starpilot/system/starport/reachability.py
new file mode 100644
index 0000000000..6d38a6ff9a
--- /dev/null
+++ b/openpilot/starpilot/system/starport/reachability.py
@@ -0,0 +1,52 @@
+"""Why a connection attempt could not reach the car, so each cause is waited out differently.
+
+Bugsink showed most failed drives never got as far as video, and nearly all of those stopped at Bluetooth: "Host is
+down" and page timeouts (the car's radio is off or busy), connection refused or reset (the radio answered but the
+Android Auto service was not up yet), and the comma's own Bluetooth stack being busy. One fixed backoff treated them alike.
+
+The class is derived from strings so the supervisor (live exceptions) and the report (logged text) agree.
+"""
+
+ASLEEP = "asleep"          # the car did not answer a page at all: off, or still waking
+NOT_READY = "not_ready"    # the car answered, but its Android Auto service or Wi-Fi handshake is not up yet
+LOCAL = "local"            # this comma's own Bluetooth stack refused or was busy; the car says nothing
+OTHER = "other"            # anything else, including every failure after the link is up
+
+CLASSES = (ASLEEP, NOT_READY, LOCAL, OTHER)
+
+_LOCAL = ("device or resource busy", "errno 16]", "operation not permitted", "no such device")
+_ASLEEP = ("host is down", "errno 112]", "page-timeout", "page timeout", "br-connection-page")
+_NOT_READY = ("connection refused", "errno 111]", "connection reset", "errno 104]", "sdp record missing",
+              "does not advertise android auto", "did not answer in time")
+_EARLY_STAGES = ("connecting_bluetooth", "discovering", "rfcomm", "wifi_start", "wifi_info", "bootstrap")
+
+# Waiting longer for a radio that is off does not wake it, and every page holds the controller (a page that crosses
+# the car's own page can strand the link). These are floors: a class never waits less than the standard backoff.
+ASLEEP_FLOOR = (6.0, 8.0, 12.0, 20.0, 30.0)
+LOCAL_FLOOR = (8.0, 10.0, 15.0, 30.0)
+
+
+def classify(stage: str, kind: str, message: str) -> str:
+  text = f"{kind} {message}".lower()
+  if kind == "BluetoothRejected" or any(word in text for word in _LOCAL):
+    return LOCAL
+  if stage not in _EARLY_STAGES:
+    return OTHER
+  if any(word in text for word in _ASLEEP) or (kind == "TimeoutError" and stage == "connecting_bluetooth"):
+    return ASLEEP
+  if any(word in text for word in _NOT_READY) or kind == "BootstrapTimeout":
+    return NOT_READY
+  return OTHER
+
+
+def retry_delay(reach: str, attempt: int, standard: float) -> float:
+  """The wait before the next attempt; never shorter than the standard backoff, and unchanged for other failures."""
+  floor = {ASLEEP: ASLEEP_FLOOR, LOCAL: LOCAL_FLOOR}.get(reach)
+  if floor is None:
+    return standard
+  return max(standard, floor[min(max(attempt, 0), len(floor) - 1)])
+
+
+def keeps_cached_channel(reach: str) -> bool:
+  """A sleeping car says nothing about which RFCOMM channel is right, so its cached channel is kept."""
+  return reach in (ASLEEP, LOCAL)
diff --git a/openpilot/starpilot/system/starport/supervisor.py b/openpilot/starpilot/system/starport/supervisor.py
index 20152d392a..3a3b22a636 100644
--- a/openpilot/starpilot/system/starport/supervisor.py
+++ b/openpilot/starpilot/system/starport/supervisor.py
@@ -33,7 +33,7 @@ from pathlib import Path
 from typing import Any
 
 from openpilot.common.hardware import COMMA_HARDWARE
-from openpilot.starpilot.system.starport import car_profiles, device_health, identity as identity_store, system_slice
+from openpilot.starpilot.system.starport import car_profiles, device_health, identity as identity_store, reachability, system_slice
 from openpilot.starpilot.system.starport.auto_connect import AutoConnectPolicy
 from openpilot.starpilot.system.starport.bootstrap import MODERN_MAJOR, NAMES, BootstrapError, WirelessBootstrap
 from openpilot.starpilot.system.starport.bugsink_report import PairingAttempt
@@ -177,6 +177,15 @@ def car_never_answered(error: BaseException) -> bool:
   return not (isinstance(error, OSError) and error.errno in LOCAL_SOCKET_ERRORS)
 
 
+def drops_cached_channel(stage: str, error: BaseException) -> bool:
+  """Forget the cached RFCOMM channel only when the car answered nothing there for a reason about the channel.
+
+  A sleeping car (page timeout, host down) or this comma's own busy Bluetooth says nothing about which channel is right."""
+  if stage not in ("rfcomm", "wifi_start") or not car_never_answered(error):
+    return False
+  return not reachability.keeps_cached_channel(reachability.classify(stage, type(error).__name__, str(error)))
+
+
 def _where(error: BaseException, depth: int = 4) -> list[str]:
   """The innermost frames of a failure, so a bare exception still says which call raised it."""
   frames = traceback.extract_tb(error.__traceback__)[-depth:]
@@ -1148,6 +1157,7 @@ class Supervisor:
       while not self._stop.is_set():
         started = time.monotonic()
         peer_stopped = False
+        reach = reachability.OTHER  # set by a failed attempt; a clean end or a car-ended session keeps the standard wait
         self.log("attempt_start")
         try:
           if car_first:
@@ -1167,7 +1177,8 @@ class Supervisor:
           stage = error.stage if isinstance(error, BootstrapError) else self._status["last_stage"]
           message = self._describe_error(stage, error)
           self._set(error=message)
-          self.log("attempt_failed", stage=stage, error=message, kind=type(error).__name__, where=_where(error))
+          reach = reachability.classify(stage, type(error).__name__, f"{message} {error}")
+          self.log("attempt_failed", stage=stage, error=message, kind=type(error).__name__, where=_where(error), reach=reach)
           if isinstance(error, StrayLinkError):
             self._clear_stray_link()
             car_first = True  # the car pages right back once its link drops; let it, rather than crossing it again
@@ -1181,6 +1192,7 @@ class Supervisor:
           break
         attempt = 0 if time.monotonic() - started > STABLE_SESSION_SECONDS else attempt + 1
         delay = BACKOFF_SECONDS[min(attempt, len(BACKOFF_SECONDS) - 1)]
+        delay = reachability.retry_delay(reach, attempt, delay)
         if peer_stopped:
           delay = max(delay, PEER_STOP_RETRY_SECONDS)  # the car ended projection itself; do not bounce straight back
         self._set(state="backoff", attempt=attempt, retry_in=delay, mode=None)
@@ -1272,7 +1284,7 @@ class Supervisor:
       if boot is not None and boot.silent_after_modern_version(error):
         self._modern_reply[address] = not boot.modern_reply  # try the other version reply next
         self.log("bootstrap_reply_switched", modern=self._modern_reply[address])
-      if source == "cache" and not self._stop.is_set() and self._status["last_stage"] in ("rfcomm", "wifi_start") and car_never_answered(error):
+      if source == "cache" and not self._stop.is_set() and drops_cached_channel(self._status["last_stage"], error):
         self._remember_channel(address, None)  # the car never answered there; ask it over SDP next time
         self.log("rfcomm_cache_dropped", channel=channel)
       raise
diff --git a/openpilot/starpilot/system/starport/tests/test_car_never_answered.py b/openpilot/starpilot/system/starport/tests/test_car_never_answered.py
index 730e488806..8263ab1e35 100644
--- a/openpilot/starpilot/system/starport/tests/test_car_never_answered.py
+++ b/openpilot/starpilot/system/starport/tests/test_car_never_answered.py
@@ -2,7 +2,7 @@ import errno
 import unittest
 
 from openpilot.starpilot.system.starport.bootstrap import BootstrapTimeout
-from openpilot.starpilot.system.starport.supervisor import car_never_answered
+from openpilot.starpilot.system.starport.supervisor import car_never_answered, drops_cached_channel
 
 
 class TestCarNeverAnswered(unittest.TestCase):
@@ -14,3 +14,20 @@ class TestCarNeverAnswered(unittest.TestCase):
     for error in (OSError(errno.ECONNREFUSED, 'refused'), OSError(errno.EHOSTDOWN, 'down'), TimeoutError(),
                   BootstrapTimeout('wifi_start', 'head unit did not answer in time')):
       self.assertTrue(car_never_answered(error))
+
+
+class TestDropsCachedChannel(unittest.TestCase):
+  def test_a_sleeping_car_keeps_its_channel(self):
+    # The message is what the kernel prints on the device (the errno number differs between macOS and Linux).
+    self.assertFalse(drops_cached_channel('rfcomm', OSError(errno.EHOSTDOWN, 'Host is down')))
+    self.assertFalse(drops_cached_channel('rfcomm', OSError(112, 'Host is down')))
+
+  def test_a_car_that_refuses_or_resets_loses_it(self):
+    for error in (ConnectionRefusedError(errno.ECONNREFUSED, 'Connection refused'), ConnectionResetError(errno.ECONNRESET, 'reset'),
+                  BootstrapTimeout('wifi_start', 'head unit did not answer in time')):
+      self.assertTrue(drops_cached_channel('rfcomm' if not isinstance(error, BootstrapTimeout) else 'wifi_start', error))
+
+  def test_other_stages_and_local_failures_never_drop_it(self):
+    self.assertFalse(drops_cached_channel('authenticating', ConnectionResetError(errno.ECONNRESET, 'reset')))
+    self.assertFalse(drops_cached_channel('rfcomm', OSError(errno.ENOSYS, 'local')))
+    self.assertFalse(drops_cached_channel('rfcomm', OSError(errno.EBUSY, 'Device or resource busy')))
diff --git a/openpilot/starpilot/system/starport/tests/test_reachability.py b/openpilot/starpilot/system/starport/tests/test_reachability.py
new file mode 100644
index 0000000000..5268acb628
--- /dev/null
+++ b/openpilot/starpilot/system/starport/tests/test_reachability.py
@@ -0,0 +1,54 @@
+"""Failures before video are told apart by why the car could not be reached, using the texts Bugsink actually showed."""
+
+import pytest
+
+from openpilot.starpilot.system.starport import bugsink_report as br, reachability as r
+from openpilot.starpilot.system.starport.tests.test_bugsink_report import write_session
+
+CASES = [
+  ("discovering", "RuntimeError", "Could not find the car's Android Auto service: [Errno 112] Host is down", r.ASLEEP),
+  ("connecting_bluetooth", "RuntimeError", "org.bluez.Error.Failed: br-connection-page-timeout", r.ASLEEP),
+  ("connecting_bluetooth", "TimeoutError", "", r.ASLEEP),
+  ("rfcomm", "OSError", "starting wireless setup: [Errno 112] Host is down", r.ASLEEP),
+  ("rfcomm", "ConnectionRefusedError", "[Errno 111] Connection refused", r.NOT_READY),
+  ("rfcomm", "ConnectionResetError", "starting wireless setup: [Errno 104] Connection reset by peer", r.NOT_READY),
+  ("discovering", "RuntimeError", "Head unit does not advertise Android Auto Wireless (SDP record missing)", r.NOT_READY),
+  ("wifi_start", "BootstrapTimeout", "waiting for car: wifi_start: head unit did not answer in time", r.NOT_READY),
+  ("rfcomm", "OSError", "[Errno 16] Device or resource busy", r.LOCAL),
+  ("connecting_bluetooth", "BluetoothRejected", "pairing rejected", r.LOCAL),
+  ("streaming", "TimeoutError", "projecting: Video acknowledgement older than 2.5 s", r.OTHER),  # after the link is up
+  ("authenticating", "ConnectionResetError", "Connection reset by peer", r.OTHER),
+  ("joining_wifi", "BootstrapError", "joining_wifi: ", r.OTHER),
+]
+
+
+@pytest.mark.parametrize("stage,kind,message,expected", CASES)
+def test_classify_known_bugsink_texts(stage, kind, message, expected):
+  assert r.classify(stage, kind, message) == expected
+
+
+def test_waits_are_never_shorter_than_the_standard_backoff_and_other_failures_are_unchanged():
+  standard = (2.0, 4.0, 8.0, 15.0, 30.0)
+  for attempt, base in enumerate(standard):
+    assert r.retry_delay(r.OTHER, attempt, base) == base and r.retry_delay(r.NOT_READY, attempt, base) == base
+    for reach in (r.ASLEEP, r.LOCAL):
+      assert r.retry_delay(reach, attempt, base) >= base
+  assert r.retry_delay(r.ASLEEP, 0, 2.0) == 6.0 and r.retry_delay(r.ASLEEP, 99, 30.0) == 30.0
+
+
+def test_a_sleeping_car_keeps_its_cached_channel_but_a_refusing_one_does_not():
+  assert r.keeps_cached_channel(r.ASLEEP) and r.keeps_cached_channel(r.LOCAL)
+  assert not r.keeps_cached_channel(r.NOT_READY) and not r.keeps_cached_channel(r.OTHER)
+
+
+def test_report_names_a_sleeping_car_instead_of_unknown(tmp_path):
+  events = [(0, 0, "session_start", {"receiver": "Car"}), (0, 1, "stage", {"state": "discovering"}),
+            (0, 9, "attempt_failed", {"stage": "discovering", "kind": "RuntimeError",
+                                      "error": "finding android auto: Could not find the car's Android Auto service: [Errno 112] Host is down"})]
+  record = br.session_record(write_session(tmp_path, 1, events))
+  assert record["reach"] == "asleep"  # derived from the text for logs written before the supervisor recorded it
+  event = br.drive_event([record])
+  assert event["tags"]["aa.cause"] == "car_asleep" and event["tags"]["aa.reach_class"] == "asleep"
+  recorded = [(0, 0, "session_start", {}), (0, 9, "attempt_failed", {"stage": "rfcomm", "kind": "ConnectionRefusedError",
+                                                                      "error": "refused", "reach": "not_ready"})]
+  assert br.session_record(write_session(tmp_path, 2, recorded))["reach"] == "not_ready"

From dbb1fe654738f6b59b410d18f78a0890e39d241b Mon Sep 17 00:00:00 2001
From: dirwin31 <83434411+dirwin31@users.noreply.github.com>
Date: Sun, 1 Nov 2026 13:46:51 -0800
Subject: [PATCH 08/38] Add a StarPort section to the Developer page with the
 new pairing switch and an H.265 setting

The Developer page gets a heading row, StarPort, that groups the StarPort
settings: the New pairing experience switch (on unless turned off), Stay on
Wi-Fi (moved under the heading, same key, label and default) and Allow
H.265 video (off by default, daemon setting allow_hevc).

The heading is a row whose key starts with heading:, projected with
heading=true. It has no choices, is never available and cannot be changed,
and Galaxy draws it as a label. The new pairing switch is a plain file next
to the other StarPort data rather than a Params key, so it reads and changes
with the StarPort service down and needs no device rebuild; absent or
unreadable means on.
---
 .../starpilot/galaxy/developer_settings.py    | 67 ++++++++++++++++---
 .../starpilot/galaxy/setting_descriptions.py  |  7 ++
 openpilot/starpilot/galaxy/settings.py        |  5 +-
 .../tests/description-key-inventory.json      | 20 +++---
 .../galaxy/tests/test_developer_settings.py   | 64 +++++++++++++++++-
 .../galaxy/tests/test_settings_controls.mjs   | 12 ++++
 openpilot/starpilot/galaxy/web/css/galaxy.css |  3 +
 .../galaxy/web/js/galaxy-setting-row.js       |  8 +--
 openpilot/starpilot/system/starport/daemon.py |  2 +
 .../starpilot/system/starport/identity.py     |  2 +
 .../starpilot/system/starport/new_setup.py    | 30 +++++++++
 .../starpilot/system/starport/supervisor.py   | 10 ++-
 .../starpilot/ui/feature_settings_state.py    |  8 +++
 13 files changed, 212 insertions(+), 26 deletions(-)
 create mode 100644 openpilot/starpilot/system/starport/new_setup.py

diff --git a/openpilot/starpilot/galaxy/developer_settings.py b/openpilot/starpilot/galaxy/developer_settings.py
index a81232caff..a04fa617db 100644
--- a/openpilot/starpilot/galaxy/developer_settings.py
+++ b/openpilot/starpilot/galaxy/developer_settings.py
@@ -6,7 +6,8 @@ from openpilot.starpilot.longitudinal.voacc import KEY, DESCRIPTION
 from openpilot.starpilot.ui.calibration_reset import calibration_reset
 from openpilot.starpilot.saved_document import commit_exact
 from openpilot.starpilot.saved_source import read_saved
-from openpilot.starpilot.ui.feature_settings_state import FeatureRow, FeatureSettingsState
+from openpilot.starpilot.system.starport import new_setup
+from openpilot.starpilot.ui.feature_settings_state import HEADING_PREFIX, FeatureRow, FeatureSettingsState
 
 
 STARPORT_WIFI_KEY = "StarPortDedicatedWifi"
@@ -14,6 +15,13 @@ STARPORT_WIFI_DESCRIPTION = ("Experimental. Join the car's Wi-Fi on a second int
                        "phone hotspot during wireless StarPort. Applies from the next StarPort connection.")
 CALIBRATION_RESET = "reset_calibration"
 CALIBRATION_RESET_DESCRIPTION = "Clear camera and steering calibration. The device recalibrates on the next drive."
+STARPORT_HEADING_KEY = HEADING_PREFIX + "starport"
+STARPORT_NEW_SETUP_KEY = "StarPortNewSetup"
+STARPORT_NEW_SETUP_DESCRIPTION = ("Guided StarPort setup with a live checklist of what is being tried. Turn off to use the classic " +
+                                  "setup screens. Applies the next time the setup screen opens.")
+STARPORT_HEVC_KEY = "StarPortAllowHevc"
+STARPORT_HEVC_DESCRIPTION = ("Experimental. Only for a car that offers H.265 and no H.264 video. Cars that offer H.264 are not " +
+                             "affected. Applies from the next StarPort connection.")
 DRIVER_MONITORING_RESET = "reset_driver_monitoring"
 DRIVER_MONITORING_RESET_DESCRIPTION = "Clear saved wheel-side detection. Automatic detection restarts on the next drive."
 
@@ -25,14 +33,40 @@ class DeveloperSettingsOwner:
     self.panda_wake = panda_wake
     self.starport = starport  # returns the StarPort daemon client
 
-  def _starport_enabled(self):
+  def _starport_status(self):
     if self.starport is None:
       return None
     try:
-      return bool(self.starport().call("status")["status"].get("dedicated_wifi_interface"))
+      status = self.starport().call("status")["status"]
+      return status if isinstance(status, dict) else None
     except (OSError, RuntimeError, ValueError, KeyError, TypeError):
       return None  # the service is off; there is nothing to configure
 
+  def _starport_enabled(self):
+    status = self._starport_status()
+    return None if status is None else bool(status.get("dedicated_wifi_interface"))
+
+  def _starport_hevc(self):
+    status = self._starport_status()
+    return None if status is None else bool(status.get("allow_hevc"))
+
+  def _starport_rows(self, parked):
+    """The StarPort section. The switch back to classic setup is always listed; the daemon's settings only while it runs."""
+    new_setup_on = new_setup.enabled()
+    held = "Park the vehicle to change this setting."
+    rows = [FeatureRow(STARPORT_HEADING_KEY, "StarPort", "", available=False),
+            FeatureRow(STARPORT_NEW_SETUP_KEY, "StarPort: New pairing experience", "On" if new_setup_on else "Off",
+                       b"1" if new_setup_on else b"0", ("Off", "On"), available=parked,
+                       reason=STARPORT_NEW_SETUP_DESCRIPTION if parked else held, default_value="On")]
+    status = self._starport_status()
+    if status is not None:
+      enabled, hevc = bool(status.get("dedicated_wifi_interface")), bool(status.get("allow_hevc"))
+      rows.append(FeatureRow(STARPORT_WIFI_KEY, "StarPort: Stay on Wi-Fi", "On" if enabled else "Off", b"1" if enabled else b"0",
+                             ("Off", "On"), available=parked, reason=STARPORT_WIFI_DESCRIPTION if parked else held, default_value="On"))
+      rows.append(FeatureRow(STARPORT_HEVC_KEY, "StarPort: Allow H.265 video", "On" if hevc else "Off", b"1" if hevc else b"0",
+                             ("Off", "On"), available=parked, reason=STARPORT_HEVC_DESCRIPTION if parked else held, default_value="Off"))
+    return tuple(rows)
+
   def _driver_monitoring_reset_allowed(self):
     return self.authorized() and not self.params.get_bool("IsDriverViewEnabled")
 
@@ -62,11 +96,7 @@ class DeveloperSettingsOwner:
     firmware_rows = (() if self.panda_wake is None else
                      tuple(replace(item, vehicle_fingerprint=item.capability[0])
                            for item in self.panda_wake.rows(parked) if item.key == "IgnoreIgnitionLine"))
-    enabled = self._starport_enabled()
-    starport_rows = () if enabled is None else (
-      FeatureRow(STARPORT_WIFI_KEY, "StarPort: Stay on Wi-Fi", "On" if enabled else "Off", b"1" if enabled else b"0", ("Off", "On"),
-                 available=parked, reason=STARPORT_WIFI_DESCRIPTION if parked else "Park the vehicle to change this setting.",
-                 default_value="On"),)
+    starport_rows = self._starport_rows(parked)
     summary = "Changes apply next drive. Panda firmware changes require a device restart." if firmware_rows else "Changes apply next drive."
     return FeatureSettingsState("developer", "Developer driving options", summary,
                                 (row, reset_row, calibration_row, *firmware_rows, *starport_rows), parked)
@@ -96,6 +126,10 @@ class DeveloperSettingsOwner:
       return self.panda_wake is not None and self.panda_wake.apply(request)
     if request.key == STARPORT_WIFI_KEY:
       return self._apply_starport(request)
+    if request.key == STARPORT_HEVC_KEY:
+      return self._apply_hevc(request)
+    if request.key == STARPORT_NEW_SETUP_KEY:
+      return self._apply_new_setup(request)
     if request.key != KEY or request.value not in ("Off", "On") or request.expected not in (None, b"0", b"1"):
       return False
     result = commit_exact(self.params, key=request.key, max_bytes=8, raw=b"1" if request.value == "On" else b"0",
@@ -112,3 +146,20 @@ class DeveloperSettingsOwner:
     except (OSError, RuntimeError, ValueError):
       return False
     return self._starport_enabled() == (request.value == "On")
+
+  def _apply_hevc(self, request):
+    enabled, client = self._starport_hevc(), self.starport
+    if (enabled is None or client is None or request.value not in ("Off", "On") or request.expected != (b"1" if enabled else b"0") or
+        not self.authorized()):
+      return False
+    try:
+      client().call("set_allow_hevc", enabled=request.value == "On")
+    except (OSError, RuntimeError, ValueError):
+      return False
+    return self._starport_hevc() == (request.value == "On")
+
+  def _apply_new_setup(self, request):
+    current = new_setup.enabled()
+    if request.value not in ("Off", "On") or request.expected != (b"1" if current else b"0") or not self.authorized():
+      return False
+    return new_setup.set_enabled(request.value == "On")
diff --git a/openpilot/starpilot/galaxy/setting_descriptions.py b/openpilot/starpilot/galaxy/setting_descriptions.py
index 28715a2be0..6e3f72b586 100644
--- a/openpilot/starpilot/galaxy/setting_descriptions.py
+++ b/openpilot/starpilot/galaxy/setting_descriptions.py
@@ -90,6 +90,10 @@ DESCRIPTIONS = {
   'RemoteStartBootsComma': 'Wakes comma during GM remote start.',
   'HKGRemoteStartBootsComma': 'Wakes comma during Hyundai, Kia or Genesis remote climate operation.',
   'IgnoreIgnitionLine': 'Uses GM CAN ignition instead of the harness ignition signal.',
+  'heading:starport': 'Settings for connecting Android Auto to the car through StarPort.',
+  'StarPortNewSetup': 'Shows the guided StarPort setup with a live checklist instead of the classic setup screens.',
+  'StarPortAllowHevc': 'Lets a car that offers only H.265 video receive H.265; a car with an H.264 mode keeps H.264.',
+  'StarPortDedicatedWifi': "Joins the car's Wi-Fi on a second interface so the comma stays on its home Wi-Fi or phone hotspot.",
   'TeslaWakeOnCAN': 'Wakes comma when the Tesla wakes up, before you press the brake.',
   'RadarRecoveryAlert': 'Play a chime and show a brief message when a radar fault clears. You must re-engage manually.',
   'CameraView': 'Chooses the camera view shown on the driving screen.',
@@ -158,6 +162,9 @@ DESCRIPTIONS = {
 
 # These are initialization explanations, not a second defaults table.
 INITIALIZATION = {
+  'StarPortNewSetup': 'Applies the next time the setup screen opens.',
+  'StarPortAllowHevc': 'Applies from the next StarPort connection.',
+  'StarPortDedicatedWifi': 'Applies from the next StarPort connection.',
   'LateralControllerSelection': ('Applies when driving processes next start: the controller class, vehicle policy and ' +
     'PID/filter state are constructed together.'),
   'UseStarPilotLongitudinalPlanner': 'Applies when the planner next starts: each choice runs a different planner process with its own subscriptions and state.',
diff --git a/openpilot/starpilot/galaxy/settings.py b/openpilot/starpilot/galaxy/settings.py
index 627e035796..f2b6ae3f0a 100644
--- a/openpilot/starpilot/galaxy/settings.py
+++ b/openpilot/starpilot/galaxy/settings.py
@@ -27,7 +27,7 @@ from openpilot.starpilot.audio.alert_volume import SPECS as SOUND_SPECS
 from openpilot.starpilot.ui.presentation import Profile
 from openpilot.common.hardware import HARDWARE
 from openpilot.starpilot.ui.feature_settings_state import (
-  FeatureRow, FeatureSettingsRequest, FEATURE_CONFIRM_ACTIONS, is_long_confirm_action, row_change, row_default,
+  FeatureRow, FeatureSettingsRequest, FEATURE_CONFIRM_ACTIONS, is_heading, is_long_confirm_action, row_change, row_default,
 )
 from openpilot.starpilot.saved_source import read_saved
 from openpilot.starpilot.galaxy.developer_settings import CALIBRATION_RESET, DRIVER_MONITORING_RESET, DeveloperSettingsOwner
@@ -392,7 +392,8 @@ def _projection(row: FeatureRow) -> dict:
           "confirm": bool(row.key in CONFIRM_ACTIONS or is_long_confirm_action(row.key) or
                           row.key in (PIP_RESET, PIP_EDITOR, VASM_RESET, VASM_ANNOTATION) or row.key.startswith(PIP_FORMAT_PREFIX)),
           "repairValue": row.repair_value, "defaultValue": row.default_value, "resetAvailable": row_default(row) is not None,
-          "displayScale": "lane-strength" if row.key == "LaneCenteringStrength" else None}
+          "displayScale": "lane-strength" if row.key == "LaneCenteringStrength" else None,
+          "heading": is_heading(row.key)}
 
 
 def _question(row: FeatureRow, request: FeatureSettingsRequest) -> str:
diff --git a/openpilot/starpilot/galaxy/tests/description-key-inventory.json b/openpilot/starpilot/galaxy/tests/description-key-inventory.json
index 4451cdbba3..26a99b379d 100644
--- a/openpilot/starpilot/galaxy/tests/description-key-inventory.json
+++ b/openpilot/starpilot/galaxy/tests/description-key-inventory.json
@@ -57,13 +57,6 @@
   "LoudBlindspotAlert",
   "LoudBlindspotAlertWhenDisengaged",
   "NostalgiaMode",
-  "slc:offset:1",
-  "slc:offset:2",
-  "slc:offset:3",
-  "slc:offset:4",
-  "slc:offset:5",
-  "slc:offset:6",
-  "slc:offset:7",
   "PIPPreviewEnabled",
   "PIPPreviewInvert",
   "PIPPreviewShowOnBSM",
@@ -106,6 +99,9 @@
   "StandardJerkSpeed",
   "StandardJerkSpeedDecrease",
   "StarPilotDisplayPreferencesEnabled",
+  "StarPortAllowHevc",
+  "StarPortDedicatedWifi",
+  "StarPortNewSetup",
   "SteerFriction",
   "SteerLatAccel",
   "StockConfidenceBallWidget",
@@ -166,6 +162,7 @@
   "display:auto:ScreenBrightness",
   "display:auto:ScreenBrightnessOnroad",
   "enable_human_turn_detection_curv",
+  "heading:starport",
   "lane_change:auto",
   "lane_change:close_gap",
   "lane_change:close_gap_seconds",
@@ -249,7 +246,6 @@
   "profile:aggressive:following:8",
   "profile:aggressive:following:9",
   "profile:global_acceleration",
-  "profile:stopped_gap",
   "profile:global_braking",
   "profile:relaxed:acceleration",
   "profile:relaxed:acceleration:0",
@@ -317,6 +313,7 @@
   "profile:standard:following:7",
   "profile:standard:following:8",
   "profile:standard:following:9",
+  "profile:stopped_gap",
   "profile:traffic:acceleration",
   "profile:traffic:acceleration:0",
   "profile:traffic:acceleration:1",
@@ -357,6 +354,13 @@
   "sentry:reset",
   "sentry:sensitivity",
   "sentry:warning",
+  "slc:offset:1",
+  "slc:offset:2",
+  "slc:offset:3",
+  "slc:offset:4",
+  "slc:offset:5",
+  "slc:offset:6",
+  "slc:offset:7",
   "slc_reset",
   "sounds:auto:DisengageVolume",
   "sounds:auto:EngageVolume",
diff --git a/openpilot/starpilot/galaxy/tests/test_developer_settings.py b/openpilot/starpilot/galaxy/tests/test_developer_settings.py
index e8d283de14..89fddb28c8 100644
--- a/openpilot/starpilot/galaxy/tests/test_developer_settings.py
+++ b/openpilot/starpilot/galaxy/tests/test_developer_settings.py
@@ -3,14 +3,18 @@
 from dataclasses import replace
 from pathlib import Path
 from types import SimpleNamespace
+from unittest import mock
 from typing import cast
 import tempfile
 import unittest
 from unittest.mock import patch
 
-from openpilot.starpilot.galaxy.developer_settings import CALIBRATION_RESET, DRIVER_MONITORING_RESET, STARPORT_WIFI_KEY, DeveloperSettingsOwner
+from openpilot.starpilot.galaxy.developer_settings import (CALIBRATION_RESET, DRIVER_MONITORING_RESET, STARPORT_HEADING_KEY,
+                                                          STARPORT_HEVC_KEY, STARPORT_NEW_SETUP_KEY, STARPORT_WIFI_KEY,
+                                                          DeveloperSettingsOwner)
 from openpilot.starpilot.galaxy.settings import AuthorityContext, ContextSource, SettingsChanged, SettingsGateway
 from openpilot.starpilot.longitudinal.voacc import KEY, selected
+from openpilot.starpilot.system.starport import new_setup
 from openpilot.starpilot.ui.feature_settings_state import FeatureSettingsRequest
 
 
@@ -40,7 +44,7 @@ class FileParams:
 
 class FakeStarPort:
   def __init__(self, enabled=False, running=True):
-    self.enabled, self.running = enabled, running
+    self.enabled, self.running, self.hevc = enabled, running, False
 
   def call(self, command, **payload):
     if not self.running:
@@ -48,7 +52,10 @@ class FakeStarPort:
     if command == "set_dedicated_wifi":
       self.enabled = payload["enabled"]
       return {"ok": True}
-    return {"ok": True, "status": {"dedicated_wifi_interface": self.enabled}}
+    if command == "set_allow_hevc":
+      self.hevc = payload["enabled"]
+      return {"ok": True}
+    return {"ok": True, "status": {"dedicated_wifi_interface": self.enabled, "allow_hevc": self.hevc}}
 
 
 class DeveloperSettingsTest(unittest.TestCase):
@@ -60,6 +67,11 @@ class DeveloperSettingsTest(unittest.TestCase):
     self.cp = SimpleNamespace(openpilotLongitudinalControl=True, notCar=False, dashcamOnly=False, passive=False)
     self.parked = True
     self.owner = DeveloperSettingsOwner(self.params, lambda: self.parked)
+    flag = Path(directory.name) / "new_setup"
+    patch = mock.patch.object(new_setup, "FLAG_PATH", flag)
+    patch.start()
+    self.addCleanup(patch.stop)
+    self.flag = flag
 
   def test_default_off_strict_selection_and_vehicle_admission(self):
     self.assertEqual(self.owner.snapshot().rows[0].value, "Off")
@@ -172,6 +184,52 @@ class DeveloperSettingsTest(unittest.TestCase):
     self.assertFalse(self.owner.apply(FeatureSettingsRequest(DRIVER_MONITORING_RESET, b"1", "confirm", confirmation=True)))
     self.assertTrue(Path(self.params.get_param_path("IsRhdDetected")).exists())
 
+  def test_starport_section_has_a_heading_and_the_escape_hatch_even_with_the_service_off(self):
+    rows = self.owner.snapshot().rows
+    keys = [row.key for row in rows]
+    heading = rows[keys.index(STARPORT_HEADING_KEY)]
+    self.assertEqual((heading.label, heading.value, heading.available, heading.choices), ("StarPort", "", False, ()))
+    self.assertEqual(keys[keys.index(STARPORT_HEADING_KEY) + 1], STARPORT_NEW_SETUP_KEY)  # the heading groups what follows
+    self.assertNotIn(STARPORT_WIFI_KEY, keys)
+    self.assertNotIn(STARPORT_HEVC_KEY, keys)
+    self.assertFalse(self.owner.apply(FeatureSettingsRequest(STARPORT_HEADING_KEY, b"", "On")))  # a heading is never a control
+
+  def test_new_pairing_experience_defaults_on_and_the_classic_screens_are_one_switch_away(self):
+    row = next(row for row in self.owner.snapshot().rows if row.key == STARPORT_NEW_SETUP_KEY)
+    self.assertEqual((row.value, row.source, row.choices, row.default_value, row.available), ("On", b"1", ("Off", "On"), "On", True))
+    self.assertFalse(self.owner.apply(FeatureSettingsRequest(STARPORT_NEW_SETUP_KEY, b"0", "On")))  # stale view
+    self.assertFalse(self.owner.apply(FeatureSettingsRequest(STARPORT_NEW_SETUP_KEY, b"1", "maybe")))
+    self.assertTrue(self.owner.apply(FeatureSettingsRequest(STARPORT_NEW_SETUP_KEY, b"1", "Off")))
+    self.assertFalse(new_setup.enabled())
+    self.assertEqual(next(r for r in self.owner.snapshot().rows if r.key == STARPORT_NEW_SETUP_KEY).value, "Off")
+    self.parked = False
+    self.assertFalse(self.owner.apply(FeatureSettingsRequest(STARPORT_NEW_SETUP_KEY, b"0", "On")))
+    self.parked = True
+    self.assertTrue(self.owner.apply(FeatureSettingsRequest(STARPORT_NEW_SETUP_KEY, b"0", "On")))
+    self.assertTrue(new_setup.enabled())
+
+  def test_unreadable_or_odd_flag_means_on(self):
+    self.flag.write_text("garbage")
+    self.assertTrue(new_setup.enabled())
+    self.flag.unlink()
+    self.assertTrue(new_setup.enabled())
+
+  def test_allow_h265_toggle_defaults_off_and_follows_the_daemon(self):
+    service = FakeStarPort()
+    owner = DeveloperSettingsOwner(self.params, lambda: self.parked, starport=lambda: service)
+    rows = owner.snapshot().rows
+    keys = [row.key for row in rows]
+    self.assertEqual(keys[keys.index(STARPORT_HEADING_KEY):], [STARPORT_HEADING_KEY, STARPORT_NEW_SETUP_KEY, STARPORT_WIFI_KEY, STARPORT_HEVC_KEY])
+    row = rows[keys.index(STARPORT_HEVC_KEY)]
+    self.assertEqual((row.value, row.default_value, row.available), ("Off", "Off", True))
+    self.assertTrue(owner.apply(FeatureSettingsRequest(STARPORT_HEVC_KEY, row.source, "On")))
+    self.assertTrue(service.hevc)
+    self.assertFalse(owner.apply(FeatureSettingsRequest(STARPORT_HEVC_KEY, row.source, "Off")))  # stale view
+    self.parked = False
+    self.assertFalse(owner.apply(FeatureSettingsRequest(STARPORT_HEVC_KEY, b"1", "Off")))
+    self.parked = True
+    service.running = False
+    self.assertFalse(owner.apply(FeatureSettingsRequest(STARPORT_HEVC_KEY, b"1", "Off")))
 
 class CalibrationResetSettingsTest(unittest.TestCase):
   setUp = DeveloperSettingsTest.setUp
diff --git a/openpilot/starpilot/galaxy/tests/test_settings_controls.mjs b/openpilot/starpilot/galaxy/tests/test_settings_controls.mjs
index 93da10fb80..f05c83dee6 100644
--- a/openpilot/starpilot/galaxy/tests/test_settings_controls.mjs
+++ b/openpilot/starpilot/galaxy/tests/test_settings_controls.mjs
@@ -227,3 +227,15 @@ for (const row of [{ value: "30", minimum: 1, maximum: 30, step: 1, unit: "h" },
                    { value: "11.8", minimum: 11.8, maximum: 12.5, step: .1, unit: "V" }]) {
   assert.equal(settingControl(row), "slider")
 }
+
+// A section heading (for example "StarPort" on the Developer page) is a label only: no control, no readout, no default button.
+{
+  const heading = { label: "StarPort", value: "", heading: true, available: false, choices: [], key: "heading:starport" }
+  assert.equal(settingControl(heading), "readout")
+  const template = GalaxySettingRow.template
+  assert.match(template, /'gx-row--heading': row\.heading/)
+  assert.match(template, /v-else-if="!row\.heading" class="gx-row__value gx-row__readout"/)
+  assert.match(template, /showDefault && !row\.heading/)
+  assert.match(template, /presentedRow\.reason && !row\.heading/)
+}
+console.log("Settings controls: section headings render as labels only")
diff --git a/openpilot/starpilot/galaxy/web/css/galaxy.css b/openpilot/starpilot/galaxy/web/css/galaxy.css
index b6347847cf..42561ebe3c 100644
--- a/openpilot/starpilot/galaxy/web/css/galaxy.css
+++ b/openpilot/starpilot/galaxy/web/css/galaxy.css
@@ -1711,6 +1711,9 @@ input[type="checkbox"]:disabled { opacity: .4; cursor: not-allowed; }
 .gx-inset { margin: var(--sp-4); max-width: calc(100% - 2 * var(--sp-4)); }
 .gx-text-danger { color: var(--error); }
 .gx-row.gx-row--borderless { border-top: 0; }
+/* A section title inside a settings page: a label only, never dimmed like an unavailable control. */
+.gx-row.gx-row--heading, .gx-row.gx-row--heading.disabled { opacity: 1; padding-top: 1.25rem; }
+.gx-row--heading .gx-row__label { font-weight: 700; letter-spacing: .04em; text-transform: uppercase; opacity: .75; }
 .gx-row--wrap { flex-wrap: wrap; }
 .gx-row__info.gx-row__info--wide { flex: 1 1 180px; }
 .gx-filter-field { flex: 1 1 14rem; min-width: 0; }
diff --git a/openpilot/starpilot/galaxy/web/js/galaxy-setting-row.js b/openpilot/starpilot/galaxy/web/js/galaxy-setting-row.js
index de6ee7539e..69c1b1b894 100644
--- a/openpilot/starpilot/galaxy/web/js/galaxy-setting-row.js
+++ b/openpilot/starpilot/galaxy/web/js/galaxy-setting-row.js
@@ -215,14 +215,14 @@ export const GalaxySettingRow = {
   },
   beforeUnmount() { this.clearHoldTimer() },
   template: `
-    <div class="gx-row" :class="{ disabled: dimmed, 'gx-row--stack': control === 'slider' }" :inert="busy || updating" :aria-busy="busy || updating || undefined">
+    <div class="gx-row" :class="{ disabled: dimmed, 'gx-row--stack': control === 'slider', 'gx-row--heading': row.heading }" :role="row.heading ? 'heading' : undefined" :aria-level="row.heading ? 3 : undefined" :inert="busy || updating" :aria-busy="busy || updating || undefined">
       <div class="gx-row__info">
         <span class="gx-row__label">{{ row.label }}</span>
-        <span v-if="presentedRow.reason" class="gx-row__desc">{{ ' ' + presentedRow.reason.replace('https://firestar.link/discord', '') }}</span>
+        <span v-if="presentedRow.reason && !row.heading" class="gx-row__desc">{{ ' ' + presentedRow.reason.replace('https://firestar.link/discord', '') }}</span>
         <a v-if="presentedRow.reason?.includes('https://firestar.link/discord')" class="gx-btn gx-btn--tonal" href="https://firestar.link/discord" target="_blank" rel="noopener">StarPilot Discord</a>
         <span v-if="control === 'group' || control === 'action'" class="gx-row__desc">{{ presentedRow.value }}</span>
       </div>
-      <button v-if="control !== 'slider' && showDefault" type="button"
+      <button v-if="control !== 'slider' && showDefault && !row.heading" type="button"
           class="gx-btn gx-btn--tonal gx-setting-default" :disabled="dimmed || !row.resetAvailable"
           :aria-label="'Reset ' + row.label + ' to default'" :title="'Default: ' + presentedRow.defaultValue"
           @click="$emit('reset-default', index)">Default</button>
@@ -249,6 +249,6 @@ export const GalaxySettingRow = {
       </GalaxySelect>
       <button v-else-if="control === 'group'" type="button" class="gx-btn gx-btn--tonal" :disabled="dimmed" @click="$emit('open', row.page)">Manage</button>
       <button v-else-if="control === 'action' && row.action" type="button" class="gx-btn gx-btn--tonal" :disabled="dimmed" @click="$emit('review', index, row.confirm ? 0 : 1)">{{ row.repairValue === 'Reset' || /reset|default/i.test(row.label) ? 'Reset' : row.repairValue ? 'Set ' + row.repairValue : row.label }}</button>
-      <span v-else class="gx-row__value gx-row__readout">{{ displayValue }}</span>
+      <span v-else-if="!row.heading" class="gx-row__value gx-row__readout">{{ displayValue }}</span>
     </div>`,
 }
diff --git a/openpilot/starpilot/system/starport/daemon.py b/openpilot/starpilot/system/starport/daemon.py
index 3482e58b33..fda09c5f3a 100644
--- a/openpilot/starpilot/system/starport/daemon.py
+++ b/openpilot/starpilot/system/starport/daemon.py
@@ -118,6 +118,8 @@ def handle(supervisor: Supervisor, request: dict[str, Any], verifier: StarPortSo
     supervisor.set_auto_connect(bool(request.get("enabled", True)))
   elif command == "set_dedicated_wifi":
     supervisor.set_dedicated_wifi(request.get("enabled") is True)
+  elif command == "set_allow_hevc":
+    supervisor.set_allow_hevc(request.get("enabled") is True)
   elif command == "select_receiver":
     supervisor.select_receiver(str(request.get("address", "")), str(request.get("name", "")))
   elif command == "forget_receiver":
diff --git a/openpilot/starpilot/system/starport/identity.py b/openpilot/starpilot/system/starport/identity.py
index 6859db0cf3..bdec5e601f 100644
--- a/openpilot/starpilot/system/starport/identity.py
+++ b/openpilot/starpilot/system/starport/identity.py
@@ -141,6 +141,7 @@ DEFAULT_CONFIG = {
   "render_profile_kb": 256,    # size cap per render_profile file
   "wifi_interface": "wlan0",
   "dedicated_wifi_interface": True,   # join the car on its own aa0 station so wlan0 stays on home Wi-Fi
+  "allow_hevc": False,         # offer H.265 when the car offers no usable H.264 mode (Galaxy Developer > StarPort)
   "device_name": "StarPilot",
   "version_status": 0,         # WifiVersionResponse status (0 = success) for receivers that negotiate a version
   "phone_class": True,         # while pairing/connecting, present as a phone: HFP gateway + smartphone Class of Device
@@ -189,6 +190,7 @@ def load_config(path: Path | None = None) -> dict:
   if config["usb_mode"] not in ("auto", "handshake", "direct"):
     config["usb_mode"] = "auto"
   config["bitrate_kbps"] = max(1000, min(12000, int(config["bitrate_kbps"])))
+  config["allow_hevc"] = config["allow_hevc"] is True
   if config["rate_control"] not in ("cbr", "vbr"):
     config["rate_control"] = "cbr"
   config["render_profile_kb"] = max(16, min(4096, int(config["render_profile_kb"])))
diff --git a/openpilot/starpilot/system/starport/new_setup.py b/openpilot/starpilot/system/starport/new_setup.py
new file mode 100644
index 0000000000..1123928930
--- /dev/null
+++ b/openpilot/starpilot/system/starport/new_setup.py
@@ -0,0 +1,30 @@
+"""The "New pairing experience" switch (Galaxy Developer > StarPort), on unless the owner turned it off.
+
+A plain file beside the other StarPort data, not a Params key: it is the way back to the classic screens, so it must
+read and change with the StarPort service down or broken, and it needs no device rebuild.
+"""
+from pathlib import Path
+
+from openpilot.starpilot.system.starport.identity import DATA_DIR
+
+FLAG_PATH = DATA_DIR / "new_setup"
+
+
+def enabled(path: Path | None = None) -> bool:
+  """Absent, unreadable or unrecognised means on; only an explicit 0 turns the new flow off."""
+  try:
+    return (path or FLAG_PATH).read_text().strip() != "0"
+  except (OSError, UnicodeError):
+    return True
+
+
+def set_enabled(value: bool, path: Path | None = None) -> bool:
+  target = path or FLAG_PATH
+  try:
+    target.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
+    temporary = target.with_name(f".{target.name}.tmp")
+    temporary.write_text("1" if value else "0")
+    temporary.replace(target)
+  except OSError:
+    return False
+  return enabled(target) == value
diff --git a/openpilot/starpilot/system/starport/supervisor.py b/openpilot/starpilot/system/starport/supervisor.py
index 3a3b22a636..007f50a51a 100644
--- a/openpilot/starpilot/system/starport/supervisor.py
+++ b/openpilot/starpilot/system/starport/supervisor.py
@@ -69,7 +69,7 @@ LINK_CHECK_SLOW = 1.0        # a link check slower than this is logged (NetworkM
 STREAM_STALL_LOG = 1.0       # a streaming loop pass slower than this is logged
 REPORTED_SETTINGS = ("connection", "usb_mode", "view", "encoder", "fps", "bitrate_kbps", "rate_control", "gpu_nv12",
                      "async_readback", "wifi_interface", "dedicated_wifi_interface", "verify_head_unit", "version_status",
-                     "rfcomm_channel", "phone_class", "auto_connect")
+                     "rfcomm_channel", "phone_class", "auto_connect", "allow_hevc")
 
 
 def encoder_preference(configured: str) -> str:
@@ -405,6 +405,7 @@ class Supervisor:
     status["pairing_ready"] = self._pairing_active()
     status["auto_connect"] = bool(self.config["auto_connect"])
     status["dedicated_wifi_interface"] = bool(self.config["dedicated_wifi_interface"])
+    status["allow_hevc"] = bool(self.config["allow_hevc"])
     status["auto_paused"] = self.auto.suppressed
     status["recent"] = list(self.log.recent)[-8:]
     return status
@@ -433,6 +434,13 @@ class Supervisor:
       identity_store.save_config(self.config)
     self.log("dedicated_wifi_selected", enabled=bool(enabled))
 
+  def set_allow_hevc(self, enabled: bool) -> None:
+    """Let a car that offers only H.265 get H.265 video; used from the next session. Cars with an H.264 mode never change."""
+    with self._lock:
+      self.config["allow_hevc"] = bool(enabled)
+      identity_store.save_config(self.config)
+    self.log("allow_hevc_selected", enabled=bool(enabled))
+
   def _adapter_choice_needed(self) -> bool:
     return self.car_type() == "adapter" and not self.config.get("car_profile_override")
 
diff --git a/openpilot/starpilot/ui/feature_settings_state.py b/openpilot/starpilot/ui/feature_settings_state.py
index 386da4bc55..1b41a8a36a 100644
--- a/openpilot/starpilot/ui/feature_settings_state.py
+++ b/openpilot/starpilot/ui/feature_settings_state.py
@@ -75,6 +75,14 @@ FEATURE_CONFIRM_ACTIONS = (TORQUE_CONFIRM_ACTIONS | SLC_CONFIRM_ACTIONS | LANE_C
                            CURVE_CONFIRM_ACTIONS | CONDITIONAL_CONFIRM_ACTIONS | {"reset_profiles", "pip:reset", "sentry:reset"})
 
 
+HEADING_PREFIX = "heading:"
+
+
+def is_heading(key: str) -> bool:
+  """A section title inside a page: shown like a row but never a control, and never a change request."""
+  return key.startswith(HEADING_PREFIX)
+
+
 @dataclass(frozen=True)
 class FeatureRow:
   key: str

From cad0022d3ed9ced5eb7db03a7b115138c576419f Mon Sep 17 00:00:00 2001
From: dirwin31 <83434411+dirwin31@users.noreply.github.com>
Date: Sun, 1 Nov 2026 13:48:07 -0800
Subject: [PATCH 09/38] Wait for NetworkManager to manage a shared Wi-Fi
 interface and tell stream losses apart

Nineteen Bugsink joins were refused with 'device is strictly unmanaged'.
On a shared interface the join now waits up to 8 s for NetworkManager to
manage it (dedicated mode already waited) and otherwise reports that the
interface is unmanaged and for how long, which the diagnosis already maps
to wifi_not_ready.

Stream losses keep the projection_interrupted category but now carry a kind
(stalled, silent, disconnected) with matching next steps, reported as
aa.loss_kind, so a car shutting off is no longer read as link loss.
---
 .../system/starport/bugsink_diagnosis.py      | 20 +++++++++
 .../system/starport/bugsink_report.py         |  6 ++-
 .../starpilot/system/starport/network.py      | 21 +++++++++
 .../tests/test_network_managed_wait.py        | 45 +++++++++++++++++++
 .../starport/tests/test_reachability.py       | 12 +++++
 5 files changed, 102 insertions(+), 2 deletions(-)
 create mode 100644 openpilot/starpilot/system/starport/tests/test_network_managed_wait.py

diff --git a/openpilot/starpilot/system/starport/bugsink_diagnosis.py b/openpilot/starpilot/system/starport/bugsink_diagnosis.py
index 9d5f060d31..61b4fc0374 100644
--- a/openpilot/starpilot/system/starport/bugsink_diagnosis.py
+++ b/openpilot/starpilot/system/starport/bugsink_diagnosis.py
@@ -97,6 +97,24 @@ def attempt_records(events):
   return attempts
 
 
+STREAM_LOSS = {
+  "stalled": ("Video acknowledgement older than", "The car kept the link but stopped acknowledging video for too long, so the stream was ended.",
+              ["Compare the Wi-Fi signal, frame age and encoder recoveries around the stall.",
+               "If it repeats at the same place or speed, look for the comma stalling (CPU, thermal) rather than the car."]),
+  "silent": ("Head unit stopped answering", "The head unit stopped answering protocol messages while the link looked up.",
+             ["Check whether the car's screen turned off or switched source at that time.",
+              "Compare with other drives on the same head unit before changing timings."]),
+  "disconnected": ("Head unit disconnected", "The head unit closed the connection, which is what a car shutdown or a source change looks like.",
+                   ["Check whether the drive ended or the driver changed source on the head unit.",
+                    "Only investigate further if it happened while the car stayed on and Android Auto was showing."]),
+}
+
+
+def stream_loss_kind(error: str) -> str:
+  """Why a stream ended, from the logged error text: stalled, silent, disconnected or other."""
+  return next((kind for kind, (marker, _, _) in STREAM_LOSS.items() if marker.lower() in error.lower()), "other")
+
+
 def diagnosis(session):
   stage, error = session.get("failed_stage", ""), session.get("error", "").lower()
   category, confidence = "unknown", "unknown"
@@ -156,6 +174,8 @@ def diagnosis(session):
     explanation = "Projection was interrupted. EOF or a timeout alone cannot distinguish a car shutdown from link loss."
     actions = ["Compare video acknowledgments, Wi-Fi signal, stalls, encoder recoveries and head-unit shutdown events.",
                "Retry while parked and verify sustained acknowledged frames, not just a streaming status."]
+    if (loss := stream_loss_kind(session.get("error", ""))) != "other":
+      explanation, actions = STREAM_LOSS[loss][1], STREAM_LOSS[loss][2]
   return {"category": category, "confidence": confidence, "summary": explanation,
           "evidence": session.get("error", ""), "recovered": session.get("outcome") == "recovered",
           "next_steps": actions, "log_file": session.get("name", ""),
diff --git a/openpilot/starpilot/system/starport/bugsink_report.py b/openpilot/starpilot/system/starport/bugsink_report.py
index dd28f84267..dfc3aebbd8 100644
--- a/openpilot/starpilot/system/starport/bugsink_report.py
+++ b/openpilot/starpilot/system/starport/bugsink_report.py
@@ -14,7 +14,7 @@ from datetime import UTC, datetime, timedelta
 from pathlib import Path
 
 from openpilot.starpilot.system.starport import identity as identity_store, reachability, system_slice
-from openpilot.starpilot.system.starport.bugsink_diagnosis import attempt_records, diagnosis, elapsed, sanitize
+from openpilot.starpilot.system.starport.bugsink_diagnosis import attempt_records, diagnosis, elapsed, sanitize, stream_loss_kind
 from openpilot.starpilot.system.starport.bugsink_summary import batch_summary, failure_summary, pairing_summary, session_timeline, software_tags
 
 STATE_PATH = identity_store.DATA_DIR / "bugsink_report.json"
@@ -405,6 +405,7 @@ def failure_detail(session: dict) -> dict:
     "session": session["seq"],
     "attempt": session.get("failed_attempt"),
     "cause": assessment["category"], "stage": stage, "error_kind": kind, "reach": session.get("reach", ""),
+    "loss": stream_loss_kind(session.get("error", "")) if assessment["category"] == "projection_interrupted" else "",
     "summary": sanitize(failure_summary(assessment), names),
     "diagnosis": sanitize(assessment, names),
   }
@@ -499,7 +500,8 @@ def drive_event(sessions: list[dict]) -> dict:
              **({"aa.phone_address_sent": "yes" if sent else "no"} if sent is not None else {}),
              **({"aa.attention": ",".join(reasons)[:190]} if reasons else {}),
              **({"aa.cause": latest["cause"], "aa.stage": latest["stage"], "aa.error_kind": latest["error_kind"]} if latest else {}),
-             **({"aa.reach_class": latest["reach"]} if latest and latest.get("reach") else {})},
+             **({"aa.reach_class": latest["reach"]} if latest and latest.get("reach") else {}),
+             **({"aa.loss_kind": latest["loss"]} if latest and latest.get("loss") else {})},
     "breadcrumbs": {"values": attempt_breadcrumbs(sessions)},
     "contexts": {"starport_drive": summary, "starport_head_unit": head_unit,
                  **{f"starport_session_{index + 1}": _public(session) for index, session in enumerate(sessions)},
diff --git a/openpilot/starpilot/system/starport/network.py b/openpilot/starpilot/system/starport/network.py
index a28017390c..61858ec44a 100644
--- a/openpilot/starpilot/system/starport/network.py
+++ b/openpilot/starpilot/system/starport/network.py
@@ -40,6 +40,10 @@ NM_AP_IFACE = "org.freedesktop.NetworkManager.AccessPoint"
 DEVICE_TYPE_WIFI = 2
 DEVICE_STATE_DISCONNECTED = 30
 DEVICE_READY_TIMEOUT_S = 5.0
+# A shared interface can be briefly unmanaged (for example while the Wi-Fi mode is being switched). Bugsink showed 19 joins
+# refused with "device is strictly unmanaged"; waiting a few seconds turns a transient state into a normal join, and a
+# device that stays unmanaged is reported as such instead of as an opaque D-Bus error.
+UNMANAGED_WAIT_S = 8.0
 ACTIVE_STATE_ACTIVATED = 2
 ACTIVE_STATE_DEACTIVATED = 4
 # The car sends its Wi-Fi details ~4 s after ignition, but a Honda's access point took ~55 s from ignition to appear
@@ -253,6 +257,7 @@ class NetworkLease:
         self._prepare_device(cancelled)
       else:
         self.device_path = self._wifi_device()
+        self._wait_managed(cancelled)
         self._pause_autoconnect()
       active = self._get(self.device_path, NM_DEVICE_IFACE, "ActiveConnection")
       if active and active != "/" and not self.previous_connection and not self.dedicated:
@@ -316,6 +321,22 @@ class NetworkLease:
       raise DedicatedUnavailable(failure)
     time.sleep(0.25)
 
+  def _wait_managed(self, cancelled: Callable[[], bool], timeout: float = UNMANAGED_WAIT_S) -> None:
+    """Give NetworkManager a few seconds to manage the shared interface before joining on it."""
+    deadline = time.monotonic() + timeout
+    waited = False
+    while (state := self._get(self.device_path, NM_DEVICE_IFACE, "State")) < DEVICE_STATE_DISCONNECTED:
+      if cancelled():
+        raise NetworkError("cancelled")
+      if time.monotonic() >= deadline:
+        raise NetworkError(f"{self.interface} is unmanaged by NetworkManager (state {state}) after waiting {timeout:.0f} s")
+      if not waited:
+        waited = True
+        self.log("wifi_waiting_managed", interface=self.interface, state=state)
+      time.sleep(0.25)
+    if waited:
+      self.log("wifi_became_managed", interface=self.interface)
+
   def _prepare_device(self, cancelled: Callable[[], bool]) -> None:
     if self.device_ready:
       return
diff --git a/openpilot/starpilot/system/starport/tests/test_network_managed_wait.py b/openpilot/starpilot/system/starport/tests/test_network_managed_wait.py
new file mode 100644
index 0000000000..24bcfaddd4
--- /dev/null
+++ b/openpilot/starpilot/system/starport/tests/test_network_managed_wait.py
@@ -0,0 +1,45 @@
+"""A shared Wi-Fi interface that NetworkManager has not taken yet is waited for, then reported as unmanaged."""
+import pytest
+
+from openpilot.starpilot.system.starport import network
+from openpilot.starpilot.system.starport.network import NetworkError, NetworkLease
+
+
+class FakeLease(NetworkLease):
+  def __init__(self, states):
+    super().__init__(lambda *a, **k: self.events.append((a, k)), "wlan0")
+    self.states, self.events, self.device_path = list(states), [], "/dev/0"
+
+  def _get(self, path, interface, name):
+    assert name == "State"
+    return self.states.pop(0) if len(self.states) > 1 else self.states[0]
+
+
+@pytest.fixture(autouse=True)
+def no_sleep(monkeypatch):
+  monkeypatch.setattr(network.time, "sleep", lambda seconds: None)
+
+
+def test_a_device_that_becomes_managed_is_joined_normally():
+  lease = FakeLease([10, 10, 20, 30])  # unmanaged, unmanaged, unavailable, disconnected
+  lease._wait_managed(lambda: False)
+  assert [event[0][0] for event in lease.events] == ["wifi_waiting_managed", "wifi_became_managed"]
+
+
+def test_a_managed_device_does_not_wait_or_log():
+  lease = FakeLease([30])
+  lease._wait_managed(lambda: False)
+  assert lease.events == []
+
+
+def test_a_device_that_stays_unmanaged_says_so(monkeypatch):
+  ticks = iter(range(0, 1000, 3))
+  monkeypatch.setattr(network.time, "monotonic", lambda: next(ticks))
+  lease = FakeLease([10])
+  with pytest.raises(NetworkError, match="unmanaged by NetworkManager"):
+    lease._wait_managed(lambda: False, timeout=8.0)
+
+
+def test_cancelling_stops_the_wait():
+  with pytest.raises(NetworkError, match="cancelled"):
+    FakeLease([10])._wait_managed(lambda: True)
diff --git a/openpilot/starpilot/system/starport/tests/test_reachability.py b/openpilot/starpilot/system/starport/tests/test_reachability.py
index 5268acb628..effbc1ff84 100644
--- a/openpilot/starpilot/system/starport/tests/test_reachability.py
+++ b/openpilot/starpilot/system/starport/tests/test_reachability.py
@@ -52,3 +52,15 @@ def test_report_names_a_sleeping_car_instead_of_unknown(tmp_path):
   recorded = [(0, 0, "session_start", {}), (0, 9, "attempt_failed", {"stage": "rfcomm", "kind": "ConnectionRefusedError",
                                                                       "error": "refused", "reach": "not_ready"})]
   assert br.session_record(write_session(tmp_path, 2, recorded))["reach"] == "not_ready"
+
+
+def test_stream_losses_are_told_apart_by_what_the_log_says(tmp_path):
+  from openpilot.starpilot.system.starport.bugsink_diagnosis import stream_loss_kind
+  assert stream_loss_kind("projecting: Video acknowledgement older than 2.5 s") == "stalled"
+  assert stream_loss_kind("projecting: Head unit stopped answering for 6 s") == "silent"
+  assert stream_loss_kind("projecting: Head unit disconnected after 4/8 bytes") == "disconnected"
+  assert stream_loss_kind("something else") == "other"
+  for text, kind in (("Video acknowledgement older than 2.5 s", "stalled"), ("Head unit disconnected after 4/8 bytes", "disconnected")):
+    events = [(0, 0, "session_start", {}), (0, 1, "stage", {"state": "streaming"}), (0, 9, "attempt_failed", {"stage": "streaming", "kind": "EOFError", "error": text})]
+    event = br.drive_event([br.session_record(write_session(tmp_path, 3 if kind == "stalled" else 4, events))])
+    assert event["tags"]["aa.cause"] == "projection_interrupted" and event["tags"]["aa.loss_kind"] == kind

From d5f6d6ee72c8fe4e2b2b8a3f0a40f91736489197 Mon Sep 17 00:00:00 2001
From: dirwin31 <83434411+dirwin31@users.noreply.github.com>
Date: Sun, 1 Nov 2026 13:55:26 -0800
Subject: [PATCH 10/38] Only wait on a Wi-Fi interface NetworkManager reports
 as unmanaged or unavailable

The first version waited on any state below disconnected, which also caught
the unknown state and broke the lease tests. Wait on states 10 and 20 only.
---
 openpilot/starpilot/system/starport/network.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/openpilot/starpilot/system/starport/network.py b/openpilot/starpilot/system/starport/network.py
index 61858ec44a..1611016419 100644
--- a/openpilot/starpilot/system/starport/network.py
+++ b/openpilot/starpilot/system/starport/network.py
@@ -39,6 +39,7 @@ NM_WIRELESS_IFACE = "org.freedesktop.NetworkManager.Device.Wireless"
 NM_AP_IFACE = "org.freedesktop.NetworkManager.AccessPoint"
 DEVICE_TYPE_WIFI = 2
 DEVICE_STATE_DISCONNECTED = 30
+DEVICE_STATES_NOT_MANAGED = (10, 20)  # NM_DEVICE_STATE_UNMANAGED, NM_DEVICE_STATE_UNAVAILABLE
 DEVICE_READY_TIMEOUT_S = 5.0
 # A shared interface can be briefly unmanaged (for example while the Wi-Fi mode is being switched). Bugsink showed 19 joins
 # refused with "device is strictly unmanaged"; waiting a few seconds turns a transient state into a normal join, and a
@@ -325,7 +326,7 @@ class NetworkLease:
     """Give NetworkManager a few seconds to manage the shared interface before joining on it."""
     deadline = time.monotonic() + timeout
     waited = False
-    while (state := self._get(self.device_path, NM_DEVICE_IFACE, "State")) < DEVICE_STATE_DISCONNECTED:
+    while (state := self._get(self.device_path, NM_DEVICE_IFACE, "State")) in DEVICE_STATES_NOT_MANAGED:
       if cancelled():
         raise NetworkError("cancelled")
       if time.monotonic() >= deadline:

From 5dbcbb9618ec3edb3b9ab936f4d35703f582c068 Mon Sep 17 00:00:00 2001
From: dirwin31 <83434411+dirwin31@users.noreply.github.com>
Date: Sun, 1 Nov 2026 13:55:26 -0800
Subject: [PATCH 11/38] Choose the car automatically when exactly one paired
 device offers Android Auto

A car that is paired and offers wireless Android Auto but was never chosen
(the pairing window closed first, or it was paired in Bluetooth settings)
is adopted by housekeeping when it is the only candidate. This reads the
cached BlueZ service list, so it never pages a device, and it does not run
during a pairing window or session, for adapter setups, or once a car is
chosen. With several candidates nothing is guessed; they are listed in the
status as car_candidates for the setup screen to offer.
---
 .../starpilot/system/starport/supervisor.py   | 41 +++++++++++++++++++
 .../starport/tests/test_car_never_answered.py | 17 ++++++++
 2 files changed, 58 insertions(+)

diff --git a/openpilot/starpilot/system/starport/supervisor.py b/openpilot/starpilot/system/starport/supervisor.py
index 007f50a51a..74d286563f 100644
--- a/openpilot/starpilot/system/starport/supervisor.py
+++ b/openpilot/starpilot/system/starport/supervisor.py
@@ -177,6 +177,17 @@ def car_never_answered(error: BaseException) -> bool:
   return not (isinstance(error, OSError) and error.errno in LOCAL_SOCKET_ERRORS)
 
 
+ADOPT_INTERVAL = 20.0         # how often housekeeping looks for a paired car that was never chosen
+
+
+def choose_only_car(devices: list[dict]) -> tuple[dict | None, list[dict]]:
+  """(the car to adopt, every candidate). A car is adopted only when exactly one paired device offers Android Auto Wireless.
+
+  Reads the cached BlueZ service list, so it never pages a device. Two candidates are never guessed between."""
+  candidates = [device for device in devices if device.get("paired") and device.get("starport")]
+  return (candidates[0] if len(candidates) == 1 else None), candidates
+
+
 def drops_cached_channel(stage: str, error: BaseException) -> bool:
   """Forget the cached RFCOMM channel only when the car answered nothing there for a reason about the channel.
 
@@ -406,6 +417,7 @@ class Supervisor:
     status["auto_connect"] = bool(self.config["auto_connect"])
     status["dedicated_wifi_interface"] = bool(self.config["dedicated_wifi_interface"])
     status["allow_hevc"] = bool(self.config["allow_hevc"])
+    status["car_candidates"] = list(getattr(self, "_candidates", []))[:8]  # paired Android Auto devices to choose between
     status["auto_paused"] = self.auto.suppressed
     status["recent"] = list(self.log.recent)[-8:]
     return status
@@ -749,8 +761,37 @@ class Supervisor:
         self._end_pairing("expired")
         if not self._session_alive():
           self._release_phone()
+    self._adopt_only_car(now)
     self._auto_connect(now)
 
+  def _adopt_only_car(self, now: float) -> None:
+    """A car that is paired and offers Android Auto but was never chosen (the pairing window closed first, or it was
+    paired in Bluetooth settings) becomes the chosen car when it is the only one. Never during a pairing window or session."""
+    config = self.config
+    if (config["receiver_address"] or config["connection"] != "wireless" or self.car_type() == "adapter"
+        or self._pairing_active() or self._session_alive() or now - getattr(self, "_adopt_at", -ADOPT_INTERVAL) < ADOPT_INTERVAL):
+      if config["receiver_address"]:
+        self._candidates = []
+      return
+    self._adopt_at = now
+    try:
+      car, candidates = choose_only_car(self._phone().devices())
+    except Exception as error:
+      self.log("car_adopt_unavailable", kind=type(error).__name__, error=str(error)[:120])
+      return
+    self._candidates = [{"address": device["address"], "name": device.get("name") or device["address"]} for device in candidates]
+    if car is None:
+      if len(candidates) > 1:
+        self.log("car_adopt_ambiguous", count=len(candidates))
+      return
+    try:
+      self.select_receiver(car["address"], car.get("name") or "")
+    except (RuntimeError, ValueError) as error:
+      self.log("car_adopt_failed", error=str(error))
+      return
+    self._candidates = []
+    self.log("car_adopted", car=car.get("name") or "", reason="only paired Android Auto device")
+
   def _auto_connect(self, now: float) -> None:
     config = self.config
     if self._pairing_active():
diff --git a/openpilot/starpilot/system/starport/tests/test_car_never_answered.py b/openpilot/starpilot/system/starport/tests/test_car_never_answered.py
index 8263ab1e35..26970b2f2c 100644
--- a/openpilot/starpilot/system/starport/tests/test_car_never_answered.py
+++ b/openpilot/starpilot/system/starport/tests/test_car_never_answered.py
@@ -31,3 +31,20 @@ class TestDropsCachedChannel(unittest.TestCase):
     self.assertFalse(drops_cached_channel('authenticating', ConnectionResetError(errno.ECONNRESET, 'reset')))
     self.assertFalse(drops_cached_channel('rfcomm', OSError(errno.ENOSYS, 'local')))
     self.assertFalse(drops_cached_channel('rfcomm', OSError(errno.EBUSY, 'Device or resource busy')))
+
+
+class TestChooseOnlyCar(unittest.TestCase):
+  def car(self, address, paired=True, starport=True):
+    return {"address": address, "name": f"car {address}", "paired": paired, "starport": starport}
+
+  def test_exactly_one_paired_android_auto_device_is_adopted(self):
+    from openpilot.starpilot.system.starport.supervisor import choose_only_car
+    only, candidates = choose_only_car([self.car("A"), self.car("B", starport=False), self.car("C", paired=False)])
+    self.assertEqual((only["address"], [c["address"] for c in candidates]), ("A", ["A"]))
+
+  def test_two_candidates_or_none_are_never_guessed(self):
+    from openpilot.starpilot.system.starport.supervisor import choose_only_car
+    self.assertEqual(choose_only_car([self.car("A"), self.car("B")])[0], None)
+    self.assertEqual([c["address"] for c in choose_only_car([self.car("A"), self.car("B")])[1]], ["A", "B"])
+    self.assertEqual(choose_only_car([self.car("A", starport=False)]), (None, []))
+    self.assertEqual(choose_only_car([]), (None, []))

From 2af7bdd1dd91a693fdac05812436e82a5c80fb60 Mon Sep 17 00:00:00 2001
From: dirwin31 <83434411+dirwin31@users.noreply.github.com>
Date: Sun, 1 Nov 2026 14:05:38 -0800
Subject: [PATCH 12/38] Add opt-in H.265 for a head unit that offers no H.264
 mode

Allow H.265 video (Developer > StarPort, off by default) lets a car that
offers only H.265 get H.265. A car with an H.264 mode is chosen exactly as
before whatever the setting; this is replay-tested over several offers.

The hardware encoder library is ABI 4: an HEVC option selects H.265 Main
profile at high-tier level 5 and allows up to 1920x1080 (H.264 stays at
1280x720). The Python side keeps H.265 apart from the H.264 code: its own
codec-config and wire-frame functions for the two-byte NAL header, its own
access unit check, and an encoder subclass. If the car is told H.265 and the
hardware encoder cannot open, the session fails with the reason; there is no
fallback to another codec.

Measured on a parked comma with a scratch copy of the library: H.265 1080p
costs about 13 ms per frame on the NV12 path (30 ms from RGBA), mid-stream
keyframes carry VPS/SPS/PPS, and the H.264 session is unchanged. The
encoder splits every H.265 picture into two slices, which the check allows.
---
 .../system/starport/bugsink_report.py         |   1 +
 .../system/starport/hw/libstarport_encoder.so | Bin 244696 -> 247280 bytes
 .../system/starport/hw/starport_encoder.cc    |  37 ++++--
 .../starpilot/system/starport/hw_encoder.py   |  96 +++++++++++++--
 .../starpilot/system/starport/session.py      |  64 ++++++++--
 .../starpilot/system/starport/supervisor.py   |  21 ++--
 .../system/starport/tests/test_hevc.py        | 113 ++++++++++++++++++
 7 files changed, 294 insertions(+), 38 deletions(-)
 create mode 100644 openpilot/starpilot/system/starport/tests/test_hevc.py

diff --git a/openpilot/starpilot/system/starport/bugsink_report.py b/openpilot/starpilot/system/starport/bugsink_report.py
index dfc3aebbd8..c739af77e6 100644
--- a/openpilot/starpilot/system/starport/bugsink_report.py
+++ b/openpilot/starpilot/system/starport/bugsink_report.py
@@ -103,6 +103,7 @@ def video_summary(events: list[dict]) -> dict:
     "screen": f"{mode['width'] - (mode.get('margin_width') or 0)}x{mode['height'] - (mode.get('margin_height') or 0)}"
               if mode.get("width") and mode.get("height") else None,
     "density_dpi": mode.get("density") or None,
+    "codec": mode.get("codec"),  # present only for H.265; H.264 reports are unchanged
     "target_fps": pipeline.get("target_fps"),
     "encoder": pipeline.get("encoder"),
     "nv12": pipeline.get("nv12"),
diff --git a/openpilot/starpilot/system/starport/hw/libstarport_encoder.so b/openpilot/starpilot/system/starport/hw/libstarport_encoder.so
index 1b8e37108cd075b75f70a40d443f2e49b49cfe13..791e7ae260cccb410c180906cc90a37fac2572d6 100755
GIT binary patch
literal 247280
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
BX{P`H

literal 244696
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

diff --git a/openpilot/starpilot/system/starport/hw/starport_encoder.cc b/openpilot/starpilot/system/starport/hw/starport_encoder.cc
index 2001e43a0c..e28c322f66 100644
--- a/openpilot/starpilot/system/starport/hw/starport_encoder.cc
+++ b/openpilot/starpilot/system/starport/hw/starport_encoder.cc
@@ -3,11 +3,12 @@
 // Altering them can degrade video smoothness or introduce lag on Android Auto.
 // Do not change them autonomously; require an explicit user request specifically
 // for these video optimizations.
-// Isolated Qualcomm H.264 session for Android Auto projection. No cereal publisher,
+// Isolated Qualcomm H.264 (or, with AA_ENCODER_HEVC, H.265) session for Android Auto projection. No cereal publisher,
 // camera buffers, realtime priority, or background thread. Exactly one input in flight.
 // Input is RGBA (converted here with NEON) or NV12 already converted on the GPU by the
 // car renderer (copied into the encoder's padded layout). ABI 3 adds the NV12 entry
-// point and create() options (AA_ENCODER_CBR).
+// point and create() options (AA_ENCODER_CBR). ABI 4 adds AA_ENCODER_HEVC for a head unit that offers only H.265;
+// the H.264 path is untouched. HEVC controls follow system/loggerd/encoder/v4l_encoder.cc.
 // Buffer/ioctl conventions follow system/loggerd/encoder/v4l_encoder.cc and
 // msgq/visionipc/visionbuf_ion.cc. Built for comma_arm64 by this directory's SConscript.
 //
@@ -38,6 +39,7 @@ namespace {
 using Clock = std::chrono::steady_clock;
 constexpr unsigned CODECCONFIG = 0x00020000;
 constexpr int AA_ENCODER_CBR = 1;  // hold the configured bitrate instead of letting it float with scene complexity
+constexpr int AA_ENCODER_HEVC = 2; // encode H.265 (Main profile) instead of H.264 baseline
 constexpr size_t MAX_PACKET = 2 * 1024 * 1024 - 10;
 
 void check(bool ok, const char *what) {
@@ -142,8 +144,9 @@ struct Encoder {
         strcmp(reinterpret_cast<char *>(cap.card), "msm_vidc_venc")) throw std::runtime_error("Unsupported encoder driver");
     v4l2_format out = {}; out.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
     out.fmt.pix_mp.width = width; out.fmt.pix_mp.height = height;
-    out.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_H264;
-    call(fd, VIDIOC_S_FMT, &out, "H264 format");
+    const bool hevc = options & AA_ENCODER_HEVC;
+    out.fmt.pix_mp.pixelformat = hevc ? V4L2_PIX_FMT_HEVC : V4L2_PIX_FMT_H264;
+    call(fd, VIDIOC_S_FMT, &out, hevc ? "HEVC format" : "H264 format");
     v4l2_streamparm parm = {}; parm.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
     parm.parm.output.timeperframe.numerator = 1; parm.parm.output.timeperframe.denominator = fps;
     call(fd, VIDIOC_S_PARM, &parm, "frame rate");
@@ -167,10 +170,15 @@ struct Encoder {
                                                                          : V4L2_CID_MPEG_VIDC_VIDEO_RATE_CONTROL_VBR_CFR);
     control(V4L2_CID_MPEG_VIDC_VIDEO_PRIORITY, V4L2_MPEG_VIDC_VIDEO_PRIORITY_REALTIME_DISABLE);
     control(V4L2_CID_MPEG_VIDC_VIDEO_IDR_PERIOD, 1);
-    control(V4L2_CID_MPEG_VIDEO_H264_PROFILE, V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE);
-    control(V4L2_CID_MPEG_VIDEO_H264_LEVEL, V4L2_MPEG_VIDEO_H264_LEVEL_3_1);
-    control(V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE, V4L2_MPEG_VIDEO_H264_ENTROPY_MODE_CAVLC);
-    control(V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE, V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_ENABLED);
+    if (hevc) {
+      control(V4L2_CID_MPEG_VIDC_VIDEO_HEVC_PROFILE, V4L2_MPEG_VIDC_VIDEO_HEVC_PROFILE_MAIN);
+      control(V4L2_CID_MPEG_VIDC_VIDEO_HEVC_TIER_LEVEL, V4L2_MPEG_VIDC_VIDEO_HEVC_LEVEL_HIGH_TIER_LEVEL_5);
+    } else {
+      control(V4L2_CID_MPEG_VIDEO_H264_PROFILE, V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE);
+      control(V4L2_CID_MPEG_VIDEO_H264_LEVEL, V4L2_MPEG_VIDEO_H264_LEVEL_3_1);
+      control(V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE, V4L2_MPEG_VIDEO_H264_ENTROPY_MODE_CAVLC);
+      control(V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE, V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_ENABLED);
+    }
     control(V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE, 0);
     unsigned count = buffers(V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE, 6);
     buffers(V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE, 9);
@@ -257,7 +265,7 @@ struct Encoder {
           auto &buffer = *outputs[b.index]; buffer.sync(true);
           auto *bytes = static_cast<unsigned char *>(buffer.addr);
           if (b.flags & CODECCONFIG) {
-            if (plane.bytesused > 65536) throw std::runtime_error("Oversized H264 header");
+            if (plane.bytesused > 65536) throw std::runtime_error("Oversized codec header");
             header.assign(bytes, bytes + plane.bytesused);
           } else {
             if (b.timestamp.tv_sec * 1000000LL + b.timestamp.tv_usec != timestamp || frame_done)
@@ -281,15 +289,20 @@ struct Encoder {
 }
 
 extern "C" {
-int starport_encoder_abi() { return 3; }
+int starport_encoder_abi() { return 4; }
 void starport_encoder_timing(void *ptr, double *output) {
   if (ptr && output) std::copy_n(static_cast<Encoder *>(ptr)->timing, 3, output);
 }
 void *starport_encoder_create(int width, int height, int fps, int bitrate, int margin_height, int options, char *error, size_t size) {
   try {
-    if (width < 2 || width > 1280 || height < 2 || height > 720 || width % 2 || height % 2 ||
+    // H.264 baseline level 3.1 is a 720p30 session; HEVC Main at high-tier level 5 carries 1080p30 for a head unit
+    // that offers nothing else.
+    const bool hevc = options & AA_ENCODER_HEVC;
+    const int max_width = hevc ? 1920 : 1280, max_height = hevc ? 1080 : 720;
+    if (width < 2 || width > max_width || height < 2 || height > max_height || width % 2 || height % 2 ||
         fps != 30 || bitrate < 1000000 || bitrate > 20000000 || margin_height < 0 ||
-        margin_height >= height || margin_height % 4 || (options & ~AA_ENCODER_CBR)) throw std::runtime_error("Unsupported encoder configuration");
+        margin_height >= height || margin_height % 4 || (options & ~(AA_ENCODER_CBR | AA_ENCODER_HEVC)))
+      throw std::runtime_error("Unsupported encoder configuration");
     auto encoder = std::make_unique<Encoder>(width, height, fps, margin_height, options);
     encoder->init(bitrate); return encoder.release();
   } catch (const std::exception &e) { error_text(error, size, e); return nullptr; }
diff --git a/openpilot/starpilot/system/starport/hw_encoder.py b/openpilot/starpilot/system/starport/hw_encoder.py
index ad79cc4b3c..279fd56d1d 100644
--- a/openpilot/starpilot/system/starport/hw_encoder.py
+++ b/openpilot/starpilot/system/starport/hw_encoder.py
@@ -23,11 +23,14 @@ from pathlib import Path
 from openpilot.starpilot.system.starport.encoder import MAX_ACCESS_UNIT, START_CODE, H264Encoder, nal_types
 
 LIBRARY = Path(__file__).with_name("hw") / "libstarport_encoder.so"
-ABI = 3
-SUPPORTED_ABIS = (2, 3)
+ABI = 4
+SUPPORTED_ABIS = (2, 3, 4)
 OPTION_CBR = 1
+OPTION_HEVC = 2          # ABI 4: H.265 Main profile instead of H.264 baseline
 MAX_WIDTH, MAX_HEIGHT, HW_FPS = 1280, 720, 30
+HEVC_MAX_WIDTH, HEVC_MAX_HEIGHT = 1920, 1080
 AUD = b"\x00\x00\x00\x01\x09\xf0"
+HEVC_AUD = b"\x00\x00\x00\x01\x46\x01\x50"
 
 
 def normalize_access_unit(data: bytes, *, keyframe: bool) -> bytes:
@@ -52,16 +55,51 @@ def normalize_access_unit(data: bytes, *, keyframe: bool) -> bytes:
   return result
 
 
+def hevc_nal_kinds(data: bytes) -> list[int]:
+  return [(data[match.end()] >> 1) & 0x3F for match in START_CODE.finditer(data) if match.end() < len(data)]
+
+
+def normalize_access_unit_hevc(data: bytes, *, keyframe: bool) -> bytes:
+  """H.265 counterpart of normalize_access_unit: exactly one leading AUD, one picture, VPS/SPS/PPS on keyframes.
+
+  A picture NAL is a VCL unit (types 0-9 and 16-21); an IDR is type 19 or 20. The comma's encoder splits every H.265
+  picture into two slices (measured on the device: [19, 19] and [1, 1]), so one or more VCL units make a picture.
+  Separate from the H.264 function so that path is unchanged."""
+  if not data.startswith((b"\x00\x00\x01", b"\x00\x00\x00\x01")) or len(data) > MAX_ACCESS_UNIT:
+    raise RuntimeError("Expected a bounded Annex B hardware frame")
+  starts = list(START_CODE.finditer(data))
+  units = []
+  for index, match in enumerate(starts):
+    end = starts[index + 1].start() if index + 1 < len(starts) else len(data)
+    if match.end() + 1 >= end:
+      raise RuntimeError("Empty hardware NAL unit")
+    units.append(((data[match.end()] >> 1) & 0x3F, data[match.start():end]))
+  kinds = [kind for kind, _ in units]
+  pictures = [kind for kind in kinds if kind <= 9 or 16 <= kind <= 21]
+  if not pictures or len({kind in (19, 20) for kind in pictures}) != 1:  # slices of one picture are all IDR or none are
+    raise RuntimeError("Hardware encoder did not produce one picture")
+  if keyframe and not ({19, 20} & set(kinds) and {32, 33, 34}.issubset(kinds)):
+    raise RuntimeError("Hardware encoder did not produce an independently decodable keyframe")
+  result = HEVC_AUD + b"".join(unit for kind, unit in units if kind != 35)
+  if len(result) > MAX_ACCESS_UNIT:
+    raise RuntimeError("Hardware access unit too large")
+  return result
+
+
 # ANDROID AUTO VIDEO PERFORMANCE GUARDRAIL: Hardware encoding and bounded frame submission avoid CPU stalls and encoder backlog.
 # Altering this can degrade video smoothness or introduce lag on Android Auto.
 # Do not change it autonomously; require an explicit user request specifically for this video optimization.
 class HardwareH264Encoder:
   backend = "qcom-v4l2"
+  codec = "h264"
+  max_width, max_height = MAX_WIDTH, MAX_HEIGHT   # level 3.1 baseline is a 720p30 session
+  codec_options = 0
+  required_abi = 2
 
   def __init__(self, width: int, height: int, fps: int = HW_FPS, bitrate_kbps: int = 6000, margin_height: int = 0,
                library: Path = LIBRARY, rate_control: str = "cbr"):
-    if not (0 < width <= MAX_WIDTH and 0 < height <= MAX_HEIGHT) or width % 2 or height % 2 or fps != HW_FPS:
-      raise ValueError("Hardware encoder supports even sizes up to 1280x720 at 30 fps")
+    if not (0 < width <= self.max_width and 0 < height <= self.max_height) or width % 2 or height % 2 or fps != HW_FPS:
+      raise ValueError(f"Hardware encoder supports even sizes up to {self.max_width}x{self.max_height} at 30 fps")
     if margin_height % 4:
       margin_height = 0  # only chroma-aligned black margins may be skipped
     self.width, self.height, self.fps = width, height, fps
@@ -71,7 +109,7 @@ class HardwareH264Encoder:
     self.lib = ctypes.CDLL(str(library))
     self.lib.starport_encoder_abi.restype = ctypes.c_int
     self.abi = self.lib.starport_encoder_abi()
-    if self.abi not in SUPPORTED_ABIS:
+    if self.abi not in SUPPORTED_ABIS or self.abi < self.required_abi:
       raise RuntimeError("libstarport_encoder.so ABI mismatch; rebuild")
     pointer = ctypes.c_void_p
     encode_args = [pointer, pointer, ctypes.c_size_t, ctypes.c_int, pointer, ctypes.c_size_t, pointer, ctypes.c_size_t]
@@ -88,7 +126,7 @@ class HardwareH264Encoder:
     self.lib.starport_encoder_destroy.restype = None
     self.error = ctypes.create_string_buffer(512)
     self.output = ctypes.create_string_buffer(MAX_ACCESS_UNIT)
-    options = (OPTION_CBR if self.rate_control == "cbr" else 0,) if self.abi >= 3 else ()
+    options = ((OPTION_CBR if self.rate_control == "cbr" else 0) | self.codec_options,) if self.abi >= 3 else ()
     self._create_args = (width, height, fps, int(bitrate_kbps) * 1000, margin_height, *options)
     self._open()
 
@@ -127,10 +165,16 @@ class HardwareH264Encoder:
     if size > len(self.output):
       raise RuntimeError("Hardware access unit too large")
     # .raw copies the entire 2 MiB capacity, even for a small inter frame.
-    data = normalize_access_unit(ctypes.string_at(self.output, size), keyframe=force)
+    data = self.normalize(ctypes.string_at(self.output, size), keyframe=force)
     self.frame_index += 1
     self.last_encode_ms = (time.monotonic() - started) * 1000
-    return data, {5, 7, 8}.issubset(nal_types(data))
+    return data, self.is_keyframe(data)
+
+  def normalize(self, data: bytes, *, keyframe: bool) -> bytes:
+    return normalize_access_unit(data, keyframe=keyframe)
+
+  def is_keyframe(self, data: bytes) -> bool:
+    return {5, 7, 8}.issubset(nal_types(data))
 
   def close(self) -> None:
     handle, self.handle = self.handle, None
@@ -138,6 +182,42 @@ class HardwareH264Encoder:
       self.lib.starport_encoder_destroy(handle)
 
 
+class HardwareHevcEncoder(HardwareH264Encoder):
+  """H.265 for a head unit that offers nothing else (Allow H.265 video). Hardware only: there is no software fallback."""
+  backend = "qcom-v4l2-hevc"
+  codec = "h265"
+  max_width, max_height = HEVC_MAX_WIDTH, HEVC_MAX_HEIGHT
+  codec_options = OPTION_HEVC
+  required_abi = 4
+
+  def normalize(self, data: bytes, *, keyframe: bool) -> bytes:
+    return normalize_access_unit_hevc(data, keyframe=keyframe)
+
+  def is_keyframe(self, data: bytes) -> bool:
+    kinds = set(hevc_nal_kinds(data))
+    return bool({19, 20} & kinds) and {32, 33, 34}.issubset(kinds)
+
+
+def create_hevc_encoder(width: int, height: int, *, bitrate_kbps: int, margin_height: int, log,
+                        rate_control: str = "cbr") -> tuple[object, int]:
+  """Return ``(encoder, fps)`` for an H.265 session. The car was told H.265, so a stand-in codec would send it a stream it
+  cannot decode: if the hardware encoder cannot open, the session fails with the reason."""
+  encoder = None
+  try:
+    if not LIBRARY.is_file():
+      raise RuntimeError(f"{LIBRARY.name} not built")
+    encoder = HardwareHevcEncoder(width, height, bitrate_kbps=max(bitrate_kbps, 4000), margin_height=margin_height,
+                                  rate_control=rate_control)
+    encoder.encode_rgba(bytes(width * height * 4), keyframe=True)  # exercise the driver and the keyframe contract
+  except Exception as error:
+    if encoder is not None:
+      encoder.close()
+    raise RuntimeError(f"The car needs H.265 and the hardware encoder could not start it: {error}") from error
+  log("encoder", backend=encoder.backend, codec=encoder.codec, fps=HW_FPS, abi=encoder.abi, rate_control=encoder.rate_control,
+      nv12=encoder.supports_nv12)
+  return encoder, HW_FPS
+
+
 # ANDROID AUTO VIDEO PERFORMANCE GUARDRAIL: Backend selection and frame-rate budgets are part of the low-latency video pipeline.
 # Altering this can degrade video smoothness or introduce lag on Android Auto.
 # Do not change it autonomously; require an explicit user request specifically for this video optimization.
diff --git a/openpilot/starpilot/system/starport/session.py b/openpilot/starpilot/system/starport/session.py
index c1002d2e49..9042b765cb 100644
--- a/openpilot/starpilot/system/starport/session.py
+++ b/openpilot/starpilot/system/starport/session.py
@@ -80,6 +80,7 @@ BLUETOOTH_AUTH_DATA = 0x8003
 SENSOR_NIGHT, SENSOR_DRIVING_STATUS = 10, 13
 
 CODEC_H264_BP = 3
+CODEC_H265 = 7          # MediaCodecType VIDEO_H265, offered by some head units instead of H.264
 SETUP_STATUS_READY = 2
 FOCUS_PROJECTED = 1
 FOCUS_NATIVE = 2
@@ -141,6 +142,39 @@ def wire_frame(access_unit: bytes, *, drop_config: bool) -> bytes:
   return b"".join(units) or access_unit
 
 
+# H.265 handling is kept apart from the H.264 functions above so the H.264 path stays byte-for-byte what it was.
+# A NAL header is two bytes; the type is bits 1-6 of the first (ITU-T H.265 7.3.1.2).
+HEVC_PARAMETER_SETS = (32, 33, 34)   # VPS, SPS, PPS
+HEVC_AUD = 35
+
+
+def hevc_nal_type(first_byte: int) -> int:
+  return (first_byte >> 1) & 0x3F
+
+
+def codec_config_hevc(access_unit: bytes) -> bytes:
+  """The VPS, SPS and PPS NAL units of an H.265 keyframe, as the codec-config buffer carries them."""
+  starts = list(START_CODE.finditer(access_unit))
+  units = []
+  for index, match in enumerate(starts):
+    end = starts[index + 1].start() if index + 1 < len(starts) else len(access_unit)
+    if match.end() < end and hevc_nal_type(access_unit[match.end()]) in HEVC_PARAMETER_SETS:
+      units.append(b"\x00\x00\x00\x01" + access_unit[match.end():end])
+  return b"".join(units)
+
+
+def wire_frame_hevc(access_unit: bytes, *, drop_config: bool) -> bytes:
+  """The H.265 picture NAL units without the access unit delimiter, and without parameter sets once they went separately."""
+  starts = list(START_CODE.finditer(access_unit))
+  drop = {HEVC_AUD, *HEVC_PARAMETER_SETS} if drop_config else {HEVC_AUD}
+  units = []
+  for index, match in enumerate(starts):
+    end = starts[index + 1].start() if index + 1 < len(starts) else len(access_unit)
+    if match.end() < end and hevc_nal_type(access_unit[match.end()]) not in drop:
+      units.append(b"\x00\x00\x00\x01" + access_unit[match.end():end])
+  return b"".join(units) or access_unit
+
+
 @dataclass(frozen=True)
 class VideoMode:
   channel: int
@@ -153,6 +187,7 @@ class VideoMode:
   content_left: int | None = None
   content_top: int | None = None
   density: int = 0  # dpi the head unit reports; 0 when it does not say
+  codec: int = CODEC_H264_BP
 
   @property
   def content_width(self) -> int:
@@ -166,6 +201,7 @@ class VideoMode:
     return {"channel": self.channel, "config_index": self.config_index, "width": self.width, "height": self.height,
             "fps": self.fps, "margin_width": self.margin_width, "margin_height": self.margin_height,
             "density": self.density,
+            **({"codec": CODEC_NAMES[self.codec]} if self.codec != CODEC_H264_BP else {}),
             **({"content_left": self.content_left, "content_top": self.content_top} if self.content_left is not None else {})}
 
 
@@ -188,14 +224,18 @@ def describe_video_configs(channels: list[dict]) -> str:
   return ", ".join(offered) or "no video"
 
 
-def choose_video_mode(channels: list[dict]) -> VideoMode:
-  """Pick a negotiated H.264 mode the software encoder can sustain."""
+def choose_video_mode(channels: list[dict], allow_hevc: bool = False) -> VideoMode:
+  """Pick a negotiated H.264 mode the software encoder can sustain.
+
+  H.265 is considered only when the owner allows it and the car offered no usable H.264 mode, so a car that works on
+  H.264 is never changed."""
   candidates = []
+  hevc_candidates = []
   for channel in channels:
     for index, config in enumerate(channel.get("video_configs", [])):
       resolution = one(config, 1)
       codec = one(config, 10, CODEC_H264_BP)
-      if resolution not in RESOLUTIONS or codec != CODEC_H264_BP:
+      if resolution not in RESOLUTIONS or codec not in (CODEC_H264_BP, CODEC_H265):
         continue
       width, height = RESOLUTIONS[resolution]
       margin_width, margin_height = int(one(config, 3, 0) or 0), int(one(config, 4, 0) or 0)
@@ -215,10 +255,13 @@ def choose_video_mode(channels: list[dict]) -> VideoMode:
               top_edge + bottom == margin_height and left_edge + right == margin_width):
             left, top = left_edge, top_edge
       mode = VideoMode(int(channel["id"]), index, width, height, fps, margin_width, margin_height, left, top,
-                       int(one(config, 5, 0) or 0))
-      candidates.append((RESOLUTION_PREFERENCE.index(resolution), fps != 30, index, mode))
+                       int(one(config, 5, 0) or 0), codec)
+      (candidates if codec == CODEC_H264_BP else hevc_candidates).append((RESOLUTION_PREFERENCE.index(resolution), fps != 30, index, mode))
+  if not candidates and allow_hevc:
+    candidates = hevc_candidates
   if not candidates:
-    raise ValueError(f"Head unit did not advertise a supported H.264 video mode (offered {describe_video_configs(channels)})")
+    hint = "; this car offers H.265, which can be turned on in Developer > StarPort" if hevc_candidates else ""
+    raise ValueError(f"Head unit did not advertise a supported H.264 video mode (offered {describe_video_configs(channels)}){hint}")
   return min(candidates, key=lambda item: item[:3])[3]
 
 
@@ -631,6 +674,7 @@ class ProjectionSession(Session):
     self.video_confirmed = False
     self.input_channel: int | None = None
     self.max_window = self.MAX_WINDOW  # raised by the supervisor for adapters that need the car's full window
+    self.allow_hevc = False  # the owner's Allow H.265 video setting; used only when the car offers no H.264 mode
     self.phone_services = False  # open the car-data and Bluetooth channels like a phone (adapter profile)
     self.phone_frames = False  # send picture NAL units only (adapter profile)
     self.phone_address = ""  # this comma's Bluetooth address, for the pairing request
@@ -652,7 +696,7 @@ class ProjectionSession(Session):
 
   def start(self, device_name: str, device_brand: str) -> VideoMode:
     self.channels = self.discover(device_name, device_brand)
-    self.mode = choose_video_mode(self.channels)
+    self.mode = choose_video_mode(self.channels, self.allow_hevc)
     self.open_video()
     self.open_input()
     if self.phone_services:
@@ -667,7 +711,7 @@ class ProjectionSession(Session):
     opened = parse_fields(self.wait_for(mode.channel, MSG_CHANNEL_OPEN_RESPONSE))
     if signed(one(opened, 1)) != 0:
       raise ValueError(f"Head unit rejected opening the video channel: {json_fields(opened)}")
-    self.send(mode.channel, AV_SETUP_REQUEST, field(1, CODEC_H264_BP))
+    self.send(mode.channel, AV_SETUP_REQUEST, field(1, mode.codec))
     setup = parse_fields(self.wait_for(mode.channel, AV_SETUP_RESPONSE))
     window = int(one(setup, 2, 0) or 0)
     if one(setup, 1) != SETUP_STATUS_READY or window < 1:  # the window is capped to MAX_WINDOW below; MIB3 offers 100
@@ -944,13 +988,13 @@ class ProjectionSession(Session):
     fragments = 0
     config = b""
     if self.needs_keyframe:
-      config = codec_config(data)
+      config = codec_config_hevc(data) if self.mode.codec == CODEC_H265 else codec_config(data)
       if config:
         fragments += self.send(self.mode.channel, AV_MEDIA_CODEC_CONFIG, config)
         if not self.fragment_acks:
           self.config_ack_slack += 1
     if self.phone_frames:
-      data = wire_frame(data, drop_config=bool(config))
+      data = (wire_frame_hevc if self.mode.codec == CODEC_H265 else wire_frame)(data, drop_config=bool(config))
     fragments += self.send(self.mode.channel, AV_MEDIA_WITH_TIMESTAMP, struct.pack(">Q", timestamp_us) + data)
     if self.fragment_acks:
       self.frame_fragments.append(fragments)
diff --git a/openpilot/starpilot/system/starport/supervisor.py b/openpilot/starpilot/system/starport/supervisor.py
index 74d286563f..6e7d94c581 100644
--- a/openpilot/starpilot/system/starport/supervisor.py
+++ b/openpilot/starpilot/system/starport/supervisor.py
@@ -42,7 +42,7 @@ from openpilot.starpilot.system.starport.frame_source import (DEFAULT_PATH as DE
 from openpilot.starpilot.system.starport.projection_control import DEFAULT_CONTROL_SOCKET, NATIVE_FOCUS
 from openpilot.starpilot.system.starport.touch import DEFAULT_TOUCH_SOCKET
 from openpilot.starpilot.system.starport.view import CAR_FRAME_PATH, ViewSource, renderer_available
-from openpilot.starpilot.system.starport.session import AuthenticationRejected, PeerRequestedStop, ProjectionSession
+from openpilot.starpilot.system.starport.session import CODEC_H265, AuthenticationRejected, PeerRequestedStop, ProjectionSession
 
 BACKOFF_SECONDS = (2.0, 4.0, 8.0, 15.0, 30.0)
 STABLE_SESSION_SECONDS = 30.0
@@ -769,7 +769,7 @@ class Supervisor:
     paired in Bluetooth settings) becomes the chosen car when it is the only one. Never during a pairing window or session."""
     config = self.config
     if (config["receiver_address"] or config["connection"] != "wireless" or self.car_type() == "adapter"
-        or self._pairing_active() or self._session_alive() or now - getattr(self, "_adopt_at", -ADOPT_INTERVAL) < ADOPT_INTERVAL):
+        or not self._projection_enabled() or self._pairing_active() or self._session_alive() or now - getattr(self, "_adopt_at", -ADOPT_INTERVAL) < ADOPT_INTERVAL):
       if config["receiver_address"]:
         self._candidates = []
       return
@@ -1568,6 +1568,7 @@ class Supervisor:
     tuning = car_profiles.tuning(config)
     session.max_window = tuning["max_window"]
     session.phone_frames = tuning["phone_frames"]
+    session.allow_hevc = bool(config["allow_hevc"])
     if tuning["phone_services"]:
       session.phone_services = True
       session.phone_address = self._adapter_address()
@@ -1583,16 +1584,20 @@ class Supervisor:
     except (OSError, ValueError, TypeError, KeyError) as error:
       self.log("screen_profile_error", error=str(error))
 
-    from openpilot.starpilot.system.starport.hw_encoder import create_encoder
+    from openpilot.starpilot.system.starport.hw_encoder import create_encoder, create_hevc_encoder
     # ANDROID AUTO VIDEO PERFORMANCE GUARDRAIL: Encoder cadence and pipeline flags are tuned together for Android Auto video.
     # Altering this can degrade video smoothness or introduce lag on Android Auto.
     # Do not change it autonomously; require an explicit user request specifically for this video optimization.
     software_fps = min(SOFTWARE_FPS, config["fps"]) if config["fps"] else SOFTWARE_FPS
-    encoder, fps = create_encoder(mode.width, mode.height, preference=encoder_preference(config["encoder"]),
-                                  bitrate_kbps=config["bitrate_kbps"],
-                                  margin_height=mode.margin_height if mode.content_top in (None, mode.margin_height // 2) else 0,
-                                  software_fps=software_fps, log=self.log,
-                                  rate_control=config["rate_control"])
+    margin_height = mode.margin_height if mode.content_top in (None, mode.margin_height // 2) else 0
+    if mode.codec == CODEC_H265:  # only a car with no H.264 mode, and only with Allow H.265 video on
+      encoder, fps = create_hevc_encoder(mode.width, mode.height, bitrate_kbps=config["bitrate_kbps"], margin_height=margin_height,
+                                         log=self.log, rate_control=config["rate_control"])
+    else:
+      encoder, fps = create_encoder(mode.width, mode.height, preference=encoder_preference(config["encoder"]),
+                                    bitrate_kbps=config["bitrate_kbps"], margin_height=margin_height,
+                                    software_fps=software_fps, log=self.log,
+                                    rate_control=config["rate_control"])
     fps = min(fps, mode.fps, config["fps"] or fps)
     interval = 1.0 / fps
     flags = (FLAG_NV12 if config["gpu_nv12"] and getattr(encoder, "supports_nv12", False) else 0) | \
diff --git a/openpilot/starpilot/system/starport/tests/test_hevc.py b/openpilot/starpilot/system/starport/tests/test_hevc.py
new file mode 100644
index 0000000000..8e4e916447
--- /dev/null
+++ b/openpilot/starpilot/system/starport/tests/test_hevc.py
@@ -0,0 +1,113 @@
+"""H.265 is an opt-in for a car that offers nothing else; every car with an H.264 mode is chosen exactly as before."""
+import itertools
+
+import pytest
+
+from openpilot.starpilot.system.starport import hw_encoder
+from openpilot.starpilot.system.starport.hw_encoder import HEVC_AUD, normalize_access_unit_hevc
+from openpilot.starpilot.system.starport.session import (CODEC_H264_BP, CODEC_H265, START_CODE, VideoMode, choose_video_mode,
+                                                         codec_config, codec_config_hevc, wire_frame, wire_frame_hevc)
+
+SC = b"\x00\x00\x00\x01"
+
+
+def config(resolution, codec, margin_w=0, margin_h=0, fps=2):
+  return {1: [resolution], 2: [fps], 3: [margin_w], 4: [margin_h], 10: [codec]}
+
+
+def channels(*configs):
+  return [{"id": 3, "video_configs": list(configs), "display_type": 0}]
+
+
+# What Bugsink showed one "AndroidAuto" unit offering: every mode H.265, none H.264 (enums 8, 7, 6 are portrait).
+H265_ONLY = channels(config(8, 7, 288, 1378), config(7, 7, 0, 811), config(6, 7, 0, 541), config(3, 7, 0, 360))
+H264_OFFERS = [
+  channels(config(2, 3, 0, 240)),
+  channels(config(1, 3), config(2, 3, 0, 240), config(3, 3, 0, 360)),
+  channels(config(3, 3, 0, 360), config(2, 3, 0, 240, fps=1)),
+  channels(config(1, 3)),
+]
+
+
+def test_without_the_setting_an_h265_only_car_is_refused_with_a_hint():
+  with pytest.raises(ValueError, match="supported H.264 video mode.*Developer > StarPort"):
+    choose_video_mode(H265_ONLY)
+  with pytest.raises(ValueError, match="supported H.264 video mode.*Developer > StarPort"):
+    choose_video_mode(H265_ONLY, False)
+
+
+def test_with_the_setting_an_h265_only_car_gets_the_1080p_h265_mode_inside_the_known_resolutions():
+  mode = choose_video_mode(H265_ONLY, True)
+  assert (mode.codec, mode.width, mode.height, mode.margin_height) == (CODEC_H265, 1920, 1080, 360)
+  assert mode.as_dict()["codec"] == "H.265"
+
+
+@pytest.mark.parametrize("offer", H264_OFFERS)
+def test_a_car_with_an_h264_mode_is_chosen_identically_whatever_the_setting(offer):
+  without, with_setting = choose_video_mode(offer), choose_video_mode(offer, True)
+  assert without == with_setting and without.codec == CODEC_H264_BP
+  assert "codec" not in without.as_dict()  # H.264 reports and screen files are unchanged
+
+
+def test_mixed_offers_never_prefer_h265_over_h264():
+  for h264, h265 in itertools.product(H264_OFFERS, [H265_ONLY, channels(config(2, 7, 0, 240))]):
+    mixed = [{"id": 3, "video_configs": h264[0]["video_configs"] + h265[0]["video_configs"]}]
+    assert choose_video_mode(mixed, True) == choose_video_mode(h264)
+
+
+def test_h265_prefers_the_smaller_known_resolution_like_h264():
+  mode = choose_video_mode(channels(config(3, 7, 0, 360), config(2, 7, 0, 240)), True)
+  assert (mode.codec, mode.width, mode.height) == (CODEC_H265, 1280, 720)
+
+
+def au(*kinds):
+  """An Annex B H.265 access unit with the given NAL types."""
+  return b"".join(SC + bytes([kind << 1, 1]) + b"\x42" * 6 for kind in kinds)
+
+
+def test_hevc_codec_config_and_wire_frame_use_the_two_byte_header():
+  frame = au(35, 32, 33, 34, 19)
+  assert START_CODE.findall(codec_config_hevc(frame)) == [SC] * 3
+  assert b"".join(bytes([kind << 1, 1]) + b"\x42" * 6 for kind in (32, 33, 34)) == codec_config_hevc(frame).replace(SC, b"")
+  assert wire_frame_hevc(frame, drop_config=True) == SC + bytes([19 << 1, 1]) + b"\x42" * 6
+  assert wire_frame_hevc(frame, drop_config=False) == au(32, 33, 34, 19)  # the AUD is always dropped
+  assert codec_config_hevc(au(35, 1)) == b""
+
+
+def test_h264_functions_are_unchanged_by_the_h265_ones():
+  h264 = SC + b"\x09\xf0" + SC + b"\x67" + b"\x01" * 5 + SC + b"\x68" + b"\x02" * 3 + SC + b"\x65" + b"\x03" * 9
+  assert codec_config(h264) == SC + b"\x67" + b"\x01" * 5 + SC + b"\x68" + b"\x02" * 3
+  assert wire_frame(h264, drop_config=True) == SC + b"\x65" + b"\x03" * 9
+
+
+def test_hevc_access_units_are_checked_like_the_h264_ones():
+  keyframe = normalize_access_unit_hevc(au(32, 33, 34, 20), keyframe=True)
+  assert keyframe.startswith(HEVC_AUD) and keyframe.count(SC) == 5
+  assert normalize_access_unit_hevc(au(35, 1), keyframe=False).startswith(HEVC_AUD)
+  # The comma's encoder emits two slices per picture; both belong to the same picture.
+  assert normalize_access_unit_hevc(au(32, 33, 34, 19, 19), keyframe=True).count(SC) == 6
+  assert normalize_access_unit_hevc(au(1, 1), keyframe=False).count(SC) == 3
+  for bad, key in ((au(32, 33, 34), True), (au(35), False), (au(33, 34, 19), True), (au(32, 33, 34, 1), True), (au(19, 1), False)):
+    with pytest.raises(RuntimeError):
+      normalize_access_unit_hevc(bad, keyframe=key)
+  with pytest.raises(RuntimeError):
+    normalize_access_unit_hevc(b"not annex b", keyframe=False)
+
+
+def test_the_hevc_encoder_class_only_changes_what_h265_needs():
+  h264, hevc = hw_encoder.HardwareH264Encoder, hw_encoder.HardwareHevcEncoder
+  assert (h264.max_width, h264.max_height, h264.codec_options, h264.required_abi) == (1280, 720, 0, 2)
+  assert (hevc.max_width, hevc.max_height, hevc.codec_options, hevc.required_abi) == (1920, 1080, hw_encoder.OPTION_HEVC, 4)
+  assert hw_encoder.OPTION_HEVC & hw_encoder.OPTION_CBR == 0
+
+
+def test_h265_never_falls_back_to_another_codec(monkeypatch, tmp_path):
+  monkeypatch.setattr(hw_encoder, "LIBRARY", tmp_path / "missing.so")
+  events = []
+  with pytest.raises(RuntimeError, match="needs H.265 and the hardware encoder could not start it"):
+    hw_encoder.create_hevc_encoder(1920, 1080, bitrate_kbps=6000, margin_height=360, log=lambda *a, **k: events.append(a))
+  assert events == []  # nothing was announced as started
+
+
+def test_video_mode_defaults_to_h264():
+  assert VideoMode(3, 0, 1280, 720, 30, 0, 240).codec == CODEC_H264_BP

From 57900f3d7367ab1c1809d9f39a4f82c2efb3c6e6 Mon Sep 17 00:00:00 2001
From: dirwin31 <83434411+dirwin31@users.noreply.github.com>
Date: Sun, 1 Nov 2026 14:12:37 -0800
Subject: [PATCH 13/38] Add the setup ladder: try handshakes in order, remember
 the one that worked

One module now decides how to answer a car's handshake, and it is also the
learned profile: the strategy that last worked is the one tried first.

The first pass is today's behavior. Later rungs are knobs that already
existed: the other version reply (the flip the dongle work added, now owned
here), the phone-style reply with both bands and with 2.4 GHz only, a longer
wait for a car that keeps saying not ready, and, for adapters only, the
handshake variations.

A failure advances the ladder only when the car answered the version
exchange, then went silent or refused the Wi-Fi setup, before any video was
acknowledged in the session. A sleeping car, this comma's own Bluetooth
trouble and anything after video (a car shutting off) never move it. Three
passes per boot at most, resuming at the first untried rung on the next
ignition; a learned strategy is dropped after two handshake failures; a
session that streams for a minute makes its strategy the learned one.

State is a small per-car file beside the config (setup_state.json, newest 16
cars, damaged or unreadable means a fresh start, never blocks a connection).
The status exposes the ladder for the setup screen, and reports carry what
was tried, how each rung ended and how long the car took to be ready.
---
 .../starpilot/system/starport/bootstrap.py    |   9 +-
 .../system/starport/bugsink_report.py         |  19 ++
 .../starpilot/system/starport/session.py      |   2 +
 .../starpilot/system/starport/setup_ladder.py | 257 ++++++++++++++++++
 .../starpilot/system/starport/supervisor.py   |  52 +++-
 .../starport/tests/test_bugsink_report.py     |  14 +
 .../starport/tests/test_setup_ladder.py       | 213 +++++++++++++++
 7 files changed, 556 insertions(+), 10 deletions(-)
 create mode 100644 openpilot/starpilot/system/starport/setup_ladder.py
 create mode 100644 openpilot/starpilot/system/starport/tests/test_setup_ladder.py

diff --git a/openpilot/starpilot/system/starport/bootstrap.py b/openpilot/starpilot/system/starport/bootstrap.py
index bd00289ec1..9e23f0d0c4 100644
--- a/openpilot/starpilot/system/starport/bootstrap.py
+++ b/openpilot/starpilot/system/starport/bootstrap.py
@@ -266,11 +266,14 @@ class WirelessBootstrap:
   def __init__(self, sock, log: Callable[..., None], *, device_serial: str = "starpilot",
                version_status: int = STATUS_SUCCESS, stage_timeout: float = 20.0, start_request_delay: float = 5.0,
                initial_kick_delay: float = INITIAL_KICK_SECONDS, join_ping_interval: float = JOIN_PING_INTERVAL,
-               experiment: str = "", modern_reply: bool = False):
+               experiment: str = "", modern_reply: bool = False, patience: int = REFUSAL_PATIENCE,
+               channel_override: int | None = None):
     self.sock = sock
     self.experiment = experiment if valid_experiment(experiment) else ""
     self.lifetime_id = uuid.uuid4().hex
     self.modern_reply = modern_reply
+    self.patience = patience                # stage timeouts a car that keeps saying "not ready" gets (setup ladder)
+    self.channel_override = channel_override  # Wi-Fi band to answer with inside the phone-style reply; None keeps the car's own
     self.version_major = 0
     self.car_started = False
     self.flags = EXPERIMENTS[self.experiment][1] if self.experiment else set()
@@ -337,7 +340,7 @@ class WirelessBootstrap:
     self.version_major = major
     if major < MODERN_MAJOR or not self.modern_reply:
       return field(1, major) + field(2, minor) + field(3, self.device_serial) + field(4, self.version_status)
-    selected = channel_type(request)
+    selected = self.channel_override or channel_type(request)
     session = field(1, self.device_serial) + field(2, self.lifetime_id)
     reply = (field(1, major) + field(2, minor) + field(3, self.device_serial) + field(4, MODERN_VERSION_SUCCESS) +
              field(5, selected) + field(6, session))
@@ -376,7 +379,7 @@ class WirelessBootstrap:
     # exchange if the car has not started it; newer head units (2025 Honda) wait for it.
     start_request_at: float | None = None
     deadline = time.monotonic() + self.stage_timeout
-    latest_deadline = time.monotonic() + REFUSAL_PATIENCE * self.stage_timeout
+    latest_deadline = time.monotonic() + self.patience * self.stage_timeout
     initial_kick_at: float | None = time.monotonic() + self.initial_kick_delay
     hint_ready_at: float | None = None
     while endpoint is None:
diff --git a/openpilot/starpilot/system/starport/bugsink_report.py b/openpilot/starpilot/system/starport/bugsink_report.py
index c739af77e6..40d0d6e967 100644
--- a/openpilot/starpilot/system/starport/bugsink_report.py
+++ b/openpilot/starpilot/system/starport/bugsink_report.py
@@ -202,6 +202,22 @@ def session_setup(events: list[dict]) -> dict:
   ) if value}
 
 
+def session_ladder(events: list[dict]) -> list[dict]:
+  """The handshake strategies tried in a session, in order, and how each ended (advanced, wrapped, exhausted, counted,
+  dropped, or worked). Kept for working pairings too: it is what shows which strategy a head unit likes."""
+  tried: list[dict] = []
+  for event in events:
+    name = event["event"]
+    if name == "ladder_strategy":
+      tried.append({"rung": str(event.get("rung", ""))[:24], "learned": bool(event.get("learned")),
+                    "at_s": elapsed(events[0], event)})
+    elif name == "ladder_failed" and tried:
+      tried[-1]["outcome"] = str(event.get("outcome", ""))[:16]
+    elif name == "ladder_worked" and tried:
+      tried[-1].update(outcome="worked", streamed_s=event.get("streamed_s"), t_ready_s=event.get("t_ready_s"))
+  return [{key: value for key, value in item.items() if value is not None} for item in tried[-12:]]
+
+
 def session_strategy(events: list[dict], setup: dict) -> dict:
   """What a streaming session ran with; the raw material for "this head unit usually likes this profile"."""
   if not any(event["event"] == "video_acknowledged" for event in events):
@@ -248,6 +264,7 @@ def session_record(path: Path) -> dict:
     # True when the comma's address went to the car in the pairing request; None when the car never opened that channel.
     "phone_address_sent": bool(opened.get("phone_address")) if opened is not None else None,
     "strategy": session_strategy(events, setup),
+    "ladder": session_ladder(events),
     "software": {key: str(software.get(key) or "unknown") for key in ("commit", "branch")} if isinstance(software, dict) else {},
     "settings": settings if isinstance(settings, dict) else {},
     "seq": _session_number(path),
@@ -464,6 +481,7 @@ def drive_event(sessions: list[dict]) -> dict:
   label = _head_unit_label(head_unit)
   setup = next((s["setup"] for s in reversed(sessions) if s.get("setup")), {})
   sent = next((s["phone_address_sent"] for s in reversed(sessions) if s.get("phone_address_sent") is not None), None)
+  ladder = next((s["ladder"][-1] for s in reversed(sessions) if s.get("ladder")), {})
   failures = [failure_detail(failure) for failure in drive_failures(sessions)]
   failed = [session for session in sessions if session["seq"] in {failure["session"] for failure in failures}]
   heading = "failures" if failures else "sessions"
@@ -499,6 +517,7 @@ def drive_event(sessions: list[dict]) -> dict:
              **({"aa.adapter_model": setup["profile"]} if setup.get("profile") else {}),
              **({"aa.profile_source": setup["profile_source"]} if setup.get("profile_source") else {}),
              **({"aa.phone_address_sent": "yes" if sent else "no"} if sent is not None else {}),
+             **({"aa.ladder_rung": ladder["rung"], "aa.ladder_learned": "yes" if ladder.get("learned") else "no"} if ladder else {}),
              **({"aa.attention": ",".join(reasons)[:190]} if reasons else {}),
              **({"aa.cause": latest["cause"], "aa.stage": latest["stage"], "aa.error_kind": latest["error_kind"]} if latest else {}),
              **({"aa.reach_class": latest["reach"]} if latest and latest.get("reach") else {}),
diff --git a/openpilot/starpilot/system/starport/session.py b/openpilot/starpilot/system/starport/session.py
index 9042b765cb..22f3ff284f 100644
--- a/openpilot/starpilot/system/starport/session.py
+++ b/openpilot/starpilot/system/starport/session.py
@@ -672,6 +672,7 @@ class ProjectionSession(Session):
     self.config_ack_slack = 0  # codec-config messages a head unit may acknowledge like frames
     self.epoch_acked = 0
     self.video_confirmed = False
+    self.video_confirmed_at = 0.0
     self.input_channel: int | None = None
     self.max_window = self.MAX_WINDOW  # raised by the supervisor for adapters that need the car's full window
     self.allow_hevc = False  # the owner's Allow H.265 video setting; used only when the car offers no H.264 mode
@@ -950,6 +951,7 @@ class ProjectionSession(Session):
     # bound on acknowledged frames without changing flow-control credit.
     if not self.video_confirmed and self.epoch_acked > self.config_ack_slack:
       self.video_confirmed = True
+      self.video_confirmed_at = time.monotonic()
       self.event("video_acknowledged", session=self.session_id, ack_ms=round(self.max_ack_seconds * 1000))
 
   # ANDROID AUTO VIDEO PERFORMANCE GUARDRAIL: Receiver ACK flow control bounds in-flight video; extra buffering increases latency.
diff --git a/openpilot/starpilot/system/starport/setup_ladder.py b/openpilot/starpilot/system/starport/setup_ladder.py
new file mode 100644
index 0000000000..cb68e094c6
--- /dev/null
+++ b/openpilot/starpilot/system/starport/setup_ladder.py
@@ -0,0 +1,257 @@
+"""Which wireless handshake to try for a car, in what order, and which one last worked.
+
+The ladder is the one place that decides this. It owns the flip between the standard and phone-style version reply that
+the dongle work added, and it is also the "learned profile": the rung that last worked is simply the strategy used first
+the next time.
+
+One rule decides everything: **a failure advances the ladder only when the car answered the version exchange and no video
+was acknowledged yet in this session.** A sleeping car, this comma's own Bluetooth trouble, a car that shuts off after the
+drive has streamed, anything that is not the handshake being refused: none of these say anything about which strategy the
+car prefers, so none of them move it. Without that rule every ignition with an asleep car would walk the whole ladder and
+a car that works fine would end up running the dongle experiments.
+
+The first pass for a car is exactly what ran before (rung ``standard``); the later rungs are knobs that already existed.
+"""
+from __future__ import annotations
+
+import json
+import os
+import tempfile
+import time
+from dataclasses import dataclass
+from pathlib import Path
+
+from openpilot.starpilot.system.starport.bootstrap import CHANNEL_24GHZ, CHANNEL_DUAL, MODERN_MAJOR, REFUSAL_PATIENCE
+from openpilot.starpilot.system.starport.identity import DATA_DIR
+
+STATE_PATH = DATA_DIR / "setup_state.json"
+STATE_VERSION = 1
+MAX_CARS = 16
+MAX_PASSES = 3          # full runs through the ladder per boot (one boot is one ignition cycle); not yet confirmed against real cars
+DROP_AFTER = 2          # failures at the remembered strategy before it is forgotten and the ladder starts over
+CLEAN_SECONDS = 60.0    # a session that streamed this long without ending in a handshake failure counts as working
+LONG_PATIENCE = 2 * REFUSAL_PATIENCE
+
+RUNGS = ("standard", "other_reply", "modern_dual", "modern_24ghz", "patient", "experiments")
+LABELS = {
+  "standard": "Standard handshake",
+  "other_reply": "The other version reply",
+  "modern_dual": "Phone-style reply, both Wi-Fi bands",
+  "modern_24ghz": "Phone-style reply, 2.4 GHz",
+  "patient": "Waiting longer for the car",
+  "experiments": "Adapter handshake variations",
+}
+MODERN_RUNGS = ("other_reply", "modern_dual", "modern_24ghz")  # only mean something to a car that speaks protocol 4 or newer
+
+
+@dataclass(frozen=True)
+class Strategy:
+  rung: str
+  modern_reply: bool
+  channel_type: int | None = None   # forces the Wi-Fi band reply inside the phone-style reply; None keeps the car's own preference
+  patience: int = REFUSAL_PATIENCE
+  experiments: bool = False
+
+  def as_dict(self) -> dict:
+    return {"rung": self.rung, "modern_reply": self.modern_reply, "channel_type": self.channel_type,
+            "patience": self.patience, "experiments": self.experiments}
+
+  @property
+  def label(self) -> str:
+    return LABELS.get(self.rung, self.rung)
+
+
+def resolve(rung: str, base_modern: bool) -> Strategy:
+  """The concrete strategy for a rung, relative to the car's remembered reply style (today's behavior)."""
+  if rung == "other_reply":
+    return Strategy(rung, not base_modern)
+  if rung == "modern_dual":
+    return Strategy(rung, True, CHANNEL_DUAL)
+  if rung == "modern_24ghz":
+    return Strategy(rung, True, CHANNEL_24GHZ)
+  if rung == "patient":
+    return Strategy(rung, base_modern, patience=LONG_PATIENCE)
+  if rung == "experiments":
+    return Strategy(rung, base_modern, experiments=True)
+  return Strategy("standard", base_modern)
+
+
+def applicable(rung: str, version_major: int, adapter: bool) -> bool:
+  if rung in MODERN_RUNGS:
+    return version_major >= MODERN_MAJOR
+  if rung == "experiments":
+    return adapter
+  return True
+
+
+def _boot_id() -> str:
+  try:
+    return Path("/proc/sys/kernel/random/boot_id").read_text().strip()
+  except OSError:
+    return ""
+
+
+def _valid_strategy(value) -> Strategy | None:
+  if not isinstance(value, dict) or value.get("rung") not in RUNGS:
+    return None
+  channel, patience = value.get("channel_type"), value.get("patience")
+  if type(value.get("modern_reply")) is not bool or type(value.get("experiments")) is not bool:
+    return None
+  if channel not in (None, CHANNEL_24GHZ, CHANNEL_DUAL, 1) or type(patience) is not int or not 1 <= patience <= 12:
+    return None
+  return Strategy(value["rung"], value["modern_reply"], channel, patience, value["experiments"])
+
+
+def _fresh() -> dict:
+  return {"rung": "standard", "results": {}, "passes": 0, "boot": "", "working": None, "working_failures": 0,
+          "t_ready": [], "successes": 0, "updated": 0.0}
+
+
+def _clean(entry) -> dict:
+  """A saved entry, or a fresh one when anything about it is not what this module writes."""
+  fresh = _fresh()
+  if not isinstance(entry, dict):
+    return fresh
+  try:
+    rung = entry.get("rung")
+    results = entry.get("results")
+    if rung in RUNGS:
+      fresh["rung"] = rung
+    if isinstance(results, dict):
+      fresh["results"] = {key: value for key, value in results.items() if key in RUNGS and value in ("failed", "skipped", "worked")}
+    for key in ("passes", "working_failures", "successes"):
+      if type(entry.get(key)) is int and 0 <= entry[key] <= 10_000:
+        fresh[key] = entry[key]
+    fresh["boot"] = entry["boot"][:64] if isinstance(entry.get("boot"), str) else ""
+    working = _valid_strategy(entry.get("working"))
+    fresh["working"] = working.as_dict() if working else None
+    fresh["t_ready"] = [round(float(value), 1) for value in entry.get("t_ready", []) if isinstance(value, (int, float)) and 0 <= value <= 3600][-8:]
+    fresh["updated"] = float(entry["updated"]) if isinstance(entry.get("updated"), (int, float)) else 0.0
+  except (TypeError, ValueError, KeyError):
+    return _fresh()
+  return fresh
+
+
+class SetupLadder:
+  def __init__(self, path: Path | None = None, boot_id=_boot_id, clock=time.time):
+    self.path = path or STATE_PATH
+    self.boot_id, self.clock = boot_id, clock
+    self.cars: dict[str, dict] = {}
+    self.load()
+
+  def load(self) -> None:
+    try:
+      data = json.loads(self.path.read_text())
+      cars = data["cars"] if isinstance(data, dict) and data.get("version") == STATE_VERSION and isinstance(data.get("cars"), dict) else {}
+    except (OSError, ValueError, KeyError, TypeError, UnicodeError):
+      cars = {}
+    self.cars = {str(address).upper(): _clean(entry) for address, entry in list(cars.items())[:MAX_CARS]}
+
+  def save(self) -> bool:
+    ordered = dict(sorted(self.cars.items(), key=lambda item: item[1]["updated"], reverse=True)[:MAX_CARS])
+    self.cars = ordered
+    try:
+      self.path.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
+      fd, temporary = tempfile.mkstemp(dir=self.path.parent, prefix=".setup-state-")
+      try:
+        with os.fdopen(fd, "w") as handle:
+          json.dump({"version": STATE_VERSION, "cars": ordered}, handle, separators=(",", ":"))
+          handle.flush()
+          os.fsync(handle.fileno())
+        os.chmod(temporary, 0o600)
+        os.replace(temporary, self.path)
+      finally:
+        if os.path.exists(temporary):
+          os.unlink(temporary)
+    except OSError:
+      return False  # progress is a convenience; a read-only disk must never stop a connection
+    return True
+
+  def _entry(self, address: str) -> dict:
+    entry = self.cars.setdefault(address.upper(), _fresh())
+    boot = self.boot_id()
+    if entry["boot"] != boot:       # a new ignition cycle gets its full passes again and resumes at the first untried rung
+      entry["boot"], entry["passes"] = boot, 0
+    return entry
+
+  def forget(self, address: str) -> bool:
+    """A car's pairing was deleted: drop what was learned about it."""
+    removed = self.cars.pop(address.upper(), None) is not None
+    if removed:
+      self.save()
+    return removed
+
+  def exhausted(self, address: str) -> bool:
+    entry = self.cars.get(address.upper())
+    return bool(entry) and entry["boot"] == self.boot_id() and entry["passes"] >= MAX_PASSES and not entry["working"]
+
+  def strategy(self, address: str, base_modern: bool) -> Strategy:
+    """What to try now: the strategy that worked, else the current rung (standard once the passes are used up)."""
+    entry = self._entry(address)
+    working = _valid_strategy(entry["working"])
+    if working:
+      return working
+    if entry["passes"] >= MAX_PASSES:
+      return resolve("standard", base_modern)
+    return resolve(entry["rung"], base_modern)
+
+  def failed(self, address: str, strategy: Strategy, *, ladder_failure: bool, video_seen: bool, version_major: int,
+             adapter: bool) -> str | None:
+    """Record a failed attempt; returns what changed ("advanced", "wrapped", "exhausted", "counted", "dropped") or None.
+
+    Only a handshake the car answered, before any video this session, counts: see the module docstring."""
+    if not ladder_failure or video_seen:
+      return None
+    entry = self._entry(address)
+    entry["updated"] = self.clock()
+    working = _valid_strategy(entry["working"])
+    if working and strategy.rung == working.rung:
+      entry["working_failures"] += 1
+      if entry["working_failures"] < DROP_AFTER:
+        self.save()
+        return "counted"
+      entry.update(working=None, working_failures=0, rung="standard", results={})
+      self.save()
+      return "dropped"
+    if entry["passes"] >= MAX_PASSES:
+      return None
+    entry["results"][strategy.rung] = "failed"
+    start = RUNGS.index(strategy.rung) if strategy.rung in RUNGS else 0
+    outcome = "wrapped"
+    for rung in RUNGS[start + 1:]:
+      if applicable(rung, version_major, adapter):
+        entry["rung"], outcome = rung, "advanced"
+        break
+      entry["results"][rung] = "skipped"
+    if outcome == "wrapped":
+      entry["passes"] += 1
+      entry["rung"], entry["results"] = "standard", {}
+      if entry["passes"] >= MAX_PASSES:
+        outcome = "exhausted"
+    self.save()
+    return outcome
+
+  def worked(self, address: str, strategy: Strategy, t_ready_s: float | None = None) -> None:
+    entry = self._entry(address)
+    entry.update(working=strategy.as_dict(), working_failures=0, rung=strategy.rung, results={strategy.rung: "worked"},
+                 passes=0, successes=entry["successes"] + 1, updated=self.clock())
+    if t_ready_s is not None and 0 <= t_ready_s <= 3600:
+      entry["t_ready"] = (entry["t_ready"] + [round(float(t_ready_s), 1)])[-8:]
+    self.save()
+
+  def snapshot(self, address: str, adapter: bool = False) -> dict:
+    """What the setup screen and the reports show: every rung, its state, and whether this car has a learned strategy."""
+    entry = self.cars.get(address.upper()) if address else None
+    entry = entry or _fresh()
+    working = _valid_strategy(entry["working"])
+    current = working.rung if working else entry["rung"]
+    passes = entry["passes"] if entry["boot"] == self.boot_id() else 0   # passes belong to one ignition cycle
+    steps = []
+    for rung in RUNGS:
+      if rung == "experiments" and not adapter:
+        continue
+      state = entry["results"].get(rung) or ("current" if rung == current else "waiting")
+      steps.append({"id": rung, "label": LABELS[rung], "state": state})
+    return {"steps": steps, "current": current, "learned": bool(working), "passes": passes, "max_passes": MAX_PASSES,
+            "exhausted": passes >= MAX_PASSES and not working, "successes": entry["successes"],
+            "t_ready_s": entry["t_ready"][-1] if entry["t_ready"] else None}
diff --git a/openpilot/starpilot/system/starport/supervisor.py b/openpilot/starpilot/system/starport/supervisor.py
index 6e7d94c581..1e559175d5 100644
--- a/openpilot/starpilot/system/starport/supervisor.py
+++ b/openpilot/starpilot/system/starport/supervisor.py
@@ -33,9 +33,9 @@ from pathlib import Path
 from typing import Any
 
 from openpilot.common.hardware import COMMA_HARDWARE
-from openpilot.starpilot.system.starport import car_profiles, device_health, identity as identity_store, reachability, system_slice
+from openpilot.starpilot.system.starport import car_profiles, device_health, identity as identity_store, new_setup, reachability, setup_ladder, system_slice
 from openpilot.starpilot.system.starport.auto_connect import AutoConnectPolicy
-from openpilot.starpilot.system.starport.bootstrap import MODERN_MAJOR, NAMES, BootstrapError, WirelessBootstrap
+from openpilot.starpilot.system.starport.bootstrap import MODERN_MAJOR, NAMES, BootstrapError, BootstrapTimeout, WirelessBootstrap
 from openpilot.starpilot.system.starport.bugsink_report import PairingAttempt
 from openpilot.starpilot.system.starport.frame_source import (DEFAULT_PATH as DEFAULT_FRAME_PATH, FLAG_ASYNC_READBACK, FLAG_NV12,
                                                                   FORMAT_NV12, FrameRequest)
@@ -374,6 +374,10 @@ class Supervisor:
     self._car_seen_at = -CAR_LINK_HOLD
     self._hfp_link = threading.Event()  # set when the chosen car opens the hands-free link
     self._modern_reply: dict[str, bool] = {}  # car address -> answer its v4+ version request like a current phone
+    self._ladder = setup_ladder.SetupLadder(identity_store.CONFIG_PATH.with_name("setup_state.json"))   # which handshake to try for each car, and which one last worked
+    self._strategy: setup_ladder.Strategy | None = None   # the one this attempt runs
+    self._video_seen = False                    # video was acknowledged in this session: later failures say nothing about the handshake
+    self._run_started = 0.0
     self.auto = AutoConnectPolicy()
     self._companion_retry_at = 0.0
     self.log = EventLog()
@@ -418,6 +422,8 @@ class Supervisor:
     status["dedicated_wifi_interface"] = bool(self.config["dedicated_wifi_interface"])
     status["allow_hevc"] = bool(self.config["allow_hevc"])
     status["car_candidates"] = list(getattr(self, "_candidates", []))[:8]  # paired Android Auto devices to choose between
+    status["new_setup"] = new_setup.enabled()
+    status["setup_ladder"] = self._ladder.snapshot(self.config["receiver_address"], self.car_type() == "adapter")
     status["auto_paused"] = self.auto.suppressed
     status["recent"] = list(self.log.recent)[-8:]
     return status
@@ -534,6 +540,7 @@ class Supervisor:
         return False  # nothing of this device was kept
       self.config.update(rfcomm_cache=cache, modern_reply_cache=replies)
       self._modern_reply.pop(address, None)
+      self._ladder.forget(address)
       if chosen:
         if self._bluez is not None:
           self._bluez.release()
@@ -1190,6 +1197,7 @@ class Supervisor:
     connection = self.config["connection"]
     wireless = connection == "wireless"
     receiver = {"wired": "usb", "headunitpad": "headunitpad", "openheadunit": "openheadunit"}.get(connection, self.config["receiver_name"])
+    self._video_seen, self._strategy, self._run_started = False, None, time.monotonic()
     from openpilot.starpilot.system.starport.bugsink_transport import device_metadata
     software = device_metadata()
     profile, profile_source = car_profiles.resolve(self.config)
@@ -1285,6 +1293,7 @@ class Supervisor:
     config = self.config
     address = config["receiver_address"]
     ident = identity_store.load_identity()
+    self._strategy = None
 
     self._stage("connecting_bluetooth", config["receiver_name"])
     bluez = self._phone()
@@ -1318,21 +1327,35 @@ class Supervisor:
     self.log("rfcomm_channel", channel=channel, source=source)
 
     boot = None
+    adapter = self.car_type() == "adapter"
+    # The ladder decides how to answer this car: what worked before, else the first rung (today's behavior), moving on
+    # only when a car that answered the handshake keeps refusing it before any video.
+    base_modern = self._modern_reply.get(address, config.get("modern_reply_cache", {}).get(address, False))
+    strategy = self._strategy = self._ladder.strategy(address, base_modern)
+    learned = self._ladder.snapshot(address, adapter)["learned"]
+    self.log("ladder_strategy", rung=strategy.rung, label=strategy.label, learned=learned, modern_reply=strategy.modern_reply,
+             channel_type=strategy.channel_type, patience=strategy.patience, experiments=strategy.experiments)
     try:
       self._stage("rfcomm", f"channel {channel}")
       rfcomm = self._track(bt_sockets.connect_rfcomm(address, channel))
       boot = WirelessBootstrap(rfcomm, self._bootstrap_log, device_serial=config["device_name"],
                                version_status=int(config.get("version_status", 0)),
-                               experiment="all" if car_profiles.tuning(config)["bootstrap_experiments"] else "",
-                               modern_reply=self._modern_reply.get(address, config.get("modern_reply_cache", {}).get(address, False)))
+                               experiment="all" if car_profiles.tuning(config)["bootstrap_experiments"] or strategy.experiments else "",
+                               modern_reply=strategy.modern_reply, patience=strategy.patience, channel_override=strategy.channel_type)
       self._set(state="wifi_start")
       result = boot.run(lambda credentials: lease.acquire(credentials, cancelled=boot.join_is_cancelled), cancelled=self._stop.is_set)
     except Exception as error:
       if _stray_link(error):
         raise StrayLinkError(f"Bluetooth link to the car is stuck: {error}") from error  # says nothing about the cached channel
-      if boot is not None and boot.silent_after_modern_version(error):
-        self._modern_reply[address] = not boot.modern_reply  # try the other version reply next
-        self.log("bootstrap_reply_switched", modern=self._modern_reply[address])
+      # A car that answered the version exchange and then went silent or refused the Wi-Fi setup says something about the
+      # handshake; every other failure (asleep, local Bluetooth trouble, after video) says nothing and leaves the ladder alone.
+      ladder_failure = (boot is not None and boot.version_major > 0 and isinstance(error, BootstrapTimeout)
+                        and error.stage in ("wifi_start", "wifi_info") and not self._stop.is_set())
+      outcome = self._ladder.failed(address, strategy, ladder_failure=ladder_failure, video_seen=self._video_seen,
+                                    version_major=boot.version_major if boot is not None else 0, adapter=adapter)
+      if outcome:
+        self.log("ladder_failed", outcome=outcome, rung=strategy.rung, next=self._ladder.strategy(address, base_modern).rung,
+                 version_major=boot.version_major)
       if source == "cache" and not self._stop.is_set() and drops_cached_channel(self._status["last_stage"], error):
         self._remember_channel(address, None)  # the car never answered there; ask it over SDP next time
         self.log("rfcomm_cache_dropped", channel=channel)
@@ -1632,6 +1655,7 @@ class Supervisor:
     try:
       self._stream(session, encoder, source, watch, interval)
     finally:
+      self._note_streamed(session)
       if session.audio is not None:
         session.audio.close()
       if getattr(session, "nav", None) is not None:
@@ -1645,6 +1669,20 @@ class Supervisor:
         except Exception:
           pass
 
+  def _note_streamed(self, session: ProjectionSession) -> None:
+    """Video was acknowledged: later failures in this session say nothing about the handshake. A session that streamed for
+    a minute without a handshake failure makes the strategy it ran with the one this car starts with next time."""
+    if not session.video_confirmed:
+      return
+    self._video_seen = True
+    strategy, address = self._strategy, self.config["receiver_address"]
+    streamed = time.monotonic() - session.video_confirmed_at
+    if strategy is None or not address or streamed < setup_ladder.CLEAN_SECONDS:
+      return
+    self._ladder.worked(address, strategy, t_ready_s=session.video_confirmed_at - self._run_started)
+    self.log("ladder_worked", rung=strategy.rung, streamed_s=round(streamed, 1),
+             t_ready_s=round(session.video_confirmed_at - self._run_started, 1))
+
   # ANDROID AUTO VIDEO PERFORMANCE GUARDRAIL: The bounded ACK/input drain and conditional waits keep video and touches responsive.
   # Altering this can degrade video smoothness or introduce lag on Android Auto.
   # Do not change it autonomously; require an explicit user request specifically for this video optimization.
diff --git a/openpilot/starpilot/system/starport/tests/test_bugsink_report.py b/openpilot/starpilot/system/starport/tests/test_bugsink_report.py
index 3221f8114b..2e300c8974 100644
--- a/openpilot/starpilot/system/starport/tests/test_bugsink_report.py
+++ b/openpilot/starpilot/system/starport/tests/test_bugsink_report.py
@@ -492,3 +492,17 @@ def test_unknown_setup_values_are_dropped(tmp_path):
   events[0] = (0, 0, "session_start", {"setup": {"type": "<script>", "profile": "x" * 90, "profile_source": "guess"}})
   setup = br.session_record(write_session(tmp_path, 1, events))["setup"]
   assert "type" not in setup and "profile_source" not in setup and len(setup["profile"]) <= 40
+
+
+def test_report_shows_what_the_ladder_tried_and_what_worked(tmp_path):
+  events = [list(item) for item in STREAMED]
+  events.insert(1, (0, 1, "ladder_strategy", {"rung": "standard", "learned": False}))
+  events.insert(2, (0, 5, "ladder_failed", {"outcome": "advanced", "rung": "standard", "next": "other_reply"}))
+  events.insert(3, (0, 6, "ladder_strategy", {"rung": "other_reply", "learned": False}))
+  events.append((1, 50, "ladder_worked", {"rung": "other_reply", "streamed_s": 62.0, "t_ready_s": 14.5}))
+  record = br.session_record(write_session(tmp_path, 1, events))
+  assert record["ladder"] == [{"rung": "standard", "learned": False, "at_s": 1.0, "outcome": "advanced"},
+                              {"rung": "other_reply", "learned": False, "at_s": 6.0, "outcome": "worked", "streamed_s": 62.0, "t_ready_s": 14.5}]
+  tags = br.drive_event([record])["tags"]
+  assert (tags["aa.ladder_rung"], tags["aa.ladder_learned"]) == ("other_reply", "no")
+  assert br.session_record(write_session(tmp_path, 2, STREAMED))["ladder"] == []   # older logs report nothing, without error
diff --git a/openpilot/starpilot/system/starport/tests/test_setup_ladder.py b/openpilot/starpilot/system/starport/tests/test_setup_ladder.py
new file mode 100644
index 0000000000..be0826f4b8
--- /dev/null
+++ b/openpilot/starpilot/system/starport/tests/test_setup_ladder.py
@@ -0,0 +1,213 @@
+"""The setup ladder moves only when a car that answered the handshake refuses it before any video; nothing else moves it."""
+import json
+
+import pytest
+
+from openpilot.starpilot.system.starport import setup_ladder as sl
+from openpilot.starpilot.system.starport.bootstrap import CHANNEL_24GHZ, CHANNEL_DUAL, REFUSAL_PATIENCE
+
+CAR = "AA:BB:CC:DD:EE:FF"
+
+
+@pytest.fixture
+def ladder(tmp_path):
+  state = {"boot": "boot-1"}
+  instance = sl.SetupLadder(tmp_path / "setup_state.json", boot_id=lambda: state["boot"], clock=lambda: 1000.0)
+  instance.state = state
+  return instance
+
+
+def refuse(ladder, strategy, **overrides):
+  values = dict(ladder_failure=True, video_seen=False, version_major=4, adapter=False)
+  values.update(overrides)
+  return ladder.failed(CAR, strategy, **values)
+
+
+def test_the_first_strategy_is_exactly_what_ran_before(ladder):
+  for base in (False, True):
+    strategy = ladder.strategy(CAR, base)
+    assert (strategy.rung, strategy.modern_reply, strategy.channel_type, strategy.patience, strategy.experiments) == (
+      "standard", base, None, REFUSAL_PATIENCE, False)
+
+
+@pytest.mark.parametrize("name,overrides", [
+  ("a car that never answered the handshake (asleep, refused, local trouble)", {"ladder_failure": False}),
+  ("anything after video was acknowledged in the session (car-off teardown)", {"video_seen": True}),
+])
+def test_failures_that_say_nothing_about_the_handshake_never_move_the_ladder(ladder, name, overrides):
+  strategy = ladder.strategy(CAR, False)
+  for _ in range(50):
+    assert refuse(ladder, strategy, **overrides) is None
+  assert ladder.strategy(CAR, False).rung == "standard" and not ladder.exhausted(CAR)
+  assert not (ladder.path.exists() and json.loads(ladder.path.read_text())["cars"])  # nothing was even recorded
+
+
+def test_a_silent_car_walks_the_rungs_in_order_and_each_is_a_knob_that_already_existed(ladder):
+  seen = []
+  for step in range(5):
+    strategy = ladder.strategy(CAR, False)
+    seen.append(strategy)
+    assert refuse(ladder, strategy) == ("advanced" if step < 4 else "wrapped")  # the last rung ends the pass
+  assert [s.rung for s in seen] == ["standard", "other_reply", "modern_dual", "modern_24ghz", "patient"]
+  assert [s.modern_reply for s in seen] == [False, True, True, True, False]
+  assert [s.channel_type for s in seen] == [None, None, CHANNEL_DUAL, CHANNEL_24GHZ, None]
+  assert seen[4].patience == sl.LONG_PATIENCE and all(not s.experiments for s in seen)
+
+
+def test_the_other_reply_is_relative_to_what_the_car_was_using(ladder):
+  assert ladder.strategy(CAR, True).modern_reply is True
+  refuse(ladder, ladder.strategy(CAR, True))
+  assert ladder.strategy(CAR, True).modern_reply is False
+
+
+def test_a_car_older_than_protocol_four_skips_the_phone_style_rungs(ladder):
+  refuse(ladder, ladder.strategy(CAR, False), version_major=3)
+  assert ladder.strategy(CAR, False).rung == "patient"
+  assert ladder.snapshot(CAR)["steps"][1]["state"] == "skipped"
+
+
+def test_the_adapter_experiments_run_last_and_only_for_adapters(ladder):
+  for _ in range(5):
+    refuse(ladder, ladder.strategy(CAR, False), adapter=True)
+  strategy = ladder.strategy(CAR, False)
+  assert strategy.rung == "experiments" and strategy.experiments
+  assert refuse(ladder, strategy, adapter=True) == "wrapped"
+  other = sl.SetupLadder(ladder.path.with_name("other.json"), boot_id=lambda: "b")
+  for _ in range(5):
+    refuse(other, other.strategy(CAR, False))
+  assert other.strategy(CAR, False).rung == "standard"  # no adapter, no experiments rung: back to the start
+  assert "experiments" not in [step["id"] for step in other.snapshot(CAR)["steps"]]
+
+
+def test_three_passes_per_boot_then_it_stops_trying_new_things(ladder):
+  results = []
+  for _ in range(5 * sl.MAX_PASSES):
+    results.append(refuse(ladder, ladder.strategy(CAR, False)))
+  assert results.count("exhausted") == 1 and ladder.exhausted(CAR)
+  assert ladder.strategy(CAR, False).rung == "standard"   # settles on today's behavior
+  assert refuse(ladder, ladder.strategy(CAR, False)) is None
+  assert ladder.snapshot(CAR)["exhausted"]
+
+
+def test_the_next_ignition_gets_its_passes_back_and_resumes_at_the_first_untried_rung(ladder):
+  for _ in range(2):
+    refuse(ladder, ladder.strategy(CAR, False))
+  ladder.state["boot"] = "boot-2"
+  assert ladder.strategy(CAR, False).rung == "modern_dual"
+  assert ladder.snapshot(CAR)["passes"] == 0
+  for _ in range(5 * sl.MAX_PASSES):
+    refuse(ladder, ladder.strategy(CAR, False))
+  assert ladder.exhausted(CAR)
+  ladder.state["boot"] = "boot-3"
+  assert not ladder.exhausted(CAR) and ladder.snapshot(CAR)["passes"] == 0
+
+
+def test_what_worked_is_used_first_next_time_even_for_a_different_remembered_reply(ladder):
+  refuse(ladder, ladder.strategy(CAR, False))
+  worked = ladder.strategy(CAR, False)
+  assert worked.rung == "other_reply"
+  ladder.worked(CAR, worked, t_ready_s=18.4)
+  # The reply style is now remembered as the phone-style one; "the other reply" must not flip back to standard.
+  again = ladder.strategy(CAR, True)
+  assert (again.rung, again.modern_reply) == ("other_reply", True)
+  snapshot = ladder.snapshot(CAR)
+  assert snapshot["learned"] and snapshot["t_ready_s"] == 18.4 and snapshot["successes"] == 1
+  assert [step["state"] for step in snapshot["steps"]][1] == "worked"
+
+
+def test_a_learned_strategy_is_forgotten_only_after_two_handshake_failures(ladder):
+  ladder.worked(CAR, sl.resolve("modern_dual", False))
+  learned = ladder.strategy(CAR, False)
+  assert refuse(ladder, learned) == "counted" and ladder.strategy(CAR, False).rung == "modern_dual"
+  assert refuse(ladder, learned, ladder_failure=False) is None and refuse(ladder, learned, video_seen=True) is None
+  assert refuse(ladder, learned) == "dropped"
+  assert ladder.strategy(CAR, False).rung == "standard" and not ladder.snapshot(CAR)["learned"]
+
+
+def test_state_survives_a_restart_and_a_damaged_file_means_a_fresh_start(tmp_path):
+  path = tmp_path / "setup_state.json"
+  first = sl.SetupLadder(path, boot_id=lambda: "b")
+  refuse(first, first.strategy(CAR, False))
+  first.worked(CAR, sl.resolve("patient", False), 12.0)
+  second = sl.SetupLadder(path, boot_id=lambda: "b")
+  assert second.strategy(CAR.lower(), False).rung == "patient" and path.stat().st_mode & 0o777 == 0o600
+  for damage in ("not json", json.dumps({"version": 99, "cars": {}}), json.dumps({"version": 1, "cars": {CAR: {"working": {"rung": "x"}}}}),
+                 json.dumps({"version": 1, "cars": [1]}), ""):
+    path.write_text(damage)
+    assert sl.SetupLadder(path, boot_id=lambda: "b").strategy(CAR, False).rung == "standard"
+
+
+def test_a_read_only_disk_never_stops_a_connection(ladder):
+  ladder.path = ladder.path / "blocked" / "x"   # parent is a missing path under a file below
+  ladder.path.parent.parent.parent.mkdir(exist_ok=True)
+  (ladder.path.parent.parent).write_text("a file where a directory should be")
+  refuse(ladder, ladder.strategy(CAR, False))     # must not raise
+  assert ladder.strategy(CAR, False).rung == "other_reply"
+
+
+def test_only_sixteen_cars_are_kept_newest_first(tmp_path):
+  clock = iter(range(1000, 2000))
+  ladder = sl.SetupLadder(tmp_path / "s.json", boot_id=lambda: "b", clock=lambda: next(clock))
+  for number in range(20):
+    ladder.worked(f"AA:00:00:00:00:{number:02X}", sl.resolve("patient", False))
+  reloaded = sl.SetupLadder(tmp_path / "s.json", boot_id=lambda: "b")
+  assert len(reloaded.cars) == sl.MAX_CARS and "AA:00:00:00:00:13" in reloaded.cars and "AA:00:00:00:00:00" not in reloaded.cars
+
+
+# ---- the supervisor's use of it -------------------------------------------------------------------------------------
+import time as _time  # noqa: E402
+from types import SimpleNamespace  # noqa: E402
+
+from openpilot.starpilot.system.starport.tests.fake_head_unit import make_identity  # noqa: E402
+from openpilot.starpilot.system.starport.tests.test_starport import make_supervisor  # noqa: E402
+
+RECEIVER = "AA:BB:CC:DD:EE:01"  # the car make_supervisor selects
+
+
+@pytest.fixture(scope="module")
+def identity(tmp_path_factory):
+  return make_identity(tmp_path_factory.mktemp("identity"))
+
+
+@pytest.fixture
+def sup(identity, tmp_path, monkeypatch):
+  supervisor, _ = make_supervisor(identity, tmp_path, monkeypatch, lambda *a, **k: None)
+  return supervisor
+
+
+def streamed(seconds):
+  return SimpleNamespace(video_confirmed=True, video_confirmed_at=_time.monotonic() - seconds)
+
+
+def test_the_supervisor_keeps_its_ladder_beside_the_config_so_tests_never_touch_real_state(sup):
+  from openpilot.starpilot.system.starport import identity as identity_store
+  assert sup._ladder.path == identity_store.CONFIG_PATH.with_name("setup_state.json")
+
+
+def test_a_minute_of_video_makes_the_strategy_the_one_this_car_starts_with(sup):
+  strategy = sl.resolve("other_reply", False)
+  sup._strategy, sup._run_started = strategy, _time.monotonic() - 150
+  sup._note_streamed(streamed(30))                      # too short to count, but video was seen
+  assert sup._video_seen and not sup._ladder.snapshot(RECEIVER)["learned"]
+  sup._note_streamed(streamed(90))
+  snapshot = sup._ladder.snapshot(RECEIVER)
+  assert snapshot["learned"] and snapshot["current"] == "other_reply" and 50 < snapshot["t_ready_s"] < 70
+
+
+def test_a_session_that_never_got_video_learns_nothing(sup):
+  sup._strategy = sl.resolve("patient", False)
+  sup._note_streamed(SimpleNamespace(video_confirmed=False, video_confirmed_at=0.0))
+  assert not sup._video_seen and not sup._ladder.snapshot(RECEIVER)["learned"]
+
+
+def test_status_shows_the_ladder_the_switch_and_the_cars_to_choose_between(sup):
+  status = sup.status()
+  assert status["new_setup"] in (True, False) and status["car_candidates"] == []
+  assert [step["id"] for step in status["setup_ladder"]["steps"]][:2] == ["standard", "other_reply"]
+  assert status["setup_ladder"]["max_passes"] == sl.MAX_PASSES and not status["setup_ladder"]["learned"]
+
+
+def test_forgetting_a_car_forgets_what_was_learned_about_it(sup):
+  sup._ladder.worked(RECEIVER, sl.resolve("patient", False), 10.0)
+  assert sup.forget_receiver(RECEIVER) is True
+  assert not sup._ladder.snapshot(RECEIVER)["learned"] and RECEIVER not in sup._ladder.cars

From 3d264541220371531c9781ea1f107cd3addb50eb Mon Sep 17 00:00:00 2001
From: dirwin31 <83434411+dirwin31@users.noreply.github.com>
Date: Sun, 1 Nov 2026 14:14:32 -0800
Subject: [PATCH 14/38] Let Galaxy read and change the new pairing experience
 switch

The setup response carries newSetup, and a new_setup control action turns the
guided setup off or on. It is handled before the StarPort-enabled check and
never calls the daemon, so it works as the way back to the classic screens
when the service is off or broken. It needs a signed-in session and park.
---
 openpilot/starpilot/galaxy/server.py          | 12 +++++++++
 openpilot/starpilot/galaxy/starport_setup.py  |  3 ++-
 .../starpilot/galaxy/test_starport_http.py    | 26 +++++++++++++++++++
 3 files changed, 40 insertions(+), 1 deletion(-)

diff --git a/openpilot/starpilot/galaxy/server.py b/openpilot/starpilot/galaxy/server.py
index 7423609558..bb70c8956f 100644
--- a/openpilot/starpilot/galaxy/server.py
+++ b/openpilot/starpilot/galaxy/server.py
@@ -2399,6 +2399,18 @@ def make_server(*, port=8082, host='127.0.0.1', monitor=None, owner=None, crashe
             else:
               self.json(401, {'error': 'Sign in to Galaxy'})
           return
+        if action == 'new_setup' and set(payload) == {'action', 'enabled'} and type(payload['enabled']) is bool:
+          # The way back to the classic screens, so it works with the StarPort service off or broken.
+          from openpilot.starpilot.system.starport import new_setup
+          if not configuration_allowed():
+            self.json(403, {'error': 'Park before changing the setup screens'})
+          elif not new_setup.set_enabled(payload['enabled']):
+            self.json(503, {'error': 'Could not save the setup screen choice'})
+          elif self.settings_session() == identity:
+            self.json(200, {'newSetup': new_setup.enabled()})
+          else:
+            self.json(401, {'error': 'Sign in to Galaxy'})
+          return
         if not starport_setup_owner().enabled():
           self.json(409, {'error': 'Enable StarPort first'})
           return
diff --git a/openpilot/starpilot/galaxy/starport_setup.py b/openpilot/starpilot/galaxy/starport_setup.py
index 4b4ee93e6a..5e9b19d98d 100644
--- a/openpilot/starpilot/galaxy/starport_setup.py
+++ b/openpilot/starpilot/galaxy/starport_setup.py
@@ -13,7 +13,7 @@ from pathlib import Path
 from collections.abc import Callable
 from typing import BinaryIO
 
-from openpilot.starpilot.system.starport import apk_identity, apkpure
+from openpilot.starpilot.system.starport import apk_identity, apkpure, new_setup
 
 # Left behind by the removed Google sign-in: a saved refresh token and the resolver binary.
 LEGACY_GOOGLE_FILES = (Path('/data/starpilot/starport_token'), Path('/data/starpilot/google-play'))
@@ -65,6 +65,7 @@ class StarPortSetup:
     ident = self.identity_status()
     return {
       'enabled': self.enabled(), 'bluetoothEnabled': self.bluetooth_enabled(), 'parked': self.parked(),
+      'newSetup': new_setup.enabled(),
       'installReady': self.install_ready(), 'serviceReady': self.service_ready(),
       'identity': {key: ident[key] for key in ('installed', 'expires', 'days_left', 'warning', 'message', 'expired', 'error', 'app_version') if key in ident},
       'import': self.job.status(),
diff --git a/openpilot/starpilot/galaxy/test_starport_http.py b/openpilot/starpilot/galaxy/test_starport_http.py
index f8feb37c38..56eb617e7c 100644
--- a/openpilot/starpilot/galaxy/test_starport_http.py
+++ b/openpilot/starpilot/galaxy/test_starport_http.py
@@ -524,3 +524,29 @@ def test_on_device_browser_api_is_gone(api):
   cookie = headers['Set-Cookie'].split(';', 1)[0]
   start = {'operation': 'start', 'email': 'user@example.com', 'remember': False}
   assert request('POST', '/api/starport/google-browser', json.dumps(start), cookie=cookie, content_type='application/json')[0] != 200
+
+
+def test_classic_setup_switch_needs_a_session_and_park_but_not_the_service(api, tmp_path, monkeypatch):
+  from openpilot.starpilot.system.starport import new_setup
+  monkeypatch.setattr(new_setup, 'FLAG_PATH', tmp_path / 'new_setup')
+  request, _, state, client = api
+  body = json.dumps({'action': 'new_setup', 'enabled': False})
+  assert request('POST', '/api/starport/control', body, content_type='application/json')[0] == 401
+  code, _, headers = request('POST', '/api/auth/login', json.dumps({'password': 'password123'}), content_type='application/json')
+  assert code == 200
+  cookie = headers['Set-Cookie'].split(';', 1)[0]
+  assert new_setup.enabled()
+  state['parked'] = False
+  assert request('POST', '/api/starport/control', body, cookie=cookie, content_type='application/json')[0] == 403
+  assert new_setup.enabled()
+  state['parked'] = True
+  client.calls.clear()
+  code, result, _ = request('POST', '/api/starport/control', body, cookie=cookie, content_type='application/json')
+  assert (code, result) == (200, {'newSetup': False}) and not new_setup.enabled()
+  assert client.calls == []   # the daemon was never asked: this is the way back when it is down
+  assert request('GET', '/api/starport/setup', cookie=cookie)[1]['newSetup'] is False
+  code, result, _ = request('POST', '/api/starport/control', json.dumps({'action': 'new_setup', 'enabled': True}),
+                            cookie=cookie, content_type='application/json')
+  assert (code, result) == (200, {'newSetup': True}) and new_setup.enabled()
+  for bad in ({'action': 'new_setup'}, {'action': 'new_setup', 'enabled': 'no'}, {'action': 'new_setup', 'enabled': True, 'x': 1}):
+    assert request('POST', '/api/starport/control', json.dumps(bad), cookie=cookie, content_type='application/json')[0] == 400

From 0783710c9a18111e36a38c1a92cec9d75aca09b9 Mon Sep 17 00:00:00 2001
From: dirwin31 <83434411+dirwin31@users.noreply.github.com>
Date: Sun, 1 Nov 2026 14:16:16 -0800
Subject: [PATCH 15/38] Add the guided StarPort setup behind the New pairing
 experience switch

A card above the classic steps asks one question (how does the car connect:
built-in wireless, adapter, USB cable or app), shows only the instructions
for that answer, and lists paired cars that offer Android Auto to choose
between when there is more than one. While connecting it shows a live
checklist of the stages (Bluetooth, the car's Wi-Fi, securing the connection,
the dashboard), a list of the handshake options being tried once one has
failed or one is remembered, and a notice that the first connection can take
a few minutes or more than one drive. Every action is one the page already had.

The card is on by default; Use classic setup turns the switch off, and Try
the guided setup turns it back on. Returning drivers see the card only while
a connection is in progress. The state function is pure and tested without a
browser.
---
 .../galaxy/tests/test_starport_guided.mjs     | 134 ++++++++++++++++
 openpilot/starpilot/galaxy/web/css/galaxy.css |   4 +
 .../galaxy/web/js/starport-guided.js          | 149 ++++++++++++++++++
 openpilot/starpilot/galaxy/web/js/starport.js |  26 ++-
 4 files changed, 312 insertions(+), 1 deletion(-)
 create mode 100644 openpilot/starpilot/galaxy/tests/test_starport_guided.mjs
 create mode 100644 openpilot/starpilot/galaxy/web/js/starport-guided.js

diff --git a/openpilot/starpilot/galaxy/tests/test_starport_guided.mjs b/openpilot/starpilot/galaxy/tests/test_starport_guided.mjs
new file mode 100644
index 0000000000..d055fed73b
--- /dev/null
+++ b/openpilot/starpilot/galaxy/tests/test_starport_guided.mjs
@@ -0,0 +1,134 @@
+import assert from "node:assert/strict"
+import { StarPortFeed, StarPortPage } from "../web/js/starport.js"
+import { guidedState, connectionStages, handshakeSteps, StarPortGuidedSetup, FIRST_RUN_NOTICE, EXHAUSTED_NOTICE } from "../web/js/starport-guided.js"
+
+const setup = { identity: { installed: true } }
+const labels = { builtin: "Built-in wireless", adapter: "Wireless adapter", usb: "Wired AA", app: "App" }
+const ladder = (over = {}) => ({ steps: [{ id: "standard", label: "Standard handshake", state: "current" }, { id: "other_reply", label: "The other version reply", state: "waiting" }],
+  learned: false, passes: 0, max_passes: 3, exhausted: false, successes: 0, ...over })
+const running = (state, over = {}) => ({ running: true, state, connection: "wireless", setup_ladder: ladder(), ...over })
+
+// Before anything is known the card stays out of the way.
+assert.equal(guidedState({}).show, false)
+assert.equal(guidedState({ setup: null, runtime: running("rfcomm") }).show, false)
+
+// Without the Android Auto package the first thing to do is that step, nothing else.
+{
+  const state = guidedState({ setup: { identity: { installed: false } }, runtime: null, labels })
+  assert.equal(state.phase, "package")
+  assert.equal(state.show, true)
+  assert.deepEqual(state.choices, [])
+}
+
+// First run: one question, four answers, the current one marked, and only the steps for that answer.
+{
+  const state = guidedState({ setup, runtime: { running: false, state: "idle" }, carType: "builtin", labels })
+  assert.equal(state.phase, "setup")
+  assert.deepEqual(state.choices.map((choice) => choice.key), ["builtin", "adapter", "usb", "app"])
+  assert.deepEqual(state.choices.map((choice) => choice.selected), [true, false, false, false])
+  assert.equal(state.choices[1].label, "Wireless adapter")
+  assert.match(state.detail, /pairing screen/)
+  assert.match(guidedState({ setup, runtime: null, carType: "adapter", labels }).detail, /adapter in pairing mode/)
+  assert.match(guidedState({ setup, runtime: null, carType: "usb", labels }).detail, /USB data port/)
+  assert.match(guidedState({ setup, runtime: null, carType: "app", labels }).detail, /tablet/)
+}
+
+// Cars to choose between: paired, offering Android Auto, de-duplicated, never the selected one, not while pairing.
+{
+  const runtime = { running: false, state: "idle", car_candidates: [{ address: "AA:BB:CC:DD:EE:01", name: "Civic" }, { address: "AA:BB:CC:DD:EE:02", name: "Truck" }] }
+  const receivers = [{ address: "AA:BB:CC:DD:EE:02", name: "Truck" }, { address: "AA:BB:CC:DD:EE:03", name: "Wagon" }, null, { address: 5, name: "x" }]
+  const names = (state) => state.candidates.map((car) => car.name)
+  assert.deepEqual(names(guidedState({ setup, runtime, receivers, carType: "builtin" })), ["Civic", "Truck", "Wagon"])
+  assert.deepEqual(names(guidedState({ setup, runtime, receivers, carType: "builtin", selected: { address: "AA:BB:CC:DD:EE:01", name: "Civic" } })), ["Truck", "Wagon"])
+  assert.deepEqual(names(guidedState({ setup, runtime, receivers, carType: "builtin", pairingActive: true })), [])
+  assert.deepEqual(names(guidedState({ setup, runtime, receivers, carType: "usb" })), [])  // a cable has no cars to pair
+}
+
+// A finished setup shows nothing unless a connection is in progress.
+{
+  assert.equal(guidedState({ setup, runtime: { running: false, state: "idle" }, setupDone: true }).show, false)
+  assert.equal(guidedState({ setup, runtime: running("streaming"), setupDone: true }).show, false)
+  const state = guidedState({ setup, runtime: running("wifi_start"), setupDone: true, carType: "builtin" })
+  assert.equal(state.show, true)
+  assert.equal(state.phase, "connecting")
+}
+
+// The checklist follows the stage the daemon reports.
+{
+  const states = (runtime) => connectionStages(runtime).map((step) => step.state)
+  assert.deepEqual(states(running("connecting_bluetooth")), ["active", "waiting", "waiting", "waiting"])
+  assert.deepEqual(states(running("joining_wifi")), ["done", "active", "waiting", "waiting"])
+  assert.deepEqual(states(running("authenticating")), ["done", "done", "active", "waiting"])
+  assert.deepEqual(states(running("negotiating")), ["done", "done", "done", "active"])
+  assert.deepEqual(states(running("streaming")), ["done", "done", "done", "done"])
+  assert.deepEqual(states(running("backoff", { last_stage: "wifi_start" })), ["done", "retry", "waiting", "waiting"])
+  assert.deepEqual(states(running("backoff", {})), ["retry", "waiting", "waiting", "waiting"])
+  assert.deepEqual(connectionStages(running("waiting_for_usb", { connection: "wired" })).map((step) => step.id), ["cable", "secure", "dashboard"])
+  assert.deepEqual(connectionStages(running("waiting_for_ipad", { connection: "headunitpad" })).map((step) => step.id), ["app", "secure", "dashboard"])
+  assert.deepEqual(connectionStages(null).map((step) => step.state), ["active", "waiting", "waiting", "waiting"])
+}
+
+// The first-connection warning appears only to a wireless car with nothing learned, and not once it has worked.
+{
+  const first = guidedState({ setup, runtime: running("rfcomm"), carType: "builtin" })
+  assert.equal(first.notice, FIRST_RUN_NOTICE)
+  assert.equal(guidedState({ setup, runtime: running("rfcomm", { setup_ladder: ladder({ learned: true }) }) }).notice, "")
+  assert.equal(guidedState({ setup, runtime: running("rfcomm", { setup_ladder: ladder({ successes: 2 }) }) }).notice, "")
+  assert.equal(guidedState({ setup, runtime: running("waiting_for_usb", { connection: "wired" }) }).notice, "")
+  const exhausted = guidedState({ setup, runtime: running("backoff", { setup_ladder: ladder({ exhausted: true }) }) })
+  assert.equal(exhausted.notice, EXHAUSTED_NOTICE)
+  assert.equal(exhausted.exhausted, true)
+}
+
+// What is being tried is listed only once something was tried and failed, or one option is remembered.
+{
+  assert.deepEqual(handshakeSteps(ladder()), [])
+  assert.deepEqual(handshakeSteps(null), [])
+  const tried = ladder({ steps: [{ id: "standard", label: "Standard handshake", state: "failed" }, { id: "other_reply", label: "The other version reply", state: "current" }] })
+  assert.deepEqual(handshakeSteps(tried).map((step) => step.state), ["failed", "current"])
+  assert.equal(guidedState({ setup, runtime: running("wifi_start", { setup_ladder: tried }) }).handshake.length, 2)
+  assert.equal(handshakeSteps(ladder({ learned: true })).length, 2)
+  assert.deepEqual(handshakeSteps({ steps: [null, { label: 3 }, { id: "a", label: "A", state: "worked" }] }).map((step) => step.id), ["a"])
+}
+
+// The component emits the page's actions and never invents state.
+{
+  assert.deepEqual(StarPortGuidedSetup.emits, ["choose-type", "use-car", "classic"])
+  const template = StarPortGuidedSetup.template
+  assert.match(template, /\$emit\('choose-type', choice\.key\)/)
+  assert.match(template, /\$emit\('use-car', car\.address\)/)
+  assert.match(template, /\$emit\('classic'\)/)
+  assert.match(template, /Use classic setup/)
+  assert.doesNotMatch(template, /v-html/)
+}
+// The way back to the classic screens posts one narrow action, even when the StarPort service is off.
+{
+  const calls = []
+  const reply = (body, code = 200) => ({ status: code, ok: code < 300, json: async () => structuredClone(body) })
+  const feed = new StarPortFeed({ publish: () => {}, fetcher: async (path, options) => {
+    calls.push([path, options])
+    return reply(path.endsWith("/setup") ? { enabled: false, bluetoothEnabled: false, parked: true, installReady: true, serviceReady: false,
+      identity: { installed: true }, import: {}, maxUploadBytes: 1000, newSetup: true } : { newSetup: false })
+  }, later: () => 1, cancelTimer: () => {} })
+  assert.equal(await feed.setNewSetup(false), false)  // not started yet
+  feed.active = true
+  assert.equal(await feed.setNewSetup("no"), false)
+  assert.equal(await feed.setNewSetup(false), true)
+  const [path, options] = calls.find(([target]) => target.endsWith("/control"))
+  assert.equal(path, "./api/starport/control")
+  assert.deepEqual(JSON.parse(options.body), { action: "new_setup", enabled: false })
+  assert.equal(options.method, "POST")
+}
+
+// The page uses the guided card by default and only when the setup response does not say newSetup is off.
+{
+  const template = StarPortPage.template
+  assert.match(template, /<StarPortGuidedSetup v-if="setup && newSetup && guided\.show"/)
+  assert.match(template, /@choose-type="chooseType" @use-car="useCar" @classic="useClassic"/)
+  assert.match(template, /Try the guided setup/)
+  const vm = { setup: { newSetup: false } }
+  assert.equal(StarPortPage.computed.newSetup.call(vm), false)
+  assert.equal(StarPortPage.computed.newSetup.call({ setup: {} }), true)        // default on, including an older server
+  assert.equal(StarPortPage.computed.newSetup.call({ setup: null }), true)
+}
+console.log("StarPort guided setup: question, steps, candidates, live checklist, first-run notice and handshake list passed")
diff --git a/openpilot/starpilot/galaxy/web/css/galaxy.css b/openpilot/starpilot/galaxy/web/css/galaxy.css
index 42561ebe3c..9acb3f539f 100644
--- a/openpilot/starpilot/galaxy/web/css/galaxy.css
+++ b/openpilot/starpilot/galaxy/web/css/galaxy.css
@@ -1714,6 +1714,10 @@ input[type="checkbox"]:disabled { opacity: .4; cursor: not-allowed; }
 /* A section title inside a settings page: a label only, never dimmed like an unavailable control. */
 .gx-row.gx-row--heading, .gx-row.gx-row--heading.disabled { opacity: 1; padding-top: 1.25rem; }
 .gx-row--heading .gx-row__label { font-weight: 700; letter-spacing: .04em; text-transform: uppercase; opacity: .75; }
+/* Guided StarPort setup: the one question about how the car connects. */
+.gx-starport-guided__choices { display: grid; gap: .5rem; grid-template-columns: repeat(auto-fit, minmax(13rem, 1fr)); }
+.gx-starport-guided__choice { display: flex; flex-direction: column; align-items: flex-start; gap: .2rem; text-align: left; height: auto; padding: .7rem .9rem; }
+.gx-starport-guided__choice small { font-weight: 400; opacity: .75; white-space: normal; }
 .gx-row--wrap { flex-wrap: wrap; }
 .gx-row__info.gx-row__info--wide { flex: 1 1 180px; }
 .gx-filter-field { flex: 1 1 14rem; min-width: 0; }
diff --git a/openpilot/starpilot/galaxy/web/js/starport-guided.js b/openpilot/starpilot/galaxy/web/js/starport-guided.js
new file mode 100644
index 0000000000..70d1d0830c
--- /dev/null
+++ b/openpilot/starpilot/galaxy/web/js/starport-guided.js
@@ -0,0 +1,149 @@
+// The guided StarPort setup: one question (how does the car connect), only the steps for that answer, and a live checklist of
+// what is being tried while connecting. It reads the daemon status the page already has and drives the page's existing actions,
+// so it adds no new state of its own. Turned off, the classic screens come back ("Use classic setup").
+
+export const FIRST_RUN_NOTICE = "The first connection can take a few minutes, and sometimes more than one drive, while we find what your car accepts. Keep the car on and its screen awake. Later connections are much faster because we remember what worked."
+export const EXHAUSTED_NOTICE = "We tried every option we have this drive. We keep what works best and will try again the next time the car starts."
+
+const CHOICES = [
+  { key: "builtin", detail: "The car connects to Android Auto wirelessly by itself." },
+  { key: "adapter", detail: "A USB adapter such as AAWireless or Motorola MA1 plugged into the car." },
+  { key: "usb", detail: "A USB data cable from the car to the comma." },
+  { key: "app", detail: "An app on an iPad or Android tablet shows the dashboard." },
+]
+
+const INSTRUCTIONS = {
+  builtin: "Open your car’s phone pairing screen, then tap Find car in the pairing step below.",
+  adapter: "Put the adapter in pairing mode, choose its model below, then tap Find adapter.",
+  usb: "Connect the car’s Android Auto USB data port to the comma with a data cable, then tap Connect.",
+  app: "Choose your app below, open it on your tablet on the same Wi-Fi, then tap Connect.",
+}
+
+const STAGES = {
+  wireless: [
+    { id: "bluetooth", label: "Reach the car over Bluetooth", states: ["connecting_bluetooth", "discovering", "rfcomm"] },
+    { id: "wifi", label: "Join the car’s Wi-Fi", states: ["wifi_start", "wifi_info", "joining_wifi"] },
+    { id: "secure", label: "Secure the connection", states: ["connecting_tcp", "authenticating"] },
+    { id: "dashboard", label: "Bring up your dashboard", states: ["negotiating", "streaming", "suspended"] },
+  ],
+  wired: [
+    { id: "cable", label: "Wait for the USB cable", states: ["waiting_for_usb", "usb_accessory"] },
+    { id: "secure", label: "Secure the connection", states: ["connecting_tcp", "authenticating"] },
+    { id: "dashboard", label: "Bring up your dashboard", states: ["negotiating", "streaming", "suspended"] },
+  ],
+  app: [
+    { id: "app", label: "Wait for your app", states: ["waiting_for_ipad", "waiting_for_tablet"] },
+    { id: "secure", label: "Secure the connection", states: ["connecting_tcp", "authenticating"] },
+    { id: "dashboard", label: "Bring up your dashboard", states: ["negotiating", "streaming", "suspended"] },
+  ],
+}
+
+const CONNECTING = new Set(["connecting_bluetooth", "discovering", "rfcomm", "wifi_start", "wifi_info", "joining_wifi", "connecting_tcp",
+  "authenticating", "negotiating", "waiting_for_usb", "usb_accessory", "waiting_for_ipad", "waiting_for_tablet", "backoff"])
+
+export function connectionStages(runtime) {
+  const kind = runtime?.connection === "wired" ? "wired" : ["headunitpad", "openheadunit"].includes(runtime?.connection) ? "app" : "wireless"
+  const stages = STAGES[kind]
+  // While retrying the state is "backoff"; the stage that failed is the one to show as still working.
+  const at = runtime?.state === "backoff" ? runtime.last_stage : runtime?.state
+  const current = Math.max(0, stages.findIndex((stage) => stage.states.includes(at)))
+  const live = runtime?.state === "streaming"
+  return stages.map((stage, index) => ({
+    id: stage.id, label: stage.label,
+    state: live || index < current ? "done" : index === current ? (runtime?.state === "backoff" ? "retry" : "active") : "waiting",
+  }))
+}
+
+// Only worth showing once a handshake option has been tried and failed, or one is remembered for this car.
+export function handshakeSteps(ladder) {
+  const steps = Array.isArray(ladder?.steps) ? ladder.steps.filter((step) => step && typeof step.label === "string") : []
+  const interesting = ladder?.learned || steps.some((step) => step.state === "failed" || step.state === "worked")
+  return interesting ? steps.map((step) => ({ id: String(step.id), label: step.label, state: String(step.state) })) : []
+}
+
+export function guidedState({ setup = null, runtime = null, selected = null, receivers = [], wired = false, app = "", carType = "builtin",
+  setupDone = false, pairingActive = false, labels = {} } = {}) {
+  const ladder = runtime?.setup_ladder || null
+  const state = runtime?.state || "idle"
+  const connecting = !!runtime?.running && CONNECTING.has(state)
+  const installed = !!setup?.identity?.installed
+  const base = { show: false, phase: "live", title: "", detail: "", choices: [], carType, candidates: [], progress: [], handshake: [],
+    notice: "", exhausted: false }
+  if (setup === null) return base
+  if (connecting) {
+    const firstRun = !ladder?.learned && !(ladder?.successes > 0) && (runtime?.connection || "wireless") === "wireless"
+    return { ...base, show: true, phase: "connecting", title: runtime?.label || "Connecting to your car",
+      detail: runtime?.detail || "Keep your car’s screen on. We’ll move to the next step automatically.",
+      progress: connectionStages(runtime), handshake: handshakeSteps(ladder), exhausted: !!ladder?.exhausted,
+      notice: ladder?.exhausted ? EXHAUSTED_NOTICE : firstRun ? FIRST_RUN_NOTICE : "" }
+  }
+  if (setupDone) return base
+  if (!installed) {
+    return { ...base, show: true, phase: "package", title: "Start by adding your Android Auto package",
+      detail: "Your car only talks to devices that present Google’s Android Auto certificate. Follow step 1 below, then come back here." }
+  }
+  const choices = CHOICES.map((choice) => ({ ...choice, label: labels[choice.key] || choice.key, selected: choice.key === carType }))
+  const known = new Set(selected ? [selected.address] : [])
+  const candidates = []
+  for (const car of [...(Array.isArray(runtime?.car_candidates) ? runtime.car_candidates : []), ...(Array.isArray(receivers) ? receivers : [])]) {
+    if (car && typeof car.address === "string" && typeof car.name === "string" && !known.has(car.address)) {
+      known.add(car.address)
+      candidates.push({ address: car.address, name: car.name })
+    }
+  }
+  const pairs = carType === "builtin" || carType === "adapter"
+  return { ...base, show: true, phase: "setup", title: "How does your car connect to Android Auto?",
+    detail: INSTRUCTIONS[carType] || INSTRUCTIONS.builtin, choices, candidates: pairs && !pairingActive ? candidates : [] }
+}
+
+export const StarPortGuidedSetup = {
+  props: { state: { type: Object, required: true }, busy: { type: Boolean, default: false } },
+  emits: ["choose-type", "use-car", "classic"],
+  template: `
+    <section class="gx-card gx-starport-guided" aria-label="Guided StarPort setup">
+      <div class="gx-starport-step__head">
+        <div><h3>{{ state.title }}</h3><p>{{ state.detail }}</p></div>
+      </div>
+      <div class="gx-starport-step__body">
+        <div v-if="state.choices.length" class="gx-starport-guided__choices" role="radiogroup" aria-label="How your car connects">
+          <button v-for="choice in state.choices" :key="choice.key" type="button" class="gx-btn gx-starport-guided__choice"
+              :class="choice.selected ? 'gx-btn--primary' : 'gx-btn--tonal'" role="radio" :aria-checked="choice.selected ? 'true' : 'false'"
+              :disabled="busy" @click="$emit('choose-type', choice.key)">
+            <strong>{{ choice.label }}</strong><small>{{ choice.detail }}</small>
+          </button>
+        </div>
+        <ul v-if="state.candidates.length" class="gx-starport-list" aria-label="Paired cars that offer Android Auto">
+          <li v-for="car in state.candidates" :key="car.address" class="gx-starport-row">
+            <i class="bi bi-car-front" aria-hidden="true"></i>
+            <span class="gx-starport-row__text"><strong>{{ car.name }}</strong><small>Paired and offers Android Auto</small></span>
+            <button type="button" class="gx-btn gx-btn--tonal" :disabled="busy" @click="$emit('use-car', car.address)">Use</button>
+          </li>
+        </ul>
+        <ol v-if="state.progress.length" class="gx-starport-list" aria-label="Connection progress">
+          <li v-for="step in state.progress" :key="step.id" class="gx-starport-row" :class="'gx-starport-row--' + step.state"
+              :aria-current="step.state === 'active' || step.state === 'retry' ? 'step' : undefined">
+            <i v-if="step.state === 'done'" class="bi bi-check-circle-fill gx-starport-ok" aria-hidden="true"></i>
+            <span v-else-if="step.state === 'active'" class="gx-spinner gx-starport-orbit gx-starport-orbit--small" aria-hidden="true"></span>
+            <i v-else-if="step.state === 'retry'" class="bi bi-arrow-repeat" aria-hidden="true"></i>
+            <i v-else class="bi bi-circle" aria-hidden="true"></i>
+            <span class="gx-starport-row__text"><strong>{{ step.label }}</strong><small v-if="step.state === 'retry'">Trying again</small></span>
+          </li>
+        </ol>
+        <details v-if="state.handshake.length" class="gx-starport-wiki" open>
+          <summary>What we are trying</summary>
+          <ol class="gx-starport-list" aria-label="Handshake options">
+            <li v-for="step in state.handshake" :key="step.id" class="gx-starport-row" :class="'gx-starport-row--' + step.state">
+              <i v-if="step.state === 'worked'" class="bi bi-check-circle-fill gx-starport-ok" aria-hidden="true"></i>
+              <i v-else-if="step.state === 'failed'" class="bi bi-x-circle" aria-hidden="true"></i>
+              <i v-else-if="step.state === 'skipped'" class="bi bi-dash-circle" aria-hidden="true"></i>
+              <span v-else-if="step.state === 'current'" class="gx-spinner gx-starport-orbit gx-starport-orbit--small" aria-hidden="true"></span>
+              <i v-else class="bi bi-circle" aria-hidden="true"></i>
+              <span class="gx-starport-row__text"><strong>{{ step.label }}</strong></span>
+            </li>
+          </ol>
+        </details>
+        <p v-if="state.notice" class="gx-note" role="status">{{ state.notice }}</p>
+        <button type="button" class="gx-btn gx-btn--tonal" :disabled="busy" @click="$emit('classic')">Use classic setup</button>
+      </div>
+    </section>`,
+}
diff --git a/openpilot/starpilot/galaxy/web/js/starport.js b/openpilot/starpilot/galaxy/web/js/starport.js
index 37a0f25f3b..c357e4249d 100644
--- a/openpilot/starpilot/galaxy/web/js/starport.js
+++ b/openpilot/starpilot/galaxy/web/js/starport.js
@@ -7,6 +7,7 @@ import { connectionError } from "./polling.js"
 import { BluetoothDeviceList } from "./bluetooth-devices.js"
 import { BluetoothNotice, bluetoothConnection } from "./bluetooth-notice.js"
 import { GalaxySettingRow, switchRow } from "./galaxy-setting-row.js"
+import { StarPortGuidedSetup, guidedState } from "./starport-guided.js"
 
 export function uploadTimeout(bytes) {
   return Math.max(180000, Math.ceil(bytes / (64 * 1024)) * 1000)
@@ -319,6 +320,18 @@ export class StarPortFeed {
     return true
   }
 
+  // The guided setup's way back to the classic screens (and back). It never needs the StarPort service, so it is not a control().
+  async setNewSetup(enabled) {
+    if (!this.active || this.busy || typeof enabled !== "boolean") return false
+    const result = await this.request("./api/starport/control", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" }, body: JSON.stringify({ action: "new_setup", enabled })
+    })
+    if (result === null) return false
+    await this.refresh()
+    return true
+  }
+
   async setEnabled(enabled, enableBluetooth = false) {
     if (!this.active || this.busy || typeof enabled !== "boolean" ||
       typeof enableBluetooth !== "boolean" || enableBluetooth && !enabled || enabled && !this.setup?.installReady) return false
@@ -481,7 +494,7 @@ export function connectionProgress(runtime, { wired = false, app = "", selected
 }
 
 export const StarPortPage = {
-  components: { GxState, GxIconButton, GxNotice, BluetoothNotice, GxDialog, GalaxySettingRow },
+  components: { GxState, GxIconButton, GxNotice, BluetoothNotice, GxDialog, GalaxySettingRow, StarPortGuidedSetup },
   props: {
     mode: { type: String, required: true }, localAccess: { type: Boolean, required: true },
     unauthorized: { type: Function, required: true }
@@ -541,6 +554,11 @@ export const StarPortPage = {
       return !!(this.supportReady && (this.selected || this.wired || this.app) && !this.pairing?.active &&
         !(this.adapterSetup && this.runtime?.car_profile_source !== "override"))
     },
+    newSetup() { return this.setup?.newSetup !== false },
+    guided() {
+      return guidedState({ setup: this.setup, runtime: this.runtime, selected: this.selected, receivers: this.receivers, wired: this.wired,
+        app: this.app, carType: this.carType, setupDone: this.setupDone, pairingActive: !!this.pairing?.active, labels: this.carTypeLabels })
+    },
     wiredStatus() {
       if (this.runtime?.wired_blocked) return { tone: "expired", label: "Wired StarPort not enabled", detail: this.runtime.wired_blocked }
       if (this.wiredJetlinkBusy) return { tone: "expired", label: "Wired StarPort not enabled", detail: "JetLink is using the USB-C port. Turn off JetLink, then return here." }
@@ -676,6 +694,9 @@ export const StarPortPage = {
       return stopping ? stopping.then((stopped) => stopped && next()) : next()
     },
     useCar(address) { return this.afterWaiting(() => this.control("select_receiver", { address })) },
+    chooseType(key) { return this.saveCarType(0, this.carTypeLabels[key]) },
+    useClassic() { return this.feed.setNewSetup(false) },
+    useGuided() { return this.feed.setNewSetup(true) },
     saveCarType(index, value) {
       const labels = this.carTypeLabels
       const carType = Object.keys(labels).find(key => labels[key] === value)
@@ -853,6 +874,9 @@ export const StarPortPage = {
             </details>
           </div>
         </section>
+      <StarPortGuidedSetup v-if="setup && newSetup && guided.show" :state="guided" :busy="busy"
+        @choose-type="chooseType" @use-car="useCar" @classic="useClassic" />
+      <p v-else-if="setup && !newSetup && !setupDone" class="gx-note"><button type="button" class="gx-btn gx-btn--tonal" :disabled="busy" @click="useGuided">Try the guided setup</button></p>
       <ol v-if="setup" id="gx-starport-steps" class="gx-starport__steps">
         <li v-show="!setupDone || showSteps" class="gx-card gx-starport-step" :class="{ 'gx-starport-step--done': !!selected && !pairing?.active }">
           <div class="gx-starport-step__head">

From 99a9025afe397a7922f657bca8a4ecb9b1fc5ae4 Mon Sep 17 00:00:00 2001
From: dirwin31 <83434411+dirwin31@users.noreply.github.com>
Date: Sun, 1 Nov 2026 14:18:06 -0800
Subject: [PATCH 16/38] Report how the channel was found and what the ladder
 tried; wait longer for a slow car

Reports carry the SDP outcome (where the RFCOMM channel came from and how
many retries it took). The Discord post names the handshake options tried
and how each ended. A car that once needed 70 s to be ready now gets that
many stage timeouts to answer the Wi-Fi handshake, never fewer than the
standard wait and capped at nine.
---
 openpilot/starpilot/galaxy/starport_send.py       | 15 ++++++++++++++-
 .../starpilot/galaxy/tests/test_starport_send.py  |  1 +
 .../starpilot/system/starport/bugsink_report.py   | 12 ++++++++++++
 .../starpilot/system/starport/setup_ladder.py     |  8 ++++++++
 openpilot/starpilot/system/starport/supervisor.py |  4 +++-
 .../system/starport/tests/test_bugsink_report.py  |  8 ++++++++
 .../system/starport/tests/test_setup_ladder.py    | 10 ++++++++++
 7 files changed, 56 insertions(+), 2 deletions(-)

diff --git a/openpilot/starpilot/galaxy/starport_send.py b/openpilot/starpilot/galaxy/starport_send.py
index 52ad1e0371..fc1045dbe4 100644
--- a/openpilot/starpilot/galaxy/starport_send.py
+++ b/openpilot/starpilot/galaxy/starport_send.py
@@ -104,10 +104,22 @@ def _setup(log_dir: Path | None, logs_to_check: int = 3) -> str:
   return ""
 
 
+def _handshake(log_dir: Path | None, logs_to_check: int = 3) -> str:
+  """What the setup ladder tried in the newest log that recorded it, e.g. "standard (advanced) > other_reply (worked)"."""
+  from openpilot.starpilot.system.starport import compat_report
+  from openpilot.starpilot.system.starport.bugsink_report import session_ladder
+  for path in compat_report.session_logs(log_dir or identity_store.LOG_DIR)[:logs_to_check]:
+    tried = session_ladder(compat_report.load_events(path))
+    if tried:
+      return " > ".join(f"{item['rung']}{' learned' if item.get('learned') else ''} ({item.get('outcome', 'tried')})" for item in tried[-6:])
+  return ""
+
+
 def device_summary(log_dir: Path | None = None) -> dict:
   from openpilot.starpilot.system.starport.bugsink_transport import device_metadata
   summary = device_metadata()
-  for key, read in (("car_fingerprint", _car_fingerprint), ("head_unit", lambda: _head_unit(log_dir)), ("setup", lambda: _setup(log_dir))):
+  for key, read in (("car_fingerprint", _car_fingerprint), ("head_unit", lambda: _head_unit(log_dir)), ("setup", lambda: _setup(log_dir)),
+                    ("handshake", lambda: _handshake(log_dir))):
     try:
       summary[key] = read()
     except Exception as error:
@@ -163,6 +175,7 @@ def send(data: bytes, name: str, note: str, summary: dict, url: str | None = Non
            f"Car: {summary.get('car_fingerprint') or 'unknown'}",
            f"Head unit: {summary.get('head_unit') or 'unknown'}",
            f"Setup: {summary.get('setup') or 'unknown'}",
+           f"Handshake: {summary.get('handshake') or 'unknown'}",
            f"Branch {summary.get('branch', '?')} @ {str(summary.get('commit', '?'))[:10]}",
            f"Note: {note.strip() or '(none)'}"]
   payload = {"content": "\n".join(lines)[:1900], "username": "StarPilot diagnostics", "allowed_mentions": {"parse": []}}
diff --git a/openpilot/starpilot/galaxy/tests/test_starport_send.py b/openpilot/starpilot/galaxy/tests/test_starport_send.py
index 8a24310d8a..59e086efee 100644
--- a/openpilot/starpilot/galaxy/tests/test_starport_send.py
+++ b/openpilot/starpilot/galaxy/tests/test_starport_send.py
@@ -61,6 +61,7 @@ class SendTest(unittest.TestCase):
     self.assertIn("Note: Dropped at the light", call["payload"]["content"])
     self.assertIn("Head unit: Honda Display Audio", call["payload"]["content"])
     self.assertIn("Setup: unknown", call["payload"]["content"])  # no session log recorded a setup in this fixture
+    self.assertIn("Handshake: unknown", call["payload"]["content"])
     self.assertNotIn(SUMMARY["device_id"], call["payload"]["content"])
     self.assertEqual(query(call), {"wait": "true"})
     self.assertEqual(call["files"]["files[0]"], ("logs.zip", b"zip", "application/zip"))
diff --git a/openpilot/starpilot/system/starport/bugsink_report.py b/openpilot/starpilot/system/starport/bugsink_report.py
index 40d0d6e967..c859969afa 100644
--- a/openpilot/starpilot/system/starport/bugsink_report.py
+++ b/openpilot/starpilot/system/starport/bugsink_report.py
@@ -190,6 +190,17 @@ def offered_modes(events: list[dict]) -> list[str]:
   return modes[:MAX_OFFERED_MODES]
 
 
+def session_sdp(events: list[dict]) -> dict:
+  """How the car's Android Auto RFCOMM channel was found: where it came from, and how many SDP retries it took."""
+  found = next((event for event in events if event["event"] == "rfcomm_channel"), {})
+  retries = sum(1 for event in events if event["event"] == "sdp_retry")
+  if not found and not retries:
+    return {}
+  return {key: value for key, value in (("channel", found.get("channel") if isinstance(found.get("channel"), int) else None),
+                                         ("source", str(found["source"])[:12] if found.get("source") else None),
+                                         ("retries", retries or None)) if value is not None}
+
+
 def session_setup(events: list[dict]) -> dict:
   """The setup type and profile the owner chose, as recorded when the session started."""
   start = next((event for event in events if event["event"] == "session_start"), {})
@@ -265,6 +276,7 @@ def session_record(path: Path) -> dict:
     "phone_address_sent": bool(opened.get("phone_address")) if opened is not None else None,
     "strategy": session_strategy(events, setup),
     "ladder": session_ladder(events),
+    "sdp": session_sdp(events),
     "software": {key: str(software.get(key) or "unknown") for key in ("commit", "branch")} if isinstance(software, dict) else {},
     "settings": settings if isinstance(settings, dict) else {},
     "seq": _session_number(path),
diff --git a/openpilot/starpilot/system/starport/setup_ladder.py b/openpilot/starpilot/system/starport/setup_ladder.py
index cb68e094c6..49f696f7dc 100644
--- a/openpilot/starpilot/system/starport/setup_ladder.py
+++ b/openpilot/starpilot/system/starport/setup_ladder.py
@@ -239,6 +239,14 @@ class SetupLadder:
       entry["t_ready"] = (entry["t_ready"] + [round(float(t_ready_s), 1)])[-8:]
     self.save()
 
+  def ready_patience(self, address: str, stage_timeout: float = 20.0) -> int:
+    """Stage timeouts a slow car needs: it was ready after t_ready_s once, so the bootstrap must be willing to wait that long.
+
+    Never less than the standard patience, and 0 (no opinion) for a car nothing is known about."""
+    entry = self.cars.get(address.upper())
+    times = entry["t_ready"] if entry else []
+    return min(9, int(-(-max(times) // stage_timeout))) if times else 0
+
   def snapshot(self, address: str, adapter: bool = False) -> dict:
     """What the setup screen and the reports show: every rung, its state, and whether this car has a learned strategy."""
     entry = self.cars.get(address.upper()) if address else None
diff --git a/openpilot/starpilot/system/starport/supervisor.py b/openpilot/starpilot/system/starport/supervisor.py
index 1e559175d5..7089f827ae 100644
--- a/openpilot/starpilot/system/starport/supervisor.py
+++ b/openpilot/starpilot/system/starport/supervisor.py
@@ -1341,7 +1341,9 @@ class Supervisor:
       boot = WirelessBootstrap(rfcomm, self._bootstrap_log, device_serial=config["device_name"],
                                version_status=int(config.get("version_status", 0)),
                                experiment="all" if car_profiles.tuning(config)["bootstrap_experiments"] or strategy.experiments else "",
-                               modern_reply=strategy.modern_reply, patience=strategy.patience, channel_override=strategy.channel_type)
+                               modern_reply=strategy.modern_reply, channel_override=strategy.channel_type,
+                               # a car that once took 70 s to be ready gets more than the standard wait for the Wi-Fi handshake
+                               patience=max(strategy.patience, self._ladder.ready_patience(address, 20.0)))
       self._set(state="wifi_start")
       result = boot.run(lambda credentials: lease.acquire(credentials, cancelled=boot.join_is_cancelled), cancelled=self._stop.is_set)
     except Exception as error:
diff --git a/openpilot/starpilot/system/starport/tests/test_bugsink_report.py b/openpilot/starpilot/system/starport/tests/test_bugsink_report.py
index 2e300c8974..8f59569e23 100644
--- a/openpilot/starpilot/system/starport/tests/test_bugsink_report.py
+++ b/openpilot/starpilot/system/starport/tests/test_bugsink_report.py
@@ -506,3 +506,11 @@ def test_report_shows_what_the_ladder_tried_and_what_worked(tmp_path):
   tags = br.drive_event([record])["tags"]
   assert (tags["aa.ladder_rung"], tags["aa.ladder_learned"]) == ("other_reply", "no")
   assert br.session_record(write_session(tmp_path, 2, STREAMED))["ladder"] == []   # older logs report nothing, without error
+
+
+def test_report_says_how_the_rfcomm_channel_was_found(tmp_path):
+  events = [list(item) for item in STREAMED]
+  events.insert(1, (0, 1, "sdp_retry", {"error": "x"}))
+  events.insert(2, (0, 2, "rfcomm_channel", {"channel": 8, "source": "sdp"}))
+  assert br.session_record(write_session(tmp_path, 1, events))["sdp"] == {"channel": 8, "source": "sdp", "retries": 1}
+  assert br.session_record(write_session(tmp_path, 2, STREAMED))["sdp"] == {}
diff --git a/openpilot/starpilot/system/starport/tests/test_setup_ladder.py b/openpilot/starpilot/system/starport/tests/test_setup_ladder.py
index be0826f4b8..1ba7e0f6e0 100644
--- a/openpilot/starpilot/system/starport/tests/test_setup_ladder.py
+++ b/openpilot/starpilot/system/starport/tests/test_setup_ladder.py
@@ -211,3 +211,13 @@ def test_forgetting_a_car_forgets_what_was_learned_about_it(sup):
   sup._ladder.worked(RECEIVER, sl.resolve("patient", False), 10.0)
   assert sup.forget_receiver(RECEIVER) is True
   assert not sup._ladder.snapshot(RECEIVER)["learned"] and RECEIVER not in sup._ladder.cars
+
+
+def test_a_slow_car_gets_the_patience_it_once_needed_and_an_unknown_car_gets_no_opinion(ladder):
+  assert ladder.ready_patience(CAR) == 0
+  ladder.worked(CAR, sl.resolve("standard", False), 14.0)
+  assert ladder.ready_patience(CAR) == 1
+  ladder.worked(CAR, sl.resolve("standard", False), 70.0)
+  assert ladder.ready_patience(CAR) == 4   # 70 s at 20 s per stage timeout
+  ladder.worked(CAR, sl.resolve("standard", False), 3000.0)
+  assert ladder.ready_patience(CAR) == 9   # capped

From 54eab0df8d8c8046b3c7e44105885e650eae6d4d Mon Sep 17 00:00:00 2001
From: dirwin31 <83434411+dirwin31@users.noreply.github.com>
Date: Sun, 1 Nov 2026 14:19:56 -0800
Subject: [PATCH 17/38] Replay the real Bugsink failure texts through the
 reachability classifier; tag the reply style

The 686 pre-video failures Bugsink showed (54 distinct texts) are kept as a
fixture. The test checks the intended class for each: Host is down and page
timeouts are a sleeping car, refused and unanswered handshakes are not ready,
and anything after the link is up is not a reachability problem. Reports tag
the reply style and Wi-Fi band the working strategy used.
---
 .../system/starport/bugsink_report.py         |   3 +
 .../tests/fixtures/bugsink_failure_texts.json | 329 ++++++++++++++++++
 .../starport/tests/test_bugsink_report.py     |   1 +
 .../starport/tests/test_reachability.py       |  23 ++
 4 files changed, 356 insertions(+)
 create mode 100644 openpilot/starpilot/system/starport/tests/fixtures/bugsink_failure_texts.json

diff --git a/openpilot/starpilot/system/starport/bugsink_report.py b/openpilot/starpilot/system/starport/bugsink_report.py
index c859969afa..c174225fc5 100644
--- a/openpilot/starpilot/system/starport/bugsink_report.py
+++ b/openpilot/starpilot/system/starport/bugsink_report.py
@@ -494,6 +494,7 @@ def drive_event(sessions: list[dict]) -> dict:
   setup = next((s["setup"] for s in reversed(sessions) if s.get("setup")), {})
   sent = next((s["phone_address_sent"] for s in reversed(sessions) if s.get("phone_address_sent") is not None), None)
   ladder = next((s["ladder"][-1] for s in reversed(sessions) if s.get("ladder")), {})
+  strategy = next((s["strategy"] for s in reversed(sessions) if s.get("strategy")), {})
   failures = [failure_detail(failure) for failure in drive_failures(sessions)]
   failed = [session for session in sessions if session["seq"] in {failure["session"] for failure in failures}]
   heading = "failures" if failures else "sessions"
@@ -529,6 +530,8 @@ def drive_event(sessions: list[dict]) -> dict:
              **({"aa.adapter_model": setup["profile"]} if setup.get("profile") else {}),
              **({"aa.profile_source": setup["profile_source"]} if setup.get("profile_source") else {}),
              **({"aa.phone_address_sent": "yes" if sent else "no"} if sent is not None else {}),
+             **({"aa.reply_style": strategy["reply_style"]} if strategy.get("reply_style") else {}),
+             **({"aa.wifi_channel_type": str(strategy["channel_type"])} if strategy.get("channel_type") else {}),
              **({"aa.ladder_rung": ladder["rung"], "aa.ladder_learned": "yes" if ladder.get("learned") else "no"} if ladder else {}),
              **({"aa.attention": ",".join(reasons)[:190]} if reasons else {}),
              **({"aa.cause": latest["cause"], "aa.stage": latest["stage"], "aa.error_kind": latest["error_kind"]} if latest else {}),
diff --git a/openpilot/starpilot/system/starport/tests/fixtures/bugsink_failure_texts.json b/openpilot/starpilot/system/starport/tests/fixtures/bugsink_failure_texts.json
new file mode 100644
index 0000000000..c562ddba95
--- /dev/null
+++ b/openpilot/starpilot/system/starport/tests/fixtures/bugsink_failure_texts.json
@@ -0,0 +1,329 @@
+{
+ "source": "Bugsink Android Auto project, failure reports pulled 2026-11-01 (sanitized by the reporter)",
+ "failures": [
+  {
+   "stage": "discovering",
+   "kind": "RuntimeError",
+   "evidence": "Could not find the car's Android Auto service: [Errno 112] Host is down",
+   "count": 116
+  },
+  {
+   "stage": "wifi_start",
+   "kind": "BootstrapTimeout",
+   "evidence": "wifi_start: head unit did not answer in time",
+   "count": 59
+  },
+  {
+   "stage": "rfcomm",
+   "kind": "ConnectionResetError",
+   "evidence": "[Errno 104] Connection reset by peer",
+   "count": 53
+  },
+  {
+   "stage": "streaming",
+   "kind": "TimeoutError",
+   "evidence": "Video acknowledgement older than 2.5 s",
+   "count": 41
+  },
+  {
+   "stage": "streaming",
+   "kind": "TimeoutError",
+   "evidence": "Head unit stopped answering for 15 s",
+   "count": 37
+  },
+  {
+   "stage": "connecting_bluetooth",
+   "kind": "RuntimeError",
+   "evidence": "org.bluez.Error.Failed: br-connection-page-timeout",
+   "count": 36
+  },
+  {
+   "stage": "rfcomm",
+   "kind": "OSError",
+   "evidence": "[Errno 112] Host is down",
+   "count": 35
+  },
+  {
+   "stage": "rfcomm",
+   "kind": "ConnectionRefusedError",
+   "evidence": "[Errno 111] Connection refused",
+   "count": 35
+  },
+  {
+   "stage": "connecting_bluetooth",
+   "kind": "TimeoutError",
+   "evidence": "TimeoutError",
+   "count": 27
+  },
+  {
+   "stage": "connecting_bluetooth",
+   "kind": "RuntimeError",
+   "evidence": "Connect your paired car in Galaxy Bluetooth first to select it for this Android Auto adapter",
+   "count": 20
+  },
+  {
+   "stage": "streaming",
+   "kind": "EOFError",
+   "evidence": "Head unit disconnected after 0/4 bytes",
+   "count": 18
+  },
+  {
+   "stage": "wifi_info",
+   "kind": "ConnectionResetError",
+   "evidence": "getting car wi-fi: [Errno 104] Connection reset by peer",
+   "count": 18
+  },
+  {
+   "stage": "joining_wifi",
+   "kind": "BootstrapError",
+   "evidence": "joining car wi-fi: joining_wifi: AddAndActivateConnection2 failed: Connection 'starpilot-android-auto' is not available on device wlan0 because device is strictly unmanaged",
+   "count": 14
+  },
+  {
+   "stage": "authenticating",
+   "kind": "EOFError",
+   "evidence": "Head unit disconnected after 0/4 bytes",
+   "count": 14
+  },
+  {
+   "stage": "discovering",
+   "kind": "RuntimeError",
+   "evidence": "Could not find the car's Android Auto service: [Errno 111] Connection refused",
+   "count": 13
+  },
+  {
+   "stage": "rfcomm",
+   "kind": "TimeoutError",
+   "evidence": "timed out",
+   "count": 12
+  },
+  {
+   "stage": "wifi_info",
+   "kind": "BootstrapTimeout",
+   "evidence": "getting car wi-fi: wifi_info: head unit did not answer in time",
+   "count": 11
+  },
+  {
+   "stage": "authenticating",
+   "kind": "TimeoutError",
+   "evidence": "timed out",
+   "count": 10
+  },
+  {
+   "stage": "rfcomm",
+   "kind": "OSError",
+   "evidence": "[Errno 16] Device or resource busy",
+   "count": 10
+  },
+  {
+   "stage": "negotiating",
+   "kind": "TimeoutError",
+   "evidence": "timed out",
+   "count": 10
+  },
+  {
+   "stage": "joining_wifi",
+   "kind": "BootstrapError",
+   "evidence": "joining car wi-fi: joining_wifi: ",
+   "count": 6
+  },
+  {
+   "stage": "discovering",
+   "kind": "RuntimeError",
+   "evidence": "Could not find the car's Android Auto service: Head unit does not advertise Android Auto Wireless (SDP record missing)",
+   "count": 6
+  },
+  {
+   "stage": "joining_wifi",
+   "kind": "BootstrapError",
+   "evidence": "joining car wi-fi: joining_wifi: The projection network connection was removed (wrong key or out of range?)",
+   "count": 5
+  },
+  {
+   "stage": "negotiating",
+   "kind": "EOFError",
+   "evidence": "Head unit disconnected after 0/4 bytes",
+   "count": 5
+  },
+  {
+   "stage": "streaming",
+   "kind": "ConnectionResetError",
+   "evidence": "[Errno 104] Connection reset by peer",
+   "count": 5
+  },
+  {
+   "stage": "rfcomm",
+   "kind": "OSError",
+   "evidence": "[Errno 38] Function not implemented",
+   "count": 5
+  },
+  {
+   "stage": "discovering",
+   "kind": "RuntimeError",
+   "evidence": "Could not find the car's Android Auto service: timed out",
+   "count": 5
+  },
+  {
+   "stage": "connecting_tcp",
+   "kind": "RuntimeError",
+   "evidence": "Car did not accept the projection connection: [Errno 111] Connection refused",
+   "count": 5
+  },
+  {
+   "stage": "joining_wifi",
+   "kind": "BootstrapError",
+   "evidence": "joining car wi-fi: joining_wifi: AddAndActivateConnection2 failed: Connection 'starpilot-starport' is not available on device wlan0 because device is strictly unmanaged",
+   "count": 5
+  },
+  {
+   "stage": "negotiating",
+   "kind": "ValueError",
+   "evidence": "Head unit did not advertise a supported H.264 video mode (offered 1440x2560 H.265 margins 288x1378, 1080x1920 H.265 margins 0x811, 720x1280 H.265 margins 0x541, 1920x1080 H.265 margins 0x360 (display 1))",
+   "count": 4
+  },
+  {
+   "stage": "streaming",
+   "kind": "NativeFocusHeld",
+   "evidence": "Car kept its own screen for 15 s; reconnecting",
+   "count": 4
+  },
+  {
+   "stage": "discovering",
+   "kind": "RuntimeError",
+   "evidence": "Could not find the car's Android Auto service: [Errno 104] Connection reset by peer",
+   "count": 3
+  },
+  {
+   "stage": "connecting_bluetooth",
+   "kind": "RuntimeError",
+   "evidence": "org.bluez.Error.Failed: br-connection-unknown",
+   "count": 3
+  },
+  {
+   "stage": "connecting_bluetooth",
+   "kind": "BluetoothRejected",
+   "evidence": "Bluetooth adapter is busy in another process",
+   "count": 3
+  },
+  {
+   "stage": "negotiating",
+   "kind": "ValueError",
+   "evidence": "Hardware encoder supports even sizes up to 1280x720 at 30 fps",
+   "count": 3
+  },
+  {
+   "stage": "rfcomm",
+   "kind": "TimeoutError",
+   "evidence": "[Errno 110] Connection timed out",
+   "count": 3
+  },
+  {
+   "stage": "connecting_tcp",
+   "kind": "RuntimeError",
+   "evidence": "Car did not accept the projection connection: [Errno 99] Cannot assign requested address",
+   "count": 2
+  },
+  {
+   "stage": "discovering",
+   "kind": "RuntimeError",
+   "evidence": "Could not find the car's Android Auto service: [Errno 114] Operation already in progress",
+   "count": 2
+  },
+  {
+   "stage": "authenticating",
+   "kind": "ValueError",
+   "evidence": "Expected authentication status; got 0/0x3",
+   "count": 2
+  },
+  {
+   "stage": "waiting_for_usb",
+   "kind": "RuntimeError",
+   "evidence": "plug into the car's usb: The car did not finish USB setup. Use its Android Auto data port and a data-capable cable",
+   "count": 2
+  },
+  {
+   "stage": "streaming",
+   "kind": "TimeoutError",
+   "evidence": "timed out",
+   "count": 2
+  },
+  {
+   "stage": "discovering",
+   "kind": "RuntimeError",
+   "evidence": "Could not find the car's Android Auto service: [Errno 38] Function not implemented",
+   "count": 2
+  },
+  {
+   "stage": "connecting_bluetooth",
+   "kind": "RuntimeError",
+   "evidence": "org.bluez.Error.Failed: br-connection-refused",
+   "count": 2
+  },
+  {
+   "stage": "joining_wifi",
+   "kind": "BootstrapError",
+   "evidence": "joining car wi-fi: joining_wifi: Timed out joining the projection network after 30 s",
+   "count": 2
+  },
+  {
+   "stage": "rfcomm",
+   "kind": "PermissionError",
+   "evidence": "[Errno 13] Permission denied",
+   "count": 2
+  },
+  {
+   "stage": "connecting_bluetooth",
+   "kind": "BluetoothRejected",
+   "evidence": "org.freedesktop.systemd1.NoSuchUnit",
+   "count": 1
+  },
+  {
+   "stage": "joining_wifi",
+   "kind": "BootstrapError",
+   "evidence": "joining car wi-fi: joining_wifi: Joined the projection network but received no IPv4 address",
+   "count": 1
+  },
+  {
+   "stage": "authenticating",
+   "kind": "SSLCertVerificationError",
+   "evidence": "[SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed: format error in certificate's notBefore field (_ssl.c:1000) (set verify_head_unit false in config.json to test without verifying the car)",
+   "count": 1
+  },
+  {
+   "stage": "streaming",
+   "kind": "RuntimeError",
+   "evidence": "Lost the car's Wi-Fi network",
+   "count": 1
+  },
+  {
+   "stage": "rfcomm",
+   "kind": "BlockingIOError",
+   "evidence": "[Errno 114] Operation already in progress",
+   "count": 1
+  },
+  {
+   "stage": "negotiating",
+   "kind": "TimeoutError",
+   "evidence": "Head unit did not send 0/0x6",
+   "count": 1
+  },
+  {
+   "stage": "streaming",
+   "kind": "TimeoutExpired",
+   "evidence": "Command '['/usr/local/venv/bin/python3', '-m', 'openpilot.starpilot.system.android_auto.current_car_ui', '--frames', '/dev/shm/starpilot_android_auto_car_frame', '--touch', '/tmp/starpilot-android-auto-touch.sock', '--control', '/tmp/starpi",
+   "count": 1
+  },
+  {
+   "stage": "authenticating",
+   "kind": "ConnectionResetError",
+   "evidence": "[Errno 104] Connection reset by peer",
+   "count": 1
+  },
+  {
+   "stage": "connecting_tcp",
+   "kind": "RuntimeError",
+   "evidence": "Car did not accept the projection connection: timed out",
+   "count": 1
+  }
+ ]
+}
diff --git a/openpilot/starpilot/system/starport/tests/test_bugsink_report.py b/openpilot/starpilot/system/starport/tests/test_bugsink_report.py
index 8f59569e23..396776b379 100644
--- a/openpilot/starpilot/system/starport/tests/test_bugsink_report.py
+++ b/openpilot/starpilot/system/starport/tests/test_bugsink_report.py
@@ -472,6 +472,7 @@ def test_report_keeps_setup_offered_modes_and_the_working_strategy(tmp_path):
   tags = event["tags"]
   assert (tags["aa.setup_type"], tags["aa.adapter_model"], tags["aa.profile_source"], tags["aa.phone_address_sent"]) == (
     "adapter", "aawireless", "override", "yes")
+  assert (tags["aa.reply_style"], tags["aa.wifi_channel_type"]) == ("modern", "1")
   context = event["contexts"]["starport_session_1"]
   assert context["offered_modes"] == record["offered_modes"] and context["strategy"]["reply_style"] == "modern"
   assert "39:90:21:64:07:00" not in json.dumps(event)  # the comma's own address is sanitized from every field
diff --git a/openpilot/starpilot/system/starport/tests/test_reachability.py b/openpilot/starpilot/system/starport/tests/test_reachability.py
index effbc1ff84..b067042f15 100644
--- a/openpilot/starpilot/system/starport/tests/test_reachability.py
+++ b/openpilot/starpilot/system/starport/tests/test_reachability.py
@@ -64,3 +64,26 @@ def test_stream_losses_are_told_apart_by_what_the_log_says(tmp_path):
     events = [(0, 0, "session_start", {}), (0, 1, "stage", {"state": "streaming"}), (0, 9, "attempt_failed", {"stage": "streaming", "kind": "EOFError", "error": text})]
     event = br.drive_event([br.session_record(write_session(tmp_path, 3 if kind == "stalled" else 4, events))])
     assert event["tags"]["aa.cause"] == "projection_interrupted" and event["tags"]["aa.loss_kind"] == kind
+
+
+def test_every_real_bugsink_failure_text_is_classified_as_intended():
+  import json
+  from pathlib import Path
+  rows = json.loads((Path(__file__).parent / "fixtures" / "bugsink_failure_texts.json").read_text())["failures"]
+  assert sum(row["count"] for row in rows) > 600 and len(rows) > 40
+  seen = {r.ASLEEP: 0, r.NOT_READY: 0, r.LOCAL: 0, r.OTHER: 0}
+  for row in rows:
+    got = r.classify(row["stage"], row["kind"], row["evidence"])
+    text = row["evidence"].lower()
+    seen[got] += row["count"]
+    if row["stage"] in ("streaming", "authenticating", "negotiating", "connecting_tcp", "joining_wifi"):
+      assert got == r.OTHER, row            # once the link is up, none of this is about reaching the car
+      continue
+    if "host is down" in text or "page-timeout" in text:
+      assert got == r.ASLEEP, row
+    if "connection refused" in text or "did not answer in time" in text:
+      assert got == r.NOT_READY, row
+    if "galaxy bluetooth first" in text:
+      assert got == r.OTHER, row            # a setup step to take, not a reachability problem
+  early = seen[r.ASLEEP] + seen[r.NOT_READY] + seen[r.LOCAL]
+  assert early > 0.6 * sum(seen.values()), seen   # most failures before video are now explained instead of "unknown"

From e5a981b5ad899ecc2075eb45e19d1fc4f4531a48 Mon Sep 17 00:00:00 2001
From: dirwin31 <83434411+dirwin31@users.noreply.github.com>
Date: Sun, 1 Nov 2026 14:26:08 -0800
Subject: [PATCH 18/38] Ladder passes are per ignition; car adoption leaves the
 owner's audio setup alone

The comma can stay powered between drives, so the three passes belong to an
ignition (an onroad start), not to a boot; a reboot still resets them. When a
learned strategy is dropped after two handshake failures the ladder carries
on from the next rung instead of starting at the one that just failed, which
the dongle flip also avoided.

Choosing the only paired Android Auto car from housekeeping runs with nobody
at the screen, and selecting a receiver unselects that device as the
Bluetooth audio output. It now skips a car that is the selected audio device,
or when that cannot be read, leaves it to the setup screen's Use button. It
reports problems once instead of every 20 s and gives the projection role
back, keeping only the standby gateway auto-connect needs.
---
 .../starpilot/system/starport/setup_ladder.py |  22 +++-
 .../starpilot/system/starport/supervisor.py   |  37 +++++-
 .../starport/tests/test_car_adoption.py       | 110 ++++++++++++++++++
 .../starport/tests/test_setup_ladder.py       |  23 +++-
 4 files changed, 180 insertions(+), 12 deletions(-)
 create mode 100644 openpilot/starpilot/system/starport/tests/test_car_adoption.py

diff --git a/openpilot/starpilot/system/starport/setup_ladder.py b/openpilot/starpilot/system/starport/setup_ladder.py
index 49f696f7dc..d433f459a3 100644
--- a/openpilot/starpilot/system/starport/setup_ladder.py
+++ b/openpilot/starpilot/system/starport/setup_ladder.py
@@ -27,7 +27,7 @@ from openpilot.starpilot.system.starport.identity import DATA_DIR
 STATE_PATH = DATA_DIR / "setup_state.json"
 STATE_VERSION = 1
 MAX_CARS = 16
-MAX_PASSES = 3          # full runs through the ladder per boot (one boot is one ignition cycle); not yet confirmed against real cars
+MAX_PASSES = 3          # full runs through the ladder per ignition cycle; not yet confirmed against real cars
 DROP_AFTER = 2          # failures at the remembered strategy before it is forgotten and the ladder starts over
 CLEAN_SECONDS = 60.0    # a session that streamed this long without ending in a handshake failure counts as working
 LONG_PATIENCE = 2 * REFUSAL_PATIENCE
@@ -170,10 +170,19 @@ class SetupLadder:
   def _entry(self, address: str) -> dict:
     entry = self.cars.setdefault(address.upper(), _fresh())
     boot = self.boot_id()
-    if entry["boot"] != boot:       # a new ignition cycle gets its full passes again and resumes at the first untried rung
+    if entry["boot"] != boot:       # a reboot is also a new cycle, for a comma that was powered off between drives
       entry["boot"], entry["passes"] = boot, 0
     return entry
 
+  def begin_cycle(self, address: str) -> None:
+    """A new ignition cycle: the passes are used up per drive, not per boot (the comma can stay powered between drives).
+
+    Resumes at the first untried rung. Does nothing for a car with a learned strategy or nothing tried."""
+    entry = self.cars.get(address.upper())
+    if entry and entry["passes"]:
+      entry["passes"] = 0
+      self.save()
+
   def forget(self, address: str) -> bool:
     """A car's pairing was deleted: drop what was learned about it."""
     removed = self.cars.pop(address.upper(), None) is not None
@@ -205,14 +214,15 @@ class SetupLadder:
     entry = self._entry(address)
     entry["updated"] = self.clock()
     working = _valid_strategy(entry["working"])
+    dropped = False
     if working and strategy.rung == working.rung:
       entry["working_failures"] += 1
       if entry["working_failures"] < DROP_AFTER:
         self.save()
         return "counted"
-      entry.update(working=None, working_failures=0, rung="standard", results={})
-      self.save()
-      return "dropped"
+      # Forgotten, and what just failed twice is not tried again first: carry on from the next rung.
+      entry.update(working=None, working_failures=0, results={})
+      dropped = True
     if entry["passes"] >= MAX_PASSES:
       return None
     entry["results"][strategy.rung] = "failed"
@@ -229,7 +239,7 @@ class SetupLadder:
       if entry["passes"] >= MAX_PASSES:
         outcome = "exhausted"
     self.save()
-    return outcome
+    return "dropped" if dropped else outcome
 
   def worked(self, address: str, strategy: Strategy, t_ready_s: float | None = None) -> None:
     entry = self._entry(address)
diff --git a/openpilot/starpilot/system/starport/supervisor.py b/openpilot/starpilot/system/starport/supervisor.py
index 7089f827ae..19f7d42b98 100644
--- a/openpilot/starpilot/system/starport/supervisor.py
+++ b/openpilot/starpilot/system/starport/supervisor.py
@@ -773,10 +773,13 @@ class Supervisor:
 
   def _adopt_only_car(self, now: float) -> None:
     """A car that is paired and offers Android Auto but was never chosen (the pairing window closed first, or it was
-    paired in Bluetooth settings) becomes the chosen car when it is the only one. Never during a pairing window or session."""
+    paired in Bluetooth settings) becomes the chosen car when it is the only one. Never during a pairing window or session,
+    and never a car the owner uses as the Bluetooth audio output: choosing it as the receiver would unselect that, and this
+    runs with nobody at the screen (the setup screen's Use button is where that choice is made)."""
     config = self.config
     if (config["receiver_address"] or config["connection"] != "wireless" or self.car_type() == "adapter"
-        or not self._projection_enabled() or self._pairing_active() or self._session_alive() or now - getattr(self, "_adopt_at", -ADOPT_INTERVAL) < ADOPT_INTERVAL):
+        or not self._projection_enabled() or self._pairing_active() or self._session_alive()
+        or now - getattr(self, "_adopt_at", -ADOPT_INTERVAL) < ADOPT_INTERVAL):
       if config["receiver_address"]:
         self._candidates = []
       return
@@ -784,21 +787,43 @@ class Supervisor:
     try:
       car, candidates = choose_only_car(self._phone().devices())
     except Exception as error:
-      self.log("car_adopt_unavailable", kind=type(error).__name__, error=str(error)[:120])
+      self._adopt_note("car_adopt_unavailable", kind=type(error).__name__, error=str(error)[:120])
       return
     self._candidates = [{"address": device["address"], "name": device.get("name") or device["address"]} for device in candidates]
     if car is None:
       if len(candidates) > 1:
-        self.log("car_adopt_ambiguous", count=len(candidates))
+        self._adopt_note("car_adopt_ambiguous", count=len(candidates))
+      return
+    if self._is_audio_car(car["address"]):
+      self._adopt_note("car_adopt_skipped", reason="selected as the Bluetooth audio output")
       return
     try:
       self.select_receiver(car["address"], car.get("name") or "")
     except (RuntimeError, ValueError) as error:
-      self.log("car_adopt_failed", error=str(error))
+      self._adopt_note("car_adopt_failed", error=str(error))
       return
+    finally:
+      if not self._session_alive():
+        self._release_phone()    # select_receiver took the projection role; nothing is connecting, so give it back
     self._candidates = []
+    self._adopt_last = None
     self.log("car_adopted", car=car.get("name") or "", reason="only paired Android Auto device")
 
+  def _adopt_note(self, name: str, **values) -> None:
+    """Housekeeping runs every 20 s: say what is wrong once, and again only when it changes."""
+    signature = (name, tuple(sorted(values.items())))
+    if signature != getattr(self, "_adopt_last", None):
+      self._adopt_last = signature
+      self.log(name, **values)
+
+  def _is_audio_car(self, address: str) -> bool:
+    if self._bt_client is None:
+      return False
+    try:
+      return self._bt_client.status().selected_audio.upper() == address.upper()
+    except Exception:
+      return True   # cannot tell, so leave the owner's audio setup alone
+
   def _auto_connect(self, now: float) -> None:
     config = self.config
     if self._pairing_active():
@@ -1198,6 +1223,8 @@ class Supervisor:
     wireless = connection == "wireless"
     receiver = {"wired": "usb", "headunitpad": "headunitpad", "openheadunit": "openheadunit"}.get(connection, self.config["receiver_name"])
     self._video_seen, self._strategy, self._run_started = False, None, time.monotonic()
+    if trigger == "onroad" and wireless:   # a new drive: the ladder's passes are per ignition, and the comma can stay on between drives
+      self._ladder.begin_cycle(self.config["receiver_address"])
     from openpilot.starpilot.system.starport.bugsink_transport import device_metadata
     software = device_metadata()
     profile, profile_source = car_profiles.resolve(self.config)
diff --git a/openpilot/starpilot/system/starport/tests/test_car_adoption.py b/openpilot/starpilot/system/starport/tests/test_car_adoption.py
new file mode 100644
index 0000000000..6741cb15dd
--- /dev/null
+++ b/openpilot/starpilot/system/starport/tests/test_car_adoption.py
@@ -0,0 +1,110 @@
+"""A car that is the only paired Android Auto device is chosen by housekeeping, without touching anything the owner set up."""
+import pytest
+
+from openpilot.starpilot.system.starport import identity as identity_store
+from openpilot.starpilot.system.starport.tests.fake_head_unit import make_identity
+from openpilot.starpilot.system.starport.tests.test_starport import make_supervisor
+
+CAR, OTHER = "AA:BB:CC:DD:EE:07", "AA:BB:CC:DD:EE:08"
+
+
+@pytest.fixture(scope="module")
+def identity(tmp_path_factory):
+  return make_identity(tmp_path_factory.mktemp("identity"))
+
+
+@pytest.fixture
+def sup(identity, tmp_path, monkeypatch):
+  supervisor, _ = make_supervisor(identity, tmp_path, monkeypatch, lambda *a, **k: None)
+  with supervisor._lock:
+    supervisor.config.update(receiver_address="", receiver_name="", car_type="builtin")
+  class Recorder:
+    recent = ()
+
+    def __init__(self):
+      self.events = []
+
+    def __call__(self, name, **values):
+      self.events.append((name, values))
+
+  supervisor.log = Recorder()
+  supervisor.events = supervisor.log.events
+  supervisor._projection_enabled = lambda: True
+  supervisor.baseline = supervisor._phone().acquired   # make_supervisor chose a car once already
+  return supervisor
+
+
+def names(sup):
+  return [name for name, _ in sup.events]
+
+
+def test_the_only_candidate_is_chosen_trusted_and_the_projection_role_given_back(sup):
+  bluez = sup._phone()
+  bluez.paired_devices = [(CAR, "Civic", True), (OTHER, "Headphones", False)]
+  sup._adopt_only_car(1000.0)
+  assert sup.config["receiver_address"] == CAR and sup.config["receiver_name"] == "Civic"
+  assert identity_store.load_config()["receiver_address"] == CAR
+  assert bluez.trusted[-1] == CAR and bluez.acquired == sup.baseline + 1 and bluez.class_restored >= 1  # the phone look is given back; the standby gateway stays
+  assert "car_adopted" in names(sup) and sup._candidates == []
+
+
+def test_two_candidates_are_never_guessed_and_nothing_is_acquired(sup):
+  bluez = sup._phone()
+  bluez.paired_devices = [(CAR, "Civic", True), (OTHER, "Wagon", True)]
+  for tick in range(5):
+    sup._adopt_only_car(1000.0 + 25 * tick)
+  assert sup.config["receiver_address"] == "" and bluez.acquired == sup.baseline
+  assert [car["address"] for car in sup.status()["car_candidates"]] == [CAR, OTHER]
+  assert names(sup).count("car_adopt_ambiguous") == 1   # said once, not every 20 s
+
+
+def test_the_car_used_as_bluetooth_audio_is_left_to_the_owner(sup):
+  sup._bt_client = type("C", (), {"status": lambda s: type("St", (), {"selected_audio": CAR.lower()})()})()
+  sup._phone().paired_devices = [(CAR, "Civic", True)]
+  for tick in range(3):
+    sup._adopt_only_car(1000.0 + 25 * tick)
+  assert sup.config["receiver_address"] == "" and sup._phone().acquired == sup.baseline
+  assert names(sup).count("car_adopt_skipped") == 1
+  assert [car["address"] for car in sup.status()["car_candidates"]] == [CAR]   # still offered through the setup screen's Use button
+
+
+def test_when_the_audio_selection_cannot_be_read_the_owners_setup_is_left_alone(sup):
+  def broken():
+    raise RuntimeError("bluetooth service down")
+  sup._bt_client = type("C", (), {"status": lambda s: broken()})()
+  sup._phone().paired_devices = [(CAR, "Civic", True)]
+  sup._adopt_only_car(1000.0)
+  assert sup.config["receiver_address"] == ""
+
+
+@pytest.mark.parametrize("change", [
+  {"receiver_address": "AA:00:00:00:00:99"}, {"connection": "wired"}, {"car_type": "adapter"},
+])
+def test_it_does_nothing_once_a_car_is_chosen_or_for_wired_and_adapter_setups(sup, change):
+  with sup._lock:
+    sup.config.update(change)
+  sup._phone().paired_devices = [(CAR, "Civic", True)]
+  sup._adopt_only_car(1000.0)
+  assert sup.config["receiver_address"] in ("", "AA:00:00:00:00:99") and sup._phone().acquired == sup.baseline
+
+
+def test_it_does_nothing_while_a_session_runs_projection_is_off_or_it_ran_a_moment_ago(sup):
+  sup._phone().paired_devices = [(CAR, "Civic", True)]
+  sup._projection_enabled = lambda: False
+  sup._adopt_only_car(1000.0)
+  assert sup.config["receiver_address"] == ""
+  sup._projection_enabled = lambda: True
+  sup._adopt_only_car(2000.0)
+  assert sup.config["receiver_address"] == CAR
+  sup.config["receiver_address"] = ""
+  sup._adopt_only_car(2005.0)      # inside the 20 s interval
+  assert sup.config["receiver_address"] == ""
+
+
+def test_an_unreadable_bluetooth_service_is_reported_once(sup):
+  def broken():
+    raise RuntimeError("no shared owner")
+  sup._phone = broken
+  for tick in range(4):
+    sup._adopt_only_car(1000.0 + 25 * tick)
+  assert names(sup).count("car_adopt_unavailable") == 1
diff --git a/openpilot/starpilot/system/starport/tests/test_setup_ladder.py b/openpilot/starpilot/system/starport/tests/test_setup_ladder.py
index 1ba7e0f6e0..fbb7e65acc 100644
--- a/openpilot/starpilot/system/starport/tests/test_setup_ladder.py
+++ b/openpilot/starpilot/system/starport/tests/test_setup_ladder.py
@@ -121,7 +121,9 @@ def test_a_learned_strategy_is_forgotten_only_after_two_handshake_failures(ladde
   assert refuse(ladder, learned) == "counted" and ladder.strategy(CAR, False).rung == "modern_dual"
   assert refuse(ladder, learned, ladder_failure=False) is None and refuse(ladder, learned, video_seen=True) is None
   assert refuse(ladder, learned) == "dropped"
-  assert ladder.strategy(CAR, False).rung == "standard" and not ladder.snapshot(CAR)["learned"]
+  # Not back to the start: the strategy that just failed twice is not tried first, the next rung is.
+  assert ladder.strategy(CAR, False).rung == "modern_24ghz" and not ladder.snapshot(CAR)["learned"]
+  assert ladder.snapshot(CAR)["steps"][2]["state"] == "failed"
 
 
 def test_state_survives_a_restart_and_a_damaged_file_means_a_fresh_start(tmp_path):
@@ -221,3 +223,22 @@ def test_a_slow_car_gets_the_patience_it_once_needed_and_an_unknown_car_gets_no_
   assert ladder.ready_patience(CAR) == 4   # 70 s at 20 s per stage timeout
   ladder.worked(CAR, sl.resolve("standard", False), 3000.0)
   assert ladder.ready_patience(CAR) == 9   # capped
+
+
+def test_a_learned_standard_strategy_that_stops_working_moves_on_to_the_other_reply(ladder):
+  ladder.worked(CAR, sl.resolve("standard", False))
+  learned = ladder.strategy(CAR, False)
+  assert refuse(ladder, learned) == "counted"
+  assert refuse(ladder, learned) == "dropped"
+  assert ladder.strategy(CAR, False).rung == "other_reply"   # one failure fewer than starting over, as the dongle flip did
+
+
+def test_the_passes_come_back_with_each_ignition_even_without_a_reboot(ladder):
+  for _ in range(5 * sl.MAX_PASSES):
+    refuse(ladder, ladder.strategy(CAR, False))
+  assert ladder.exhausted(CAR) and ladder.snapshot(CAR)["passes"] == sl.MAX_PASSES
+  ladder.begin_cycle(CAR)                         # the next drive starts: same boot, same comma
+  assert not ladder.exhausted(CAR) and ladder.snapshot(CAR)["passes"] == 0
+  assert refuse(ladder, ladder.strategy(CAR, False)) == "advanced"
+  ladder.begin_cycle("AA:00:00:00:00:99")        # an unknown car is a no-op
+  assert "AA:00:00:00:00:99" not in ladder.cars

From 75a29d3e7195887e26bd8a740dac2fbf6efd5c24 Mon Sep 17 00:00:00 2001
From: dirwin31 <83434411+dirwin31@users.noreply.github.com>
Date: Sun, 1 Nov 2026 14:28:15 -0800
Subject: [PATCH 19/38] Put the full report in the logs bundle; turn the
 Bluetooth-first refusal into a step

The logs bundle, and so the Discord send, now carries report.json: the same
tags and per-session detail a Bugsink report has (setup, offered modes, reach
class, ladder, SDP, strategy) for the newest five sessions, sanitized and
size-capped. It is built best-effort: if it cannot be, the bundle is
unaffected.

The adapter setup's 'Connect your paired car in Galaxy Bluetooth first'
refusal (27 Bugsink reports) now shows a step with a link to Bluetooth, next
to the usual question while setup is unfinished and alone once it is done.
---
 .../galaxy/tests/test_starport_guided.mjs     | 15 +++++++++
 .../galaxy/web/js/starport-guided.js          | 16 +++++++---
 .../system/starport/compat_report.py          | 31 +++++++++++++++++++
 .../tests/test_diagnostics_logging.py         | 17 ++++++++++
 4 files changed, 75 insertions(+), 4 deletions(-)

diff --git a/openpilot/starpilot/galaxy/tests/test_starport_guided.mjs b/openpilot/starpilot/galaxy/tests/test_starport_guided.mjs
index d055fed73b..1c85cd4de6 100644
--- a/openpilot/starpilot/galaxy/tests/test_starport_guided.mjs
+++ b/openpilot/starpilot/galaxy/tests/test_starport_guided.mjs
@@ -132,3 +132,18 @@ assert.equal(guidedState({ setup: null, runtime: running("rfcomm") }).show, fals
   assert.equal(StarPortPage.computed.newSetup.call({ setup: null }), true)
 }
 console.log("StarPort guided setup: question, steps, candidates, live checklist, first-run notice and handshake list passed")
+
+// The adapter's "connect your car in Bluetooth first" refusal becomes a step with a link, not a dead end.
+{
+  const { BLUETOOTH_HINT } = await import("../web/js/starport-guided.js")
+  const refused = { running: false, state: "error", error: "Connect your paired car in Galaxy Bluetooth first to select it for this Android Auto adapter" }
+  const state = guidedState({ setup, runtime: refused, carType: "adapter", labels })
+  assert.equal(state.phase, "setup")      // the usual question and steps stay, with the action first
+  assert.deepEqual(state.hint, BLUETOOTH_HINT)
+  assert.equal(BLUETOOTH_HINT.href, "#/bluetooth")
+  const done = guidedState({ setup, runtime: refused, setupDone: true })
+  assert.equal(done.phase, "bluetooth")   // even a finished setup shows the thing to fix
+  assert.equal(guidedState({ setup, runtime: { running: false, state: "error", error: "something else" }, carType: "adapter", labels }).hint, null)
+  assert.match(StarPortGuidedSetup.template, /state\.hint\.href/)
+}
+console.log("StarPort guided setup: Bluetooth-first hint passed")
diff --git a/openpilot/starpilot/galaxy/web/js/starport-guided.js b/openpilot/starpilot/galaxy/web/js/starport-guided.js
index 70d1d0830c..798b7c2cca 100644
--- a/openpilot/starpilot/galaxy/web/js/starport-guided.js
+++ b/openpilot/starpilot/galaxy/web/js/starport-guided.js
@@ -3,6 +3,9 @@
 // so it adds no new state of its own. Turned off, the classic screens come back ("Use classic setup").
 
 export const FIRST_RUN_NOTICE = "The first connection can take a few minutes, and sometimes more than one drive, while we find what your car accepts. Keep the car on and its screen awake. Later connections are much faster because we remember what worked."
+// The adapter flow refuses to continue until the car itself is connected in Galaxy Bluetooth (27 Bugsink reports, 7 devices).
+export const BLUETOOTH_FIRST = /connect your paired car in galaxy bluetooth first/i
+export const BLUETOOTH_HINT = { text: "Connect your car in Bluetooth first, then come back and tap Connect.", href: "#/bluetooth", label: "Open Bluetooth" }
 export const EXHAUSTED_NOTICE = "We tried every option we have this drive. We keep what works best and will try again the next time the car starts."
 
 const CHOICES = [
@@ -68,16 +71,20 @@ export function guidedState({ setup = null, runtime = null, selected = null, rec
   const connecting = !!runtime?.running && CONNECTING.has(state)
   const installed = !!setup?.identity?.installed
   const base = { show: false, phase: "live", title: "", detail: "", choices: [], carType, candidates: [], progress: [], handshake: [],
-    notice: "", exhausted: false }
+    notice: "", exhausted: false, hint: null }
   if (setup === null) return base
+  const hint = BLUETOOTH_FIRST.test(String(runtime?.error || "")) ? BLUETOOTH_HINT : null
   if (connecting) {
     const firstRun = !ladder?.learned && !(ladder?.successes > 0) && (runtime?.connection || "wireless") === "wireless"
     return { ...base, show: true, phase: "connecting", title: runtime?.label || "Connecting to your car",
       detail: runtime?.detail || "Keep your car’s screen on. We’ll move to the next step automatically.",
       progress: connectionStages(runtime), handshake: handshakeSteps(ladder), exhausted: !!ladder?.exhausted,
-      notice: ladder?.exhausted ? EXHAUSTED_NOTICE : firstRun ? FIRST_RUN_NOTICE : "" }
+      notice: ladder?.exhausted ? EXHAUSTED_NOTICE : firstRun ? FIRST_RUN_NOTICE : "", hint }
+  }
+  if (setupDone) {
+    // A finished setup shows nothing, except a refusal that is the one thing to act on.
+    return hint ? { ...base, show: true, phase: "bluetooth", title: "Your car needs to be connected in Bluetooth first", detail: hint.text, hint } : base
   }
-  if (setupDone) return base
   if (!installed) {
     return { ...base, show: true, phase: "package", title: "Start by adding your Android Auto package",
       detail: "Your car only talks to devices that present Google’s Android Auto certificate. Follow step 1 below, then come back here." }
@@ -93,7 +100,7 @@ export function guidedState({ setup = null, runtime = null, selected = null, rec
   }
   const pairs = carType === "builtin" || carType === "adapter"
   return { ...base, show: true, phase: "setup", title: "How does your car connect to Android Auto?",
-    detail: INSTRUCTIONS[carType] || INSTRUCTIONS.builtin, choices, candidates: pairs && !pairingActive ? candidates : [] }
+    detail: INSTRUCTIONS[carType] || INSTRUCTIONS.builtin, choices, candidates: pairs && !pairingActive ? candidates : [], hint }
 }
 
 export const StarPortGuidedSetup = {
@@ -142,6 +149,7 @@ export const StarPortGuidedSetup = {
             </li>
           </ol>
         </details>
+        <p v-if="state.hint" class="gx-note" role="status">{{ state.hint.text }} <a class="gx-btn gx-btn--tonal" :href="state.hint.href">{{ state.hint.label }}</a></p>
         <p v-if="state.notice" class="gx-note" role="status">{{ state.notice }}</p>
         <button type="button" class="gx-btn gx-btn--tonal" :disabled="busy" @click="$emit('classic')">Use classic setup</button>
       </div>
diff --git a/openpilot/starpilot/system/starport/compat_report.py b/openpilot/starpilot/system/starport/compat_report.py
index 64ede3ae94..f6692fc70f 100644
--- a/openpilot/starpilot/system/starport/compat_report.py
+++ b/openpilot/starpilot/system/starport/compat_report.py
@@ -293,6 +293,34 @@ def shareable_config(config: dict) -> dict:
   return shared
 
 
+RECENT_DIAGNOSIS_SESSIONS = 5
+MAX_DIAGNOSIS_BYTES = 512 << 10
+
+
+def _diagnosis_report(logs: list[Path]) -> bytes:
+  """The same tags and per-session detail a Bugsink report carries (setup, offered modes, reach class, ladder, SDP...),
+  for the newest few sessions, sanitized. An addition to the bundle: if it cannot be built the bundle is unaffected."""
+  try:
+    from openpilot.starpilot.system.starport import bugsink_report
+    records = []
+    for path in logs[:RECENT_DIAGNOSIS_SESSIONS]:
+      try:
+        records.append(bugsink_report.session_record(path))
+      except (OSError, ValueError, KeyError, TypeError):
+        continue
+    if not records:
+      return b""
+    records.reverse()   # oldest first, as the drive report expects
+    event = bugsink_report.drive_event(records)
+    report = {"tags": event["tags"], "message": event["message"], "sessions": [bugsink_report._public(record) for record in records]}
+    data = json.dumps(report, indent=1, default=str).encode()
+    if len(data) > MAX_DIAGNOSIS_BYTES:
+      data = json.dumps({key: report[key] for key in ("tags", "message")}, indent=1, default=str).encode()
+    return data
+  except Exception:
+    return b""
+
+
 def bundle(log_dir: Path | None = None, config_path: Path | None = None, *,
            snapshot: Callable[[float], dict[str, bytes]] | None = system_snapshot.collect) -> bytes:
   """A zip for a bug report: every session log with its report, the settings, the renderer logs and a snapshot of the
@@ -321,6 +349,9 @@ def bundle(log_dir: Path | None = None, config_path: Path | None = None, *,
       add(f"logs/{path.name}", data)
       add(f"reports/{path.stem}.json", json.dumps(report, indent=2, default=str).encode())
     add("REPORT.txt", ("\n".join(summaries) or "No Android Auto sessions have been logged yet.\n").encode())
+    report = _diagnosis_report(logs)
+    if report:
+      add("report.json", report)
     config = identity_store.load_config(config_path)
     add("config.json", json.dumps(shareable_config(config), indent=2, default=str).encode())
     for name in EXTRA_LOGS:
diff --git a/openpilot/starpilot/system/starport/tests/test_diagnostics_logging.py b/openpilot/starpilot/system/starport/tests/test_diagnostics_logging.py
index 5bd9bbcb64..4852d9724a 100644
--- a/openpilot/starpilot/system/starport/tests/test_diagnostics_logging.py
+++ b/openpilot/starpilot/system/starport/tests/test_diagnostics_logging.py
@@ -231,6 +231,23 @@ def test_bundle_has_logs_reports_and_settings_without_addresses(tmp_path):
     assert "AA:BB:CC:DD:EE:FF" not in shared and json.loads(shared)["rfcomm_cache"] == [5]
     assert "projected, then failed" in archive.read("REPORT.txt").decode()
     assert not any(name.endswith((".pem", ".key")) for name in names)
+    # The bundle (and so the Discord send) carries what a Bugsink report carries: tags, and per-session detail.
+    report = json.loads(archive.read("report.json"))
+    assert report["tags"]["aa.report"] == "drive" and "aa.head_unit" in report["tags"]
+    assert report["sessions"][0]["offered_modes"] is not None and "setup" in report["sessions"][0]
+    assert "AA:BB:CC:DD:EE:FF" not in archive.read("report.json").decode()
+
+
+def test_bundle_still_builds_when_the_report_cannot(tmp_path, monkeypatch):
+  from openpilot.starpilot.system.starport import bugsink_report
+  logs = tmp_path / "logs"
+  logs.mkdir()
+  write_log(logs, "session-000025-20260928-141351.jsonl", CIVIC_SESSION)
+  monkeypatch.setattr(bugsink_report, "session_record", lambda path: (_ for _ in ()).throw(RuntimeError("broken")))
+  config = tmp_path / "config.json"
+  config.write_text("{}")
+  with zipfile.ZipFile(io.BytesIO(compat_report.bundle(logs, config))) as archive:
+    assert "REPORT.txt" in archive.namelist() and "report.json" not in archive.namelist()
 
 
 def test_report_tool_prints_a_log(tmp_path, monkeypatch, capsys):

From 2678e29cb3495138e4e7d82ae60b05b3a12220d1 Mon Sep 17 00:00:00 2001
From: dirwin31 <83434411+dirwin31@users.noreply.github.com>
Date: Sun, 1 Nov 2026 16:42:08 -0800
Subject: [PATCH 20/38] Redesign the guided StarPort setup; keep the dropdowns
 to the classic screens

The guided card is rebuilt in an Apple-style: a three-step track (support,
car, connect) that fills as setup moves along, a large title, inset grouped
lists with coloured icon tiles for how the car connects, a segmented control
for the adapter model and the tablet app, iOS-style checklist rows for the
connection, and one full-width primary button. It uses Galaxy's theme colors
so light and dark both work, and reads cleanly down to a phone.

The classic step 2 and the home card's dropdowns now render only in the
classic setup. The guided card replaces them and hosts the page's own
pairing, cable and app instructions and the Connect button, so nothing is
lost. A finished setup can be reopened from Setup and Pairing, and Done
closes it. Paired cars the page's own list does not show yet are offered in
the card; the rest stay in the pairing step.
---
 .../galaxy/tests/test_starport_guided.mjs     |  94 +++++++--
 openpilot/starpilot/galaxy/web/css/galaxy.css | 167 ++++++++++++++-
 .../galaxy/web/js/starport-guided.js          | 196 ++++++++++++------
 openpilot/starpilot/galaxy/web/js/starport.js | 187 ++++++++++-------
 4 files changed, 486 insertions(+), 158 deletions(-)

diff --git a/openpilot/starpilot/galaxy/tests/test_starport_guided.mjs b/openpilot/starpilot/galaxy/tests/test_starport_guided.mjs
index 1c85cd4de6..14de96aff0 100644
--- a/openpilot/starpilot/galaxy/tests/test_starport_guided.mjs
+++ b/openpilot/starpilot/galaxy/tests/test_starport_guided.mjs
@@ -3,7 +3,8 @@ import { StarPortFeed, StarPortPage } from "../web/js/starport.js"
 import { guidedState, connectionStages, handshakeSteps, StarPortGuidedSetup, FIRST_RUN_NOTICE, EXHAUSTED_NOTICE } from "../web/js/starport-guided.js"
 
 const setup = { identity: { installed: true } }
-const labels = { builtin: "Built-in wireless", adapter: "Wireless adapter", usb: "Wired AA", app: "App" }
+const adapterModels = { aawireless: "AAWireless", default: "Motorola MA1", unofficial: "Unofficial dongle" }
+const appModels = { headunitpad: "HeadunitPad", openheadunit: "Open Headunit" }
 const ladder = (over = {}) => ({ steps: [{ id: "standard", label: "Standard handshake", state: "current" }, { id: "other_reply", label: "The other version reply", state: "waiting" }],
   learned: false, passes: 0, max_passes: 3, exhausted: false, successes: 0, ...over })
 const running = (state, over = {}) => ({ running: true, state, connection: "wireless", setup_ladder: ladder(), ...over })
@@ -14,7 +15,7 @@ assert.equal(guidedState({ setup: null, runtime: running("rfcomm") }).show, fals
 
 // Without the Android Auto package the first thing to do is that step, nothing else.
 {
-  const state = guidedState({ setup: { identity: { installed: false } }, runtime: null, labels })
+  const state = guidedState({ setup: { identity: { installed: false } }, runtime: null })
   assert.equal(state.phase, "package")
   assert.equal(state.show, true)
   assert.deepEqual(state.choices, [])
@@ -22,24 +23,27 @@ assert.equal(guidedState({ setup: null, runtime: running("rfcomm") }).show, fals
 
 // First run: one question, four answers, the current one marked, and only the steps for that answer.
 {
-  const state = guidedState({ setup, runtime: { running: false, state: "idle" }, carType: "builtin", labels })
+  const state = guidedState({ setup, runtime: { running: false, state: "idle" }, carType: "builtin" })
   assert.equal(state.phase, "setup")
   assert.deepEqual(state.choices.map((choice) => choice.key), ["builtin", "adapter", "usb", "app"])
   assert.deepEqual(state.choices.map((choice) => choice.selected), [true, false, false, false])
-  assert.equal(state.choices[1].label, "Wireless adapter")
+  assert.deepEqual(state.choices.map((choice) => choice.title), ["Built-in wireless", "Wireless adapter", "USB cable", "Tablet app"])
+  assert.equal(state.title, "Set up your car")
   assert.match(state.detail, /pairing screen/)
-  assert.match(guidedState({ setup, runtime: null, carType: "adapter", labels }).detail, /adapter in pairing mode/)
-  assert.match(guidedState({ setup, runtime: null, carType: "usb", labels }).detail, /USB data port/)
-  assert.match(guidedState({ setup, runtime: null, carType: "app", labels }).detail, /tablet/)
+  assert.match(guidedState({ setup, runtime: null, carType: "adapter" }).detail, /pairing mode/)
+  assert.match(guidedState({ setup, runtime: null, carType: "usb" }).detail, /USB data port/)
+  assert.match(guidedState({ setup, runtime: null, carType: "app" }).detail, /tablet/)
 }
 
-// Cars to choose between: paired, offering Android Auto, de-duplicated, never the selected one, not while pairing.
+// Cars to choose between: paired and offering Android Auto but missing from the page's own paired list; never the selected one,
+// never twice, not while pairing. (The page lists the rest itself in the pairing step.)
 {
   const runtime = { running: false, state: "idle", car_candidates: [{ address: "AA:BB:CC:DD:EE:01", name: "Civic" }, { address: "AA:BB:CC:DD:EE:02", name: "Truck" }] }
   const receivers = [{ address: "AA:BB:CC:DD:EE:02", name: "Truck" }, { address: "AA:BB:CC:DD:EE:03", name: "Wagon" }, null, { address: 5, name: "x" }]
   const names = (state) => state.candidates.map((car) => car.name)
-  assert.deepEqual(names(guidedState({ setup, runtime, receivers, carType: "builtin" })), ["Civic", "Truck", "Wagon"])
-  assert.deepEqual(names(guidedState({ setup, runtime, receivers, carType: "builtin", selected: { address: "AA:BB:CC:DD:EE:01", name: "Civic" } })), ["Truck", "Wagon"])
+  assert.deepEqual(names(guidedState({ setup, runtime, receivers, carType: "builtin" })), ["Civic"])
+  assert.deepEqual(names(guidedState({ setup, runtime, receivers: [], carType: "builtin" })), ["Civic", "Truck"])
+  assert.deepEqual(names(guidedState({ setup, runtime, receivers, carType: "builtin", selected: { address: "AA:BB:CC:DD:EE:01", name: "Civic" } })), [])
   assert.deepEqual(names(guidedState({ setup, runtime, receivers, carType: "builtin", pairingActive: true })), [])
   assert.deepEqual(names(guidedState({ setup, runtime, receivers, carType: "usb" })), [])  // a cable has no cars to pair
 }
@@ -93,7 +97,7 @@ assert.equal(guidedState({ setup: null, runtime: running("rfcomm") }).show, fals
 
 // The component emits the page's actions and never invents state.
 {
-  assert.deepEqual(StarPortGuidedSetup.emits, ["choose-type", "use-car", "classic"])
+  assert.deepEqual(StarPortGuidedSetup.emits, ["choose-type", "choose-adapter", "choose-app", "use-car", "classic", "done"])
   const template = StarPortGuidedSetup.template
   assert.match(template, /\$emit\('choose-type', choice\.key\)/)
   assert.match(template, /\$emit\('use-car', car\.address\)/)
@@ -124,7 +128,7 @@ assert.equal(guidedState({ setup: null, runtime: running("rfcomm") }).show, fals
 {
   const template = StarPortPage.template
   assert.match(template, /<StarPortGuidedSetup v-if="setup && newSetup && guided\.show"/)
-  assert.match(template, /@choose-type="chooseType" @use-car="useCar" @classic="useClassic"/)
+  assert.match(template, /@choose-type="chooseType" @choose-adapter="chooseAdapter" @choose-app="chooseApp" @use-car="useCar" @classic="useClassic"/)
   assert.match(template, /Try the guided setup/)
   const vm = { setup: { newSetup: false } }
   assert.equal(StarPortPage.computed.newSetup.call(vm), false)
@@ -137,13 +141,75 @@ console.log("StarPort guided setup: question, steps, candidates, live checklist,
 {
   const { BLUETOOTH_HINT } = await import("../web/js/starport-guided.js")
   const refused = { running: false, state: "error", error: "Connect your paired car in Galaxy Bluetooth first to select it for this Android Auto adapter" }
-  const state = guidedState({ setup, runtime: refused, carType: "adapter", labels })
+  const state = guidedState({ setup, runtime: refused, carType: "adapter" })
   assert.equal(state.phase, "setup")      // the usual question and steps stay, with the action first
   assert.deepEqual(state.hint, BLUETOOTH_HINT)
   assert.equal(BLUETOOTH_HINT.href, "#/bluetooth")
   const done = guidedState({ setup, runtime: refused, setupDone: true })
   assert.equal(done.phase, "bluetooth")   // even a finished setup shows the thing to fix
-  assert.equal(guidedState({ setup, runtime: { running: false, state: "error", error: "something else" }, carType: "adapter", labels }).hint, null)
+  assert.equal(guidedState({ setup, runtime: { running: false, state: "error", error: "something else" }, carType: "adapter" }).hint, null)
   assert.match(StarPortGuidedSetup.template, /state\.hint\.href/)
 }
 console.log("StarPort guided setup: Bluetooth-first hint passed")
+
+// The three steps are always shown, and follow the setup along.
+{
+  const states = (input) => guidedState({ setup, ...input }).steps.map((step) => step.state)
+  const labels = (input) => guidedState({ setup, ...input }).steps.map((step) => step.label)
+  assert.deepEqual(guidedState({ setup: { identity: { installed: false } } }).steps.map((step) => step.state), ["current", "todo", "todo"])
+  assert.deepEqual(states({ runtime: null }), ["done", "current", "todo"])
+  assert.deepEqual(states({ runtime: null, setupDone: true, editing: true }), ["done", "done", "current"])
+  assert.deepEqual(states({ runtime: running("wifi_start"), setupDone: true }), ["done", "done", "current"])
+  assert.deepEqual(states({ runtime: running("streaming"), setupDone: true }), ["done", "done", "done"])
+  assert.deepEqual(labels({ carType: "builtin" }), ["Support", "Car", "Connect"])
+  assert.deepEqual(labels({ carType: "adapter" }), ["Support", "Adapter", "Connect"])
+  assert.equal(labels({ carType: "usb" })[1], "Cable")
+  assert.equal(labels({ carType: "app" })[1], "App")
+  // Every phase carries them, including the Bluetooth-first refusal and a connection in progress.
+  for (const input of [{ runtime: running("rfcomm") }, { runtime: null }, { runtime: { running: false, error: "Connect your paired car in Galaxy Bluetooth first" }, setupDone: true }]) {
+    assert.equal(guidedState({ setup, ...input }).steps.length, 3)
+  }
+}
+
+// The adapter model and the app are picked in the card, not from a dropdown.
+{
+  const adapter = guidedState({ setup, runtime: null, carType: "adapter", adapterModels, adapterKey: "" })
+  assert.deepEqual(adapter.adapter.options.map((option) => option.label), ["AAWireless", "Motorola MA1", "Unofficial dongle"])
+  assert.equal(adapter.adapter.needsChoice, true)
+  const chosen = guidedState({ setup, runtime: null, carType: "adapter", adapterModels, adapterKey: "aawireless" })
+  assert.deepEqual(chosen.adapter.options.map((option) => option.selected), [true, false, false])
+  assert.equal(chosen.adapter.needsChoice, false)
+  assert.equal(guidedState({ setup, runtime: null, carType: "builtin", adapterModels }).adapter, null)
+  const apps = guidedState({ setup, runtime: null, carType: "app", appModels, app: "HeadunitPad" })
+  assert.deepEqual(apps.apps.options.map((option) => [option.key, option.selected]), [["headunitpad", true], ["openheadunit", false]])
+  assert.equal(guidedState({ setup, runtime: null, carType: "app", appModels, app: "" }).apps.needsChoice, true)
+  assert.equal(guidedState({ setup, runtime: null, carType: "usb", appModels }).apps, null)
+}
+
+// A finished setup can be reopened from the home card; Done closes it.
+{
+  const reopened = guidedState({ setup, runtime: { running: false, state: "idle" }, setupDone: true, editing: true })
+  assert.equal(reopened.show, true)
+  assert.equal(reopened.editing, true)
+  assert.equal(reopened.title, "Change how your car connects")
+  assert.equal(guidedState({ setup, runtime: { running: false, state: "idle" }, setupDone: true, editing: false }).show, false)
+  assert.match(StarPortGuidedSetup.template, /\$emit\('done'\)/)
+}
+
+// Dropdowns belong to the classic screens only; the guided card replaces them and keeps pairing, steps and Connect.
+{
+  const template = StarPortPage.template
+  const guidedBlock = template.slice(template.indexOf("<StarPortGuidedSetup"), template.indexOf("</StarPortGuidedSetup>"))
+  for (const dropdown of [":row=\"carTypeRow\"", ":row=\"adapterRow\"", ":row=\"appRow\""]) assert.ok(!guidedBlock.includes(dropdown), dropdown)
+  assert.match(guidedBlock, /<template #car>/)
+  assert.match(guidedBlock, /beginPairing/)         // Find car / Find adapter
+  assert.match(guidedBlock, /@click="connect"/)      // the Connect button
+  assert.match(guidedBlock, /Stuck pairing\?/)       // the pairing help stays
+  assert.match(template, /<ol v-if="setup && !newSetup" id="gx-starport-steps"/)   // the classic step 2, with its dropdown
+  const home = template.slice(template.indexOf("gx-starport-home\" aria-labelledby"))
+  assert.match(home, /<template v-if="!newSetup">\s*<GalaxySettingRow :row="carTypeRow"/)
+  assert.match(StarPortGuidedSetup.template, /gx-guided__steps/)
+  assert.match(StarPortGuidedSetup.template, /<slot name="car" \/>/)
+  assert.match(StarPortGuidedSetup.template, /<slot name="connect" \/>/)
+}
+console.log("StarPort guided setup: steps, adapter and app choices, reopening and classic-only dropdowns passed")
diff --git a/openpilot/starpilot/galaxy/web/css/galaxy.css b/openpilot/starpilot/galaxy/web/css/galaxy.css
index 9acb3f539f..5f3e5f7d46 100644
--- a/openpilot/starpilot/galaxy/web/css/galaxy.css
+++ b/openpilot/starpilot/galaxy/web/css/galaxy.css
@@ -1714,10 +1714,6 @@ input[type="checkbox"]:disabled { opacity: .4; cursor: not-allowed; }
 /* A section title inside a settings page: a label only, never dimmed like an unavailable control. */
 .gx-row.gx-row--heading, .gx-row.gx-row--heading.disabled { opacity: 1; padding-top: 1.25rem; }
 .gx-row--heading .gx-row__label { font-weight: 700; letter-spacing: .04em; text-transform: uppercase; opacity: .75; }
-/* Guided StarPort setup: the one question about how the car connects. */
-.gx-starport-guided__choices { display: grid; gap: .5rem; grid-template-columns: repeat(auto-fit, minmax(13rem, 1fr)); }
-.gx-starport-guided__choice { display: flex; flex-direction: column; align-items: flex-start; gap: .2rem; text-align: left; height: auto; padding: .7rem .9rem; }
-.gx-starport-guided__choice small { font-weight: 400; opacity: .75; white-space: normal; }
 .gx-row--wrap { flex-wrap: wrap; }
 .gx-row__info.gx-row__info--wide { flex: 1 1 180px; }
 .gx-filter-field { flex: 1 1 14rem; min-width: 0; }
@@ -2005,3 +2001,166 @@ progress { max-width: 100%; accent-color: var(--primary); }
   .gx-tuner__diagnostics { grid-template-columns: 1fr; gap: 5px; }
   .gx-tuner__diagnostics dd { margin-bottom: 12px; }
 }
+
+/* Guided StarPort setup. Apple-style geometry and type on Galaxy's own colors, so light and dark both follow the theme. */
+.gx-card.gx-guided {
+  --g-ink: var(--on-surface);
+  --g-muted: var(--on-surface-variant);
+  --g-fill: color-mix(in srgb, var(--on-surface) 7%, transparent);
+  --g-fill-hover: color-mix(in srgb, var(--on-surface) 11%, transparent);
+  --g-line: color-mix(in srgb, var(--on-surface) 11%, transparent);
+  --g-track: color-mix(in srgb, var(--on-surface) 16%, var(--background));  /* opaque, so overlapping segments never show a seam */
+  --g-accent: var(--primary);
+  --g-done: #30d158;
+  --g-thumb: rgba(255, 255, 255, .18);
+  --g-ease: cubic-bezier(.32, .72, 0, 1);
+  display: grid; gap: 24px; padding: 28px 28px 24px; border-radius: 28px; margin-block: 16px;
+  font-family: -apple-system, BlinkMacSystemFont, "SF Pro Text", "Inter", system-ui, "Segoe UI", sans-serif;
+  font-size: 16px; line-height: 1.4; color: var(--g-ink); -webkit-font-smoothing: antialiased;
+}
+[data-theme="light"] .gx-card.gx-guided { --g-done: #248a3d; --g-thumb: #fff; }
+
+/* The step track: three numbered nodes on a line that fills as the setup moves along. */
+.gx-guided__steps { list-style: none; margin: 0; padding: 0; display: grid; grid-template-columns: repeat(3, 1fr); position: relative; counter-reset: none; }
+.gx-guided__step { position: relative; display: grid; justify-items: center; gap: 8px; text-align: center; }
+.gx-guided__step::before, .gx-guided__step::after { content: ""; position: absolute; top: 15px; height: 2px; width: calc(50% - 8px); }
+.gx-guided__step::before { left: 0; background: var(--g-track); }
+.gx-guided__step::after  { right: 0; background: var(--g-track); }
+.gx-guided__step:first-child::before, .gx-guided__step:last-child::after { display: none; }
+.gx-guided__step.is-done::before, .gx-guided__step.is-done::after, .gx-guided__step.is-current::before { background: var(--g-done); }
+.gx-guided__step.is-done + .gx-guided__step::before { background: var(--g-done); }
+.gx-guided__node {
+  position: relative; z-index: 1; display: grid; place-items: center; width: 32px; height: 32px; border-radius: 50%;
+  font-size: 15px; font-weight: 600; font-variant-numeric: tabular-nums; background: var(--g-fill); color: var(--g-muted);
+  transition: background .3s var(--g-ease), color .3s var(--g-ease), box-shadow .3s var(--g-ease), transform .3s var(--g-ease);
+}
+.gx-guided__step.is-current .gx-guided__node { background: var(--g-accent); color: var(--on-primary); box-shadow: 0 0 0 5px color-mix(in srgb, var(--g-accent) 24%, transparent); }
+.gx-guided__step.is-done .gx-guided__node { background: var(--g-done); color: #fff; animation: gx-guided-pop .35s var(--g-ease); }
+.gx-guided__step-label { font-size: 13px; font-weight: 600; letter-spacing: -.005em; color: var(--g-muted); }
+.gx-guided__step.is-current .gx-guided__step-label { color: var(--g-ink); }
+@keyframes gx-guided-pop { 0% { transform: scale(.7); } 60% { transform: scale(1.12); } 100% { transform: scale(1); } }
+.gx-guided__sr { position: absolute; width: 1px; height: 1px; overflow: hidden; clip-path: inset(50%); white-space: nowrap; }
+
+.gx-guided__header { display: grid; gap: 6px; max-width: 34rem; }
+.gx-guided__title { margin: 0; font-size: 30px; line-height: 1.12; font-weight: 650; letter-spacing: -.024em; text-wrap: balance; }
+.gx-guided__lede { margin: 0; font-size: 17px; line-height: 1.45; color: var(--g-muted); text-wrap: pretty; }
+
+.gx-guided__section { display: grid; gap: 10px; }
+.gx-guided__subhead { margin: 0 0 0 4px; font-size: 15px; font-weight: 600; letter-spacing: -.01em; color: var(--g-muted); }
+.gx-guided__hint { margin: 0 4px; font-size: 14px; color: var(--g-muted); }
+
+/* Inset grouped lists, as in iOS Settings. */
+.gx-guided__group { list-style: none; margin: 0; padding: 0; background: var(--g-fill); border-radius: 18px; overflow: hidden; }
+.gx-guided__group > li { position: relative; }
+.gx-guided__group > li + li::before { content: ""; position: absolute; top: 0; left: 70px; right: 0; height: 1px; background: var(--g-line); }
+.gx-guided__option, .gx-guided__car, .gx-guided__checklist > li {
+  display: flex; align-items: center; gap: 14px; width: 100%; min-height: 60px; padding: 10px 16px; box-sizing: border-box;
+  background: none; border: 0; color: inherit; font: inherit; text-align: left;
+}
+.gx-guided__checklist > li { min-height: 52px; }
+.gx-guided__option { cursor: pointer; transition: background .2s var(--g-ease); }
+.gx-guided__option:hover:not(:disabled) { background: var(--g-fill-hover); }
+.gx-guided__option:active:not(:disabled) { background: var(--g-line); }
+.gx-guided__option:disabled { cursor: default; opacity: .6; }
+.gx-guided__option:focus-visible, .gx-guided__segmented button:focus-visible, .gx-guided__link:focus-visible {
+  outline: 3px solid color-mix(in srgb, var(--g-accent) 70%, transparent); outline-offset: -3px; border-radius: 14px;
+}
+.gx-guided__text { display: grid; gap: 1px; min-width: 0; flex: 1; }
+.gx-guided__text strong { font-size: 16px; font-weight: 590; letter-spacing: -.01em; }
+.gx-guided__text small { font-size: 14px; line-height: 1.3; color: var(--g-muted); }
+.gx-guided__tile {
+  flex: none; display: grid; place-items: center; width: 40px; height: 40px; border-radius: 10px; color: #fff; font-size: 20px;
+  box-shadow: inset 0 0 0 1px rgba(255, 255, 255, .14);
+}
+.gx-guided__tile.is-blue { background: linear-gradient(180deg, #4aa3ff, #0a84ff); }
+.gx-guided__tile.is-orange { background: linear-gradient(180deg, #ffb84a, #ff9f0a); }
+.gx-guided__tile.is-gray { background: linear-gradient(180deg, #a1a1a6, #7c7c82); }
+.gx-guided__tile.is-purple { background: linear-gradient(180deg, #d58cff, #bf5af2); }
+.gx-guided__radio {
+  flex: none; display: grid; place-items: center; width: 24px; height: 24px; border-radius: 50%; font-size: 14px; color: transparent;
+  border: 1.5px solid color-mix(in srgb, var(--on-surface) 28%, transparent); transition: background .25s var(--g-ease), border-color .25s var(--g-ease);
+}
+.gx-guided__option[aria-checked="true"] .gx-guided__radio { background: var(--g-accent); border-color: var(--g-accent); color: var(--on-primary); }
+.gx-guided__option[aria-checked="true"] .gx-guided__text strong { color: var(--g-ink); }
+
+/* Segmented control for the adapter and app choices. */
+.gx-guided__segmented { display: flex; gap: 2px; padding: 3px; background: var(--g-fill); border-radius: 12px; }
+.gx-guided__segmented button {
+  flex: 1; min-height: 44px; padding: 6px 8px; border: 0; border-radius: 9px; background: none; color: var(--g-muted);
+  font: inherit; font-size: 15px; font-weight: 560; line-height: 1.2; text-wrap: balance; cursor: pointer; transition: background .25s var(--g-ease), color .25s var(--g-ease), box-shadow .25s var(--g-ease);
+}
+.gx-guided__segmented button.is-selected { background: var(--g-thumb); color: var(--g-ink); box-shadow: 0 1px 3px rgba(0, 0, 0, .22), 0 0 0 .5px rgba(0, 0, 0, .06); }
+.gx-guided__segmented button:disabled { opacity: .6; cursor: default; }
+.gx-guided__segmented button:not(.is-selected):hover:not(:disabled) { color: var(--g-ink); }
+
+/* Live checklist. */
+.gx-guided__mark { flex: none; display: grid; place-items: center; width: 28px; font-size: 22px; color: color-mix(in srgb, var(--on-surface) 30%, transparent); }
+.gx-guided__checklist > li.is-done .gx-guided__mark, .gx-guided__checklist > li.is-worked .gx-guided__mark { color: var(--g-done); animation: gx-guided-pop .35s var(--g-ease); }
+.gx-guided__checklist > li.is-active .gx-guided__mark, .gx-guided__checklist > li.is-current .gx-guided__mark, .gx-guided__checklist > li.is-retry .gx-guided__mark { color: var(--g-accent); }
+.gx-guided__checklist > li.is-failed .gx-guided__mark { color: var(--error); }
+.gx-guided__checklist > li.is-waiting .gx-guided__text strong, .gx-guided__checklist > li.is-skipped .gx-guided__text strong { color: var(--g-muted); font-weight: 500; }
+.gx-guided__spinner { width: 20px; height: 20px; }
+.gx-guided__checklist.gx-guided__group > li + li::before { left: 58px; }
+
+.gx-guided__disclosure { background: var(--g-fill); border-radius: 18px; overflow: hidden; }
+.gx-guided__disclosure > summary { list-style: none; cursor: pointer; padding: 14px 16px; font-size: 15px; font-weight: 590; display: flex; justify-content: space-between; align-items: center; }
+.gx-guided__disclosure > summary::-webkit-details-marker { display: none; }
+.gx-guided__disclosure > summary::after { content: "\203A"; font-size: 22px; color: var(--g-muted); transition: transform .25s var(--g-ease); }
+.gx-guided__disclosure[open] > summary::after { transform: rotate(90deg); }
+.gx-guided__disclosure .gx-guided__group { border-radius: 0; background: none; border-top: 1px solid var(--g-line); }
+
+.gx-guided__callout {
+  display: flex; align-items: center; justify-content: space-between; gap: 14px; flex-wrap: wrap; margin: 0; padding: 14px 16px;
+  border-radius: 16px; background: color-mix(in srgb, var(--g-accent) 14%, transparent); font-size: 15px; line-height: 1.4;
+}
+.gx-guided__callout--quiet { background: var(--g-fill); color: var(--g-muted); display: block; }
+
+/* The page's own pairing, cable and app content arrives through the car slot; it takes the same look here. */
+.gx-guided__body { display: grid; gap: 14px; }
+.gx-guided__body:empty { display: none; }
+.gx-guided .gx-starport-list { list-style: none; margin: 0; padding: 0; background: var(--g-fill); border-radius: 18px; overflow: hidden; box-shadow: none; border: 0; }
+.gx-guided .gx-starport-row { display: flex; align-items: center; gap: 14px; min-height: 56px; padding: 10px 16px; background: none; border: 0; border-radius: 0; }
+.gx-guided .gx-starport-list > li + li, .gx-guided .gx-starport-list > .gx-starport-row + .gx-starport-row { border-top: 1px solid var(--g-line); }
+.gx-guided .gx-starport-row__text { display: grid; gap: 1px; min-width: 0; flex: 1; }
+.gx-guided .gx-starport-row__text strong { font-size: 16px; font-weight: 590; }
+.gx-guided .gx-starport-row__text small { font-size: 14px; color: var(--g-muted); }
+.gx-guided .gx-starport-row > i.bi { font-size: 20px; color: var(--g-muted); }
+.gx-guided .gx-starport-ok { color: var(--g-done) !important; }
+.gx-guided .gx-starport-pill { border-radius: 999px; padding: 4px 12px; font-size: 13px; font-weight: 600; background: var(--g-fill-hover); color: var(--g-muted); border: 0; }
+.gx-guided .gx-starport-pill--ready { background: color-mix(in srgb, var(--g-done) 20%, transparent); color: var(--g-done); }
+.gx-guided .gx-note, .gx-guided .gx-notice, .gx-guided .gx-starport-guide { margin: 0; padding: 14px 16px; border-radius: 16px; background: var(--g-fill); font-size: 15px; line-height: 1.45; border: 0; }
+.gx-guided .gx-starport-prompt { padding: 18px; border-radius: 18px; background: var(--g-fill); display: grid; gap: 10px; border: 0; }
+.gx-guided .gx-starport-prompt__code { font-size: 34px; letter-spacing: .12em; font-weight: 650; font-variant-numeric: tabular-nums; }
+.gx-guided .gx-starport-wiki { background: var(--g-fill); border-radius: 16px; padding: 0; border: 0; overflow: hidden; }
+.gx-guided .gx-starport-wiki > summary { padding: 14px 16px; font-size: 15px; font-weight: 560; cursor: pointer; color: var(--g-ink); }
+.gx-guided .gx-starport-wiki > :not(summary) { margin-inline: 16px; font-size: 14px; line-height: 1.5; }
+.gx-guided .gx-starport-wiki > :last-child { margin-bottom: 16px; }
+.gx-guided .gx-field { min-height: 44px; border-radius: 12px; }
+.gx-guided .gx-actions, .gx-guided .gx-driving__actions { display: flex; gap: 10px; flex-wrap: wrap; margin: 0; }
+.gx-guided .gx-row { background: var(--g-fill); border: 0; border-radius: 18px; padding: 12px 16px; }
+
+/* Buttons: pill-shaped primary, soft tonal. */
+.gx-guided .gx-btn { min-height: 44px; border-radius: 12px; font-size: 16px; font-weight: 590; letter-spacing: -.01em; padding-inline: 18px; box-shadow: none; }
+.gx-guided .gx-btn--tonal { background: var(--g-fill-hover); color: var(--g-ink); border: 0; }
+.gx-guided .gx-btn--tonal:hover:not(:disabled) { background: var(--g-line); }
+.gx-guided .gx-starport-cta { width: 100%; min-height: 54px; border-radius: 16px; font-size: 17px; }
+.gx-guided__footer { display: grid; gap: 12px; justify-items: stretch; }
+.gx-guided__footer .gx-guided__hint { text-align: center; }
+.gx-guided__link { justify-self: center; padding: 8px 12px; border: 0; background: none; color: var(--g-accent); font: inherit; font-size: 15px; font-weight: 560; cursor: pointer; }
+.gx-guided__link:hover:not(:disabled) { text-decoration: underline; }
+.gx-guided__link:disabled { opacity: .5; cursor: default; }
+
+@media (max-width: 640px) {
+  .gx-card.gx-guided { padding: 22px 16px 18px; border-radius: 24px; gap: 20px; }
+  .gx-guided__title { font-size: 26px; }
+  .gx-guided__lede { font-size: 16px; }
+  .gx-guided__segmented button { font-size: 14px; }
+  .gx-guided__option, .gx-guided__car, .gx-guided__checklist > li { padding-inline: 14px; gap: 12px; }
+  .gx-guided__group > li + li::before { left: 66px; }
+  .gx-guided__checklist.gx-guided__group > li + li::before { left: 54px; }
+  .gx-guided .gx-starport-cta { min-height: 56px; }
+}
+@media (prefers-reduced-motion: reduce) {
+  .gx-guided__node, .gx-guided__option, .gx-guided__radio, .gx-guided__segmented button, .gx-guided__disclosure > summary::after { transition: none; }
+  .gx-guided__step.is-done .gx-guided__node, .gx-guided__checklist > li.is-done .gx-guided__mark, .gx-guided__checklist > li.is-worked .gx-guided__mark { animation: none; }
+}
diff --git a/openpilot/starpilot/galaxy/web/js/starport-guided.js b/openpilot/starpilot/galaxy/web/js/starport-guided.js
index 798b7c2cca..d5afa79ba7 100644
--- a/openpilot/starpilot/galaxy/web/js/starport-guided.js
+++ b/openpilot/starpilot/galaxy/web/js/starport-guided.js
@@ -1,27 +1,31 @@
-// The guided StarPort setup: one question (how does the car connect), only the steps for that answer, and a live checklist of
+// The guided StarPort setup. Three steps (support, car, connect), one choice about how the car connects, and a live checklist of
 // what is being tried while connecting. It reads the daemon status the page already has and drives the page's existing actions,
-// so it adds no new state of its own. Turned off, the classic screens come back ("Use classic setup").
+// so it adds no state of its own. The pairing, cable and app instructions are the page's own and arrive through the `car` slot;
+// the Connect button arrives through the `connect` slot. Turned off, the classic screens come back ("Use classic setup").
 
 export const FIRST_RUN_NOTICE = "The first connection can take a few minutes, and sometimes more than one drive, while we find what your car accepts. Keep the car on and its screen awake. Later connections are much faster because we remember what worked."
+export const EXHAUSTED_NOTICE = "We tried every option we have this drive. We keep what works best and will try again the next time the car starts."
+
 // The adapter flow refuses to continue until the car itself is connected in Galaxy Bluetooth (27 Bugsink reports, 7 devices).
 export const BLUETOOTH_FIRST = /connect your paired car in galaxy bluetooth first/i
 export const BLUETOOTH_HINT = { text: "Connect your car in Bluetooth first, then come back and tap Connect.", href: "#/bluetooth", label: "Open Bluetooth" }
-export const EXHAUSTED_NOTICE = "We tried every option we have this drive. We keep what works best and will try again the next time the car starts."
 
 const CHOICES = [
-  { key: "builtin", detail: "The car connects to Android Auto wirelessly by itself." },
-  { key: "adapter", detail: "A USB adapter such as AAWireless or Motorola MA1 plugged into the car." },
-  { key: "usb", detail: "A USB data cable from the car to the comma." },
-  { key: "app", detail: "An app on an iPad or Android tablet shows the dashboard." },
+  { key: "builtin", title: "Built-in wireless", detail: "Your car has wireless Android Auto.", icon: "car-front-fill", tone: "blue" },
+  { key: "adapter", title: "Wireless adapter", detail: "AAWireless, Motorola MA1 or similar, plugged into the car.", icon: "usb-plug-fill", tone: "orange" },
+  { key: "usb", title: "USB cable", detail: "A data cable from the car to your comma.", icon: "usb-c-fill", tone: "gray" },
+  { key: "app", title: "Tablet app", detail: "An iPad or Android tablet shows the dashboard.", icon: "tablet-fill", tone: "purple" },
 ]
 
 const INSTRUCTIONS = {
-  builtin: "Open your car’s phone pairing screen, then tap Find car in the pairing step below.",
-  adapter: "Put the adapter in pairing mode, choose its model below, then tap Find adapter.",
-  usb: "Connect the car’s Android Auto USB data port to the comma with a data cable, then tap Connect.",
-  app: "Choose your app below, open it on your tablet on the same Wi-Fi, then tap Connect.",
+  builtin: "Open your car’s phone pairing screen, then tap Find car below.",
+  adapter: "Choose your adapter, put it in pairing mode, then tap Find adapter.",
+  usb: "Plug the car’s Android Auto USB data port into the comma, then tap Connect.",
+  app: "Choose your app, open it on your tablet on the same Wi-Fi, then tap Connect.",
 }
 
+const CAR_STEP_LABEL = { builtin: "Car", adapter: "Adapter", usb: "Cable", app: "App" }
+
 const STAGES = {
   wireless: [
     { id: "bluetooth", label: "Reach the car over Bluetooth", states: ["connecting_bluetooth", "discovering", "rfcomm"] },
@@ -64,14 +68,29 @@ export function handshakeSteps(ladder) {
   return interesting ? steps.map((step) => ({ id: String(step.id), label: step.label, state: String(step.state) })) : []
 }
 
+// The three steps always shown at the top: the package, the car (choice and pairing), and the connection.
+export function setupSteps({ installed, carDone, live, carType }) {
+  const state = (done, current) => (done ? "done" : current ? "current" : "todo")
+  return [
+    { id: "support", label: "Support", state: state(installed, !installed) },
+    { id: "car", label: CAR_STEP_LABEL[carType] || "Car", state: state(installed && carDone, installed && !carDone) },
+    { id: "connect", label: "Connect", state: state(live, installed && carDone && !live) },
+  ]
+}
+
+function options(models, chosen) {
+  return Object.entries(models || {}).map(([key, label]) => ({ key, label: String(label), selected: key === chosen }))
+}
+
 export function guidedState({ setup = null, runtime = null, selected = null, receivers = [], wired = false, app = "", carType = "builtin",
-  setupDone = false, pairingActive = false, labels = {} } = {}) {
+  setupDone = false, pairingActive = false, editing = false, adapterModels = {}, adapterKey = "", appModels = {} } = {}) {
   const ladder = runtime?.setup_ladder || null
   const state = runtime?.state || "idle"
   const connecting = !!runtime?.running && CONNECTING.has(state)
   const installed = !!setup?.identity?.installed
+  const steps = setupSteps({ installed, carDone: setupDone, live: state === "streaming", carType })
   const base = { show: false, phase: "live", title: "", detail: "", choices: [], carType, candidates: [], progress: [], handshake: [],
-    notice: "", exhausted: false, hint: null }
+    notice: "", exhausted: false, hint: null, steps, adapter: null, apps: null, editing: false }
   if (setup === null) return base
   const hint = BLUETOOTH_FIRST.test(String(runtime?.error || "")) ? BLUETOOTH_HINT : null
   if (connecting) {
@@ -81,77 +100,134 @@ export function guidedState({ setup = null, runtime = null, selected = null, rec
       progress: connectionStages(runtime), handshake: handshakeSteps(ladder), exhausted: !!ladder?.exhausted,
       notice: ladder?.exhausted ? EXHAUSTED_NOTICE : firstRun ? FIRST_RUN_NOTICE : "", hint }
   }
-  if (setupDone) {
+  if (setupDone && !editing) {
     // A finished setup shows nothing, except a refusal that is the one thing to act on.
     return hint ? { ...base, show: true, phase: "bluetooth", title: "Your car needs to be connected in Bluetooth first", detail: hint.text, hint } : base
   }
   if (!installed) {
-    return { ...base, show: true, phase: "package", title: "Start by adding your Android Auto package",
-      detail: "Your car only talks to devices that present Google’s Android Auto certificate. Follow step 1 below, then come back here." }
+    return { ...base, show: true, phase: "package", title: "Add your Android Auto package",
+      detail: "Your car only talks to devices that present Google’s Android Auto certificate. Follow the support step above, then come back here." }
   }
-  const choices = CHOICES.map((choice) => ({ ...choice, label: labels[choice.key] || choice.key, selected: choice.key === carType }))
-  const known = new Set(selected ? [selected.address] : [])
+  const choices = CHOICES.map((choice) => ({ ...choice, selected: choice.key === carType }))
+  const known = new Set([...(selected ? [selected.address] : []), ...(Array.isArray(receivers) ? receivers : []).map((car) => car?.address)])
   const candidates = []
-  for (const car of [...(Array.isArray(runtime?.car_candidates) ? runtime.car_candidates : []), ...(Array.isArray(receivers) ? receivers : [])]) {
+  // Paired cars the page's own list does not show yet; the page lists the rest itself in the pairing step.
+  for (const car of Array.isArray(runtime?.car_candidates) ? runtime.car_candidates : []) {
     if (car && typeof car.address === "string" && typeof car.name === "string" && !known.has(car.address)) {
       known.add(car.address)
       candidates.push({ address: car.address, name: car.name })
     }
   }
   const pairs = carType === "builtin" || carType === "adapter"
-  return { ...base, show: true, phase: "setup", title: "How does your car connect to Android Auto?",
-    detail: INSTRUCTIONS[carType] || INSTRUCTIONS.builtin, choices, candidates: pairs && !pairingActive ? candidates : [], hint }
+  return { ...base, show: true, phase: "setup", title: editing ? "Change how your car connects" : "Set up your car",
+    detail: INSTRUCTIONS[carType] || INSTRUCTIONS.builtin, choices, candidates: pairs && !pairingActive ? candidates : [], hint, editing,
+    adapter: carType === "adapter" ? { options: options(adapterModels, adapterKey), needsChoice: !adapterKey } : null,
+    apps: carType === "app" ? { options: options(appModels, Object.keys(appModels).find((key) => appModels[key] === app) || ""), needsChoice: !app } : null }
 }
 
 export const StarPortGuidedSetup = {
   props: { state: { type: Object, required: true }, busy: { type: Boolean, default: false } },
-  emits: ["choose-type", "use-car", "classic"],
+  emits: ["choose-type", "choose-adapter", "choose-app", "use-car", "classic", "done"],
   template: `
-    <section class="gx-card gx-starport-guided" aria-label="Guided StarPort setup">
-      <div class="gx-starport-step__head">
-        <div><h3>{{ state.title }}</h3><p>{{ state.detail }}</p></div>
+    <section class="gx-card gx-guided" :data-phase="state.phase" aria-label="Guided StarPort setup">
+      <ol class="gx-guided__steps" aria-label="Setup progress">
+        <li v-for="(step, index) in state.steps" :key="step.id" class="gx-guided__step" :class="'is-' + step.state"
+            :aria-current="step.state === 'current' ? 'step' : undefined">
+          <span class="gx-guided__node" aria-hidden="true"><i v-if="step.state === 'done'" class="bi bi-check-lg"></i><template v-else>{{ index + 1 }}</template></span>
+          <span class="gx-guided__step-label">{{ step.label }}<span class="gx-guided__sr">{{ step.state === 'done' ? ', done' : step.state === 'current' ? ', current step' : '' }}</span></span>
+        </li>
+      </ol>
+
+      <header class="gx-guided__header">
+        <h2 class="gx-guided__title">{{ state.title }}</h2>
+        <p class="gx-guided__lede">{{ state.detail }}</p>
+      </header>
+
+      <div v-if="state.choices.length" class="gx-guided__section">
+        <ul class="gx-guided__group" role="radiogroup" aria-label="How your car connects">
+          <li v-for="choice in state.choices" :key="choice.key">
+            <button type="button" class="gx-guided__option" role="radio" :aria-checked="choice.selected ? 'true' : 'false'"
+                :disabled="busy" @click="$emit('choose-type', choice.key)">
+              <span class="gx-guided__tile" :class="'is-' + choice.tone" aria-hidden="true"><i :class="'bi bi-' + choice.icon"></i></span>
+              <span class="gx-guided__text"><strong>{{ choice.title }}</strong><small>{{ choice.detail }}</small></span>
+              <span class="gx-guided__radio" aria-hidden="true"><i v-if="choice.selected" class="bi bi-check-lg"></i></span>
+            </button>
+          </li>
+        </ul>
       </div>
-      <div class="gx-starport-step__body">
-        <div v-if="state.choices.length" class="gx-starport-guided__choices" role="radiogroup" aria-label="How your car connects">
-          <button v-for="choice in state.choices" :key="choice.key" type="button" class="gx-btn gx-starport-guided__choice"
-              :class="choice.selected ? 'gx-btn--primary' : 'gx-btn--tonal'" role="radio" :aria-checked="choice.selected ? 'true' : 'false'"
-              :disabled="busy" @click="$emit('choose-type', choice.key)">
-            <strong>{{ choice.label }}</strong><small>{{ choice.detail }}</small>
-          </button>
+
+      <div v-if="state.adapter" class="gx-guided__section">
+        <h3 class="gx-guided__subhead">Which adapter?</h3>
+        <div class="gx-guided__segmented" role="radiogroup" aria-label="Adapter model">
+          <button v-for="option in state.adapter.options" :key="option.key" type="button" role="radio" :aria-checked="option.selected ? 'true' : 'false'"
+              :class="{ 'is-selected': option.selected }" :disabled="busy" @click="$emit('choose-adapter', option.key)">{{ option.label }}</button>
         </div>
-        <ul v-if="state.candidates.length" class="gx-starport-list" aria-label="Paired cars that offer Android Auto">
-          <li v-for="car in state.candidates" :key="car.address" class="gx-starport-row">
-            <i class="bi bi-car-front" aria-hidden="true"></i>
-            <span class="gx-starport-row__text"><strong>{{ car.name }}</strong><small>Paired and offers Android Auto</small></span>
+        <p v-if="state.adapter.needsChoice" class="gx-guided__hint">Choose your adapter to continue.</p>
+      </div>
+
+      <div v-if="state.apps" class="gx-guided__section">
+        <h3 class="gx-guided__subhead">Which app?</h3>
+        <div class="gx-guided__segmented" role="radiogroup" aria-label="Tablet app">
+          <button v-for="option in state.apps.options" :key="option.key" type="button" role="radio" :aria-checked="option.selected ? 'true' : 'false'"
+              :class="{ 'is-selected': option.selected }" :disabled="busy" @click="$emit('choose-app', option.key)">{{ option.label }}</button>
+        </div>
+        <p v-if="state.apps.needsChoice" class="gx-guided__hint">Choose your app to continue.</p>
+      </div>
+
+      <div v-if="state.candidates.length" class="gx-guided__section">
+        <h3 class="gx-guided__subhead">Paired cars</h3>
+        <ul class="gx-guided__group" aria-label="Paired cars that offer Android Auto">
+          <li v-for="car in state.candidates" :key="car.address" class="gx-guided__car">
+            <span class="gx-guided__tile is-blue" aria-hidden="true"><i class="bi bi-car-front-fill"></i></span>
+            <span class="gx-guided__text"><strong>{{ car.name }}</strong><small>Paired and offers Android Auto</small></span>
             <button type="button" class="gx-btn gx-btn--tonal" :disabled="busy" @click="$emit('use-car', car.address)">Use</button>
           </li>
         </ul>
-        <ol v-if="state.progress.length" class="gx-starport-list" aria-label="Connection progress">
-          <li v-for="step in state.progress" :key="step.id" class="gx-starport-row" :class="'gx-starport-row--' + step.state"
-              :aria-current="step.state === 'active' || step.state === 'retry' ? 'step' : undefined">
-            <i v-if="step.state === 'done'" class="bi bi-check-circle-fill gx-starport-ok" aria-hidden="true"></i>
-            <span v-else-if="step.state === 'active'" class="gx-spinner gx-starport-orbit gx-starport-orbit--small" aria-hidden="true"></span>
-            <i v-else-if="step.state === 'retry'" class="bi bi-arrow-repeat" aria-hidden="true"></i>
-            <i v-else class="bi bi-circle" aria-hidden="true"></i>
-            <span class="gx-starport-row__text"><strong>{{ step.label }}</strong><small v-if="step.state === 'retry'">Trying again</small></span>
+      </div>
+
+      <div v-if="state.hint" class="gx-guided__callout" role="status">
+        <span>{{ state.hint.text }}</span>
+        <a class="gx-btn gx-btn--tonal" :href="state.hint.href">{{ state.hint.label }}</a>
+      </div>
+
+      <div v-if="state.progress.length" class="gx-guided__section">
+        <ol class="gx-guided__group gx-guided__checklist" aria-label="Connection progress">
+          <li v-for="step in state.progress" :key="step.id" :class="'is-' + step.state" :aria-current="step.state === 'active' || step.state === 'retry' ? 'step' : undefined">
+            <span class="gx-guided__mark" aria-hidden="true">
+              <i v-if="step.state === 'done'" class="bi bi-check-circle-fill"></i>
+              <span v-else-if="step.state === 'active'" class="gx-spinner gx-guided__spinner"></span>
+              <i v-else-if="step.state === 'retry'" class="bi bi-arrow-repeat"></i>
+              <i v-else class="bi bi-circle"></i>
+            </span>
+            <span class="gx-guided__text"><strong>{{ step.label }}</strong><small v-if="step.state === 'retry'">Trying again</small></span>
           </li>
         </ol>
-        <details v-if="state.handshake.length" class="gx-starport-wiki" open>
-          <summary>What we are trying</summary>
-          <ol class="gx-starport-list" aria-label="Handshake options">
-            <li v-for="step in state.handshake" :key="step.id" class="gx-starport-row" :class="'gx-starport-row--' + step.state">
-              <i v-if="step.state === 'worked'" class="bi bi-check-circle-fill gx-starport-ok" aria-hidden="true"></i>
-              <i v-else-if="step.state === 'failed'" class="bi bi-x-circle" aria-hidden="true"></i>
-              <i v-else-if="step.state === 'skipped'" class="bi bi-dash-circle" aria-hidden="true"></i>
-              <span v-else-if="step.state === 'current'" class="gx-spinner gx-starport-orbit gx-starport-orbit--small" aria-hidden="true"></span>
-              <i v-else class="bi bi-circle" aria-hidden="true"></i>
-              <span class="gx-starport-row__text"><strong>{{ step.label }}</strong></span>
-            </li>
-          </ol>
-        </details>
-        <p v-if="state.hint" class="gx-note" role="status">{{ state.hint.text }} <a class="gx-btn gx-btn--tonal" :href="state.hint.href">{{ state.hint.label }}</a></p>
-        <p v-if="state.notice" class="gx-note" role="status">{{ state.notice }}</p>
-        <button type="button" class="gx-btn gx-btn--tonal" :disabled="busy" @click="$emit('classic')">Use classic setup</button>
+      </div>
+
+      <details v-if="state.handshake.length" class="gx-guided__disclosure" open>
+        <summary>What we are trying</summary>
+        <ol class="gx-guided__group gx-guided__checklist" aria-label="Handshake options">
+          <li v-for="step in state.handshake" :key="step.id" :class="'is-' + step.state">
+            <span class="gx-guided__mark" aria-hidden="true">
+              <i v-if="step.state === 'worked'" class="bi bi-check-circle-fill"></i>
+              <i v-else-if="step.state === 'failed'" class="bi bi-x-circle"></i>
+              <i v-else-if="step.state === 'skipped'" class="bi bi-dash-circle"></i>
+              <span v-else-if="step.state === 'current'" class="gx-spinner gx-guided__spinner"></span>
+              <i v-else class="bi bi-circle"></i>
+            </span>
+            <span class="gx-guided__text"><strong>{{ step.label }}</strong></span>
+          </li>
+        </ol>
+      </details>
+
+      <p v-if="state.notice" class="gx-guided__callout gx-guided__callout--quiet" role="status">{{ state.notice }}</p>
+
+      <div v-if="state.phase === 'setup'" class="gx-guided__body"><slot name="car" /></div>
+
+      <div class="gx-guided__footer">
+        <slot name="connect" />
+        <button v-if="state.editing" type="button" class="gx-guided__link" :disabled="busy" @click="$emit('done')">Done</button>
+        <button type="button" class="gx-guided__link" :disabled="busy" @click="$emit('classic')">Use classic setup</button>
       </div>
     </section>`,
 }
diff --git a/openpilot/starpilot/galaxy/web/js/starport.js b/openpilot/starpilot/galaxy/web/js/starport.js
index c357e4249d..86c368ff77 100644
--- a/openpilot/starpilot/galaxy/web/js/starport.js
+++ b/openpilot/starpilot/galaxy/web/js/starport.js
@@ -90,6 +90,82 @@ const APP_SETUP = `
       <li>Tap Connect here, then tap the WiFi button in Open Headunit.</li>
     </ol>
   </div>`
+const PAIR_UI = `
+            <ol v-if="adapterSetup" class="gx-starport-list" aria-label="Adapter pairing">
+              <li class="gx-starport-row">
+                <i class="bi bi-usb-symbol" aria-hidden="true"></i>
+                <span class="gx-starport-row__text"><strong>Adapter</strong><small>{{ selected ? selected.name : 'Put it in pairing mode, then tap Find adapter.' }}</small></span>
+                <span class="gx-starport-pill" :class="selected ? 'gx-starport-pill--ready' : ''">{{ selected ? 'Paired' : 'Not paired' }}</span>
+              </li>
+            </ol>
+            <GxNotice v-if="!pairing?.active && runtime?.pairing_note" tone="warn">{{ runtime.pairing_note }}</GxNotice>
+            <ul v-if="!pairing?.active && receivers.length" class="gx-starport-list" aria-label="Paired cars">
+              <li v-for="car in receivers" :key="car.address" class="gx-starport-row">
+                <i class="bi bi-car-front" aria-hidden="true"></i>
+                <span class="gx-starport-row__text"><strong>{{ car.name }}</strong><small>{{ selected?.address === car.address ? 'Used for Android Auto' : 'Paired' }}</small></span>
+                <span v-if="selected?.address === car.address" class="gx-starport-pill gx-starport-pill--ready"><i class="bi bi-check-lg"></i> Selected</span>
+                <button v-else class="gx-btn gx-btn--tonal" :disabled="!setup.parked || linked" @click="useCar(car.address)">Use</button>
+              </li>
+            </ul>
+            <p v-else-if="!pairing?.active && selected" class="gx-starport-row"><i class="bi bi-car-front" aria-hidden="true"></i><span class="gx-starport-row__text"><strong>{{ selected.name }}</strong><small>Used for Android Auto</small></span></p>
+            <p v-if="!pairing?.active && endReason === 'canceled'" class="gx-note" role="status">Pairing canceled. Start again when your car is ready.</p>
+            <p v-else-if="!pairing?.active && endReason" class="gx-note" role="status">The pairing window ended without choosing a car. Try again when your car’s pairing screen is open.</p>
+            <ol v-if="showPairSteps" class="gx-starport-list" aria-label="Pairing progress">
+              <li v-for="step in pairSteps" :key="step.label" class="gx-starport-row" :class="'gx-starport-row--' + step.status" :aria-current="step.status === 'active' ? 'step' : undefined">
+                <i v-if="step.status === 'done'" class="bi bi-check-circle-fill gx-starport-ok" aria-hidden="true"></i>
+                <span v-else-if="step.status === 'active'" class="gx-spinner gx-starport-orbit gx-starport-orbit--small" aria-hidden="true"></span>
+                <i v-else class="bi bi-circle" aria-hidden="true"></i>
+                <span class="gx-starport-row__text"><strong>{{ step.label }}</strong></span>
+              </li>
+            </ol>
+            <p v-if="waitingForCar" role="status">{{ pairing.discovering ? "Searching for nearby cars and adapters…" : "Choose your car or wireless adapter below." }}</p>
+            <p v-else-if="pairing?.active && pairing.approved && (!pairing.state || pairing.state === 'idle')" role="status">Approved {{ pairing.receiver?.name }}. Finishing Bluetooth pairing…</p>
+            <p v-if="pairing?.state === 'pairing' && !pairing.prompt && !pairing.approved" role="status">Pairing with {{ pairing.receiver?.name || 'the selected device' }}…</p>
+            <p v-if="pairing?.state === 'connecting'" role="status">Connecting to {{ pairing.receiver?.name || 'the selected device' }}…</p>
+            <p v-if="['paired', 'connected'].includes(pairing?.state)" role="status"><i class="bi bi-check-circle-fill gx-starport-ok"></i> {{ pairing.receiver?.name || 'Device' }} {{ pairing.state === 'connected' ? 'connected' : 'paired' }}.</p>
+            <GxNotice tone="danger" v-if="pairing?.error">{{ pairing.error }}</GxNotice>
+            <ul v-if="pairing?.active" class="gx-starport-list" aria-label="Nearby devices">
+              <li v-if="!pairing.devices?.length && waitingForCar" class="gx-starport-row gx-note" role="status"><span class="gx-spinner" aria-hidden="true"></span>Nothing found yet. Keep your car’s pairing screen open.</li>
+              <li v-for="device in pairing.devices || []" :key="device.address" class="gx-starport-row">
+                <i :class="device.starport ? 'bi bi-car-front' : 'bi bi-bluetooth'" aria-hidden="true"></i>
+                <span class="gx-starport-row__text"><strong>{{ device.name }}</strong><small>{{ device.starport ? 'StarPort ready' : 'Bluetooth device' }} · {{ device.connected ? 'Connected' : device.paired ? 'Paired before' : 'Nearby' }}</small></span>
+                <button class="gx-btn gx-btn--tonal" :disabled="deviceSelectionBlocked" @click="selectDevice(device.address)">{{ device.paired ? 'Connect' : 'Pair' }}</button>
+              </li>
+            </ul>
+            <div v-if="pairing?.prompt" class="gx-starport-prompt" role="status"><strong>{{ pairing.receiver.name }}</strong>
+              <p>{{ pairing.prompt.kind === 'confirmation' ? 'Check that this code matches your car, then confirm.' :
+                pairing.prompt.kind === 'pin' ? 'Enter the PIN shown by your car.' :
+                pairing.prompt.kind === 'passkey' ? 'Enter your car’s passkey.' :
+                pairing.prompt.kind === 'authorization' ? 'Allow this car to pair?' : 'Enter this code in your car.' }}</p>
+              <strong v-if="pairing.prompt.value" class="gx-starport-prompt__code">{{ pairing.prompt.value }}</strong>
+              <input v-if="['pin','passkey'].includes(pairing.prompt.kind)" class="gx-field" type="text" maxlength="16" autocomplete="off"
+                :inputmode="pairing.prompt.kind === 'passkey' ? 'numeric' : 'text'" :aria-label="pairing.prompt.kind === 'pin' ? 'Car PIN' : 'Car passkey'" v-model="pairValue" />
+              <div v-if="!pairing.prompt.displayOnly" class="gx-driving__actions gx-actions">
+                <button class="gx-btn gx-btn--tonal" @click="respond(false)">Reject</button>
+                <button class="gx-btn" :disabled="!canRespond" @click="respond(true)">{{ pairing.prompt.kind === 'pin' ? 'Send PIN' : pairing.prompt.kind === 'passkey' ? 'Send Passkey' : 'Confirm' }}</button></div>
+            </div>
+            <p v-if="pairWhenReady" class="gx-note" role="status"><span class="gx-spinner" aria-hidden="true"></span> Turning on Android Auto, then searching…</p>
+            <p v-else-if="!pairing?.active && pairingReason" class="gx-note" role="status">{{ pairingReason }}</p>
+            <div class="gx-driving__actions gx-actions">
+              <button v-if="!pairing?.active" class="gx-btn" :class="{ 'gx-btn--tonal': !!selected }" :disabled="pairWhenReady || !!pairingReason" @click="beginPairing"><span v-if="starting" class="gx-spinner" aria-hidden="true"></span><i v-else class="bi bi-search"></i> {{ starting ? 'Starting search…' : selected ? 'Pair another ' + findLabel : 'Find ' + findLabel }}</button>
+              <button v-else class="gx-btn gx-btn--tonal" @click="cancelPairing">Cancel Search / Pairing</button>
+            </div>
+            <details class="gx-starport-wiki"><summary>Stuck pairing? Pairing order and wireless adapters</summary>
+              <ul>
+                <li><strong>Keep this page open while pairing</strong> so the car’s PIN or code doesn’t time out.</li>
+                <li><strong>Cars with built-in wireless Android Auto:</strong> open the car’s phone pairing screen, then tap <strong>Find car</strong> above. Choose your car, then confirm the code on both screens.</li>
+                <li><strong>Wireless adapter</strong> (AAWireless or Motorola MA1): choose Wireless adapter above, put the adapter in pairing mode and pair it here Your car doesn’t need to be paired. Adapter names often look like AndroidAuto-XXXX.</li>
+              </ul>
+              <p><strong>Start fresh:</strong></p>
+              <ol>
+                <li>Forget the car on the comma: Bluetooth under Tools → Forget.</li>
+                <li>Delete the comma from the car’s Bluetooth list.</li>
+                <li>Turn the car off and on (or unplug the adapter for 5 seconds).</li>
+                <li>Pair again here.</li>
+              </ol>
+              <a class="gx-btn gx-btn--tonal" href="#/bluetooth">Open Bluetooth</a>
+            </details>
+`
 export const CAR_TYPES = {
   builtin: "Built-in wireless", adapter: "Wireless adapter", usb: "Wired AA", app: "App"
 }
@@ -557,7 +633,9 @@ export const StarPortPage = {
     newSetup() { return this.setup?.newSetup !== false },
     guided() {
       return guidedState({ setup: this.setup, runtime: this.runtime, selected: this.selected, receivers: this.receivers, wired: this.wired,
-        app: this.app, carType: this.carType, setupDone: this.setupDone, pairingActive: !!this.pairing?.active, labels: this.carTypeLabels })
+        app: this.app, carType: this.carType, setupDone: this.setupDone, pairingActive: !!this.pairing?.active, editing: this.showSteps,
+        adapterModels: ADAPTER_MODELS, adapterKey: this.runtime?.car_profile_source === "override" ? this.runtime.car_profile : "",
+        appModels: HEAD_UNIT_APPS })
     },
     wiredStatus() {
       if (this.runtime?.wired_blocked) return { tone: "expired", label: "Wired StarPort not enabled", detail: this.runtime.wired_blocked }
@@ -695,6 +773,8 @@ export const StarPortPage = {
     },
     useCar(address) { return this.afterWaiting(() => this.control("select_receiver", { address })) },
     chooseType(key) { return this.saveCarType(0, this.carTypeLabels[key]) },
+    chooseAdapter(key) { return this.saveAdapter(0, ADAPTER_MODELS[key]) },
+    chooseApp(key) { return this.saveApp(0, HEAD_UNIT_APPS[key]) },
     useClassic() { return this.feed.setNewSetup(false) },
     useGuided() { return this.feed.setNewSetup(true) },
     saveCarType(index, value) {
@@ -875,9 +955,27 @@ export const StarPortPage = {
           </div>
         </section>
       <StarPortGuidedSetup v-if="setup && newSetup && guided.show" :state="guided" :busy="busy"
-        @choose-type="chooseType" @use-car="useCar" @classic="useClassic" />
+        @choose-type="chooseType" @choose-adapter="chooseAdapter" @choose-app="chooseApp" @use-car="useCar" @classic="useClassic" @done="showSteps = false">
+        <template #car>
+          <GxNotice v-if="wiredUnavailable" tone="warn">Wired AA is unavailable: {{ runtime.wired_blocked }}.</GxNotice>
+          <template v-if="carType === 'usb'">
+            ${WIRED_STATUS}
+          </template>
+          <template v-else-if="carType === 'app'">
+            ${APP_SETUP}
+          </template>
+          <template v-if="pairsHere">
+            ${PAIR_UI}
+          </template>
+        </template>
+        <template #connect>
+          ${AUTO_CONNECT}
+          ${CONNECT}
+          <p v-if="connectReason" class="gx-guided__hint" role="status">{{ connectReason }}</p>
+        </template>
+      </StarPortGuidedSetup>
       <p v-else-if="setup && !newSetup && !setupDone" class="gx-note"><button type="button" class="gx-btn gx-btn--tonal" :disabled="busy" @click="useGuided">Try the guided setup</button></p>
-      <ol v-if="setup" id="gx-starport-steps" class="gx-starport__steps">
+      <ol v-if="setup && !newSetup" id="gx-starport-steps" class="gx-starport__steps">
         <li v-show="!setupDone || showSteps" class="gx-card gx-starport-step" :class="{ 'gx-starport-step--done': !!selected && !pairing?.active }">
           <div class="gx-starport-step__head">
             <span class="gx-starport-step__num" aria-hidden="true"><i v-if="selected && !pairing?.active" class="bi bi-check-lg"></i><template v-else>2</template></span>
@@ -897,80 +995,7 @@ export const StarPortPage = {
               ${APP_SETUP}
             </template>
             <template v-if="pairsHere">
-            <ol v-if="adapterSetup" class="gx-starport-list" aria-label="Adapter pairing">
-              <li class="gx-starport-row">
-                <i class="bi bi-usb-symbol" aria-hidden="true"></i>
-                <span class="gx-starport-row__text"><strong>Adapter</strong><small>{{ selected ? selected.name : 'Put it in pairing mode, then tap Find adapter.' }}</small></span>
-                <span class="gx-starport-pill" :class="selected ? 'gx-starport-pill--ready' : ''">{{ selected ? 'Paired' : 'Not paired' }}</span>
-              </li>
-            </ol>
-            <GxNotice v-if="!pairing?.active && runtime?.pairing_note" tone="warn">{{ runtime.pairing_note }}</GxNotice>
-            <ul v-if="!pairing?.active && receivers.length" class="gx-starport-list" aria-label="Paired cars">
-              <li v-for="car in receivers" :key="car.address" class="gx-starport-row">
-                <i class="bi bi-car-front" aria-hidden="true"></i>
-                <span class="gx-starport-row__text"><strong>{{ car.name }}</strong><small>{{ selected?.address === car.address ? 'Used for Android Auto' : 'Paired' }}</small></span>
-                <span v-if="selected?.address === car.address" class="gx-starport-pill gx-starport-pill--ready"><i class="bi bi-check-lg"></i> Selected</span>
-                <button v-else class="gx-btn gx-btn--tonal" :disabled="!setup.parked || linked" @click="useCar(car.address)">Use</button>
-              </li>
-            </ul>
-            <p v-else-if="!pairing?.active && selected" class="gx-starport-row"><i class="bi bi-car-front" aria-hidden="true"></i><span class="gx-starport-row__text"><strong>{{ selected.name }}</strong><small>Used for Android Auto</small></span></p>
-            <p v-if="!pairing?.active && endReason === 'canceled'" class="gx-note" role="status">Pairing canceled. Start again when your car is ready.</p>
-            <p v-else-if="!pairing?.active && endReason" class="gx-note" role="status">The pairing window ended without choosing a car. Try again when your car’s pairing screen is open.</p>
-            <ol v-if="showPairSteps" class="gx-starport-list" aria-label="Pairing progress">
-              <li v-for="step in pairSteps" :key="step.label" class="gx-starport-row" :class="'gx-starport-row--' + step.status" :aria-current="step.status === 'active' ? 'step' : undefined">
-                <i v-if="step.status === 'done'" class="bi bi-check-circle-fill gx-starport-ok" aria-hidden="true"></i>
-                <span v-else-if="step.status === 'active'" class="gx-spinner gx-starport-orbit gx-starport-orbit--small" aria-hidden="true"></span>
-                <i v-else class="bi bi-circle" aria-hidden="true"></i>
-                <span class="gx-starport-row__text"><strong>{{ step.label }}</strong></span>
-              </li>
-            </ol>
-            <p v-if="waitingForCar" role="status">{{ pairing.discovering ? "Searching for nearby cars and adapters…" : "Choose your car or wireless adapter below." }}</p>
-            <p v-else-if="pairing?.active && pairing.approved && (!pairing.state || pairing.state === 'idle')" role="status">Approved {{ pairing.receiver?.name }}. Finishing Bluetooth pairing…</p>
-            <p v-if="pairing?.state === 'pairing' && !pairing.prompt && !pairing.approved" role="status">Pairing with {{ pairing.receiver?.name || 'the selected device' }}…</p>
-            <p v-if="pairing?.state === 'connecting'" role="status">Connecting to {{ pairing.receiver?.name || 'the selected device' }}…</p>
-            <p v-if="['paired', 'connected'].includes(pairing?.state)" role="status"><i class="bi bi-check-circle-fill gx-starport-ok"></i> {{ pairing.receiver?.name || 'Device' }} {{ pairing.state === 'connected' ? 'connected' : 'paired' }}.</p>
-            <GxNotice tone="danger" v-if="pairing?.error">{{ pairing.error }}</GxNotice>
-            <ul v-if="pairing?.active" class="gx-starport-list" aria-label="Nearby devices">
-              <li v-if="!pairing.devices?.length && waitingForCar" class="gx-starport-row gx-note" role="status"><span class="gx-spinner" aria-hidden="true"></span>Nothing found yet. Keep your car’s pairing screen open.</li>
-              <li v-for="device in pairing.devices || []" :key="device.address" class="gx-starport-row">
-                <i :class="device.starport ? 'bi bi-car-front' : 'bi bi-bluetooth'" aria-hidden="true"></i>
-                <span class="gx-starport-row__text"><strong>{{ device.name }}</strong><small>{{ device.starport ? 'StarPort ready' : 'Bluetooth device' }} · {{ device.connected ? 'Connected' : device.paired ? 'Paired before' : 'Nearby' }}</small></span>
-                <button class="gx-btn gx-btn--tonal" :disabled="deviceSelectionBlocked" @click="selectDevice(device.address)">{{ device.paired ? 'Connect' : 'Pair' }}</button>
-              </li>
-            </ul>
-            <div v-if="pairing?.prompt" class="gx-starport-prompt" role="status"><strong>{{ pairing.receiver.name }}</strong>
-              <p>{{ pairing.prompt.kind === 'confirmation' ? 'Check that this code matches your car, then confirm.' :
-                pairing.prompt.kind === 'pin' ? 'Enter the PIN shown by your car.' :
-                pairing.prompt.kind === 'passkey' ? 'Enter your car’s passkey.' :
-                pairing.prompt.kind === 'authorization' ? 'Allow this car to pair?' : 'Enter this code in your car.' }}</p>
-              <strong v-if="pairing.prompt.value" class="gx-starport-prompt__code">{{ pairing.prompt.value }}</strong>
-              <input v-if="['pin','passkey'].includes(pairing.prompt.kind)" class="gx-field" type="text" maxlength="16" autocomplete="off"
-                :inputmode="pairing.prompt.kind === 'passkey' ? 'numeric' : 'text'" :aria-label="pairing.prompt.kind === 'pin' ? 'Car PIN' : 'Car passkey'" v-model="pairValue" />
-              <div v-if="!pairing.prompt.displayOnly" class="gx-driving__actions gx-actions">
-                <button class="gx-btn gx-btn--tonal" @click="respond(false)">Reject</button>
-                <button class="gx-btn" :disabled="!canRespond" @click="respond(true)">{{ pairing.prompt.kind === 'pin' ? 'Send PIN' : pairing.prompt.kind === 'passkey' ? 'Send Passkey' : 'Confirm' }}</button></div>
-            </div>
-            <p v-if="pairWhenReady" class="gx-note" role="status"><span class="gx-spinner" aria-hidden="true"></span> Turning on Android Auto, then searching…</p>
-            <p v-else-if="!pairing?.active && pairingReason" class="gx-note" role="status">{{ pairingReason }}</p>
-            <div class="gx-driving__actions gx-actions">
-              <button v-if="!pairing?.active" class="gx-btn" :class="{ 'gx-btn--tonal': !!selected }" :disabled="pairWhenReady || !!pairingReason" @click="beginPairing"><span v-if="starting" class="gx-spinner" aria-hidden="true"></span><i v-else class="bi bi-search"></i> {{ starting ? 'Starting search…' : selected ? 'Pair another ' + findLabel : 'Find ' + findLabel }}</button>
-              <button v-else class="gx-btn gx-btn--tonal" @click="cancelPairing">Cancel Search / Pairing</button>
-            </div>
-            <details class="gx-starport-wiki"><summary>Stuck pairing? Pairing order and wireless adapters</summary>
-              <ul>
-                <li><strong>Keep this page open while pairing</strong> so the car’s PIN or code doesn’t time out.</li>
-                <li><strong>Cars with built-in wireless Android Auto:</strong> open the car’s phone pairing screen, then tap <strong>Find car</strong> above. Choose your car, then confirm the code on both screens.</li>
-                <li><strong>Wireless adapter</strong> (AAWireless or Motorola MA1): choose Wireless adapter above, put the adapter in pairing mode and pair it here Your car doesn’t need to be paired. Adapter names often look like AndroidAuto-XXXX.</li>
-              </ul>
-              <p><strong>Start fresh:</strong></p>
-              <ol>
-                <li>Forget the car on the comma: Bluetooth under Tools → Forget.</li>
-                <li>Delete the comma from the car’s Bluetooth list.</li>
-                <li>Turn the car off and on (or unplug the adapter for 5 seconds).</li>
-                <li>Pair again here.</li>
-              </ol>
-              <a class="gx-btn gx-btn--tonal" href="#/bluetooth">Open Bluetooth</a>
-            </details>
+            ${PAIR_UI}
             </template>
             ${CONNECTION_PROGRESS}
             ${CONNECT}
@@ -997,9 +1022,11 @@ export const StarPortPage = {
         </div>
         <div class="gx-starport-step__body">
           <p v-if="expiry.level === 'soon'" class="gx-starport-pill gx-starport-pill--soon" role="status">{{ expiry.label }}</p>
-          <GalaxySettingRow :row="carTypeRow" :index="0" :busy="busy" :disabled="appDisabled" :save-value="saveCarType" />
-          <GalaxySettingRow v-if="adapterSetup" :row="adapterRow" :index="0" :busy="busy" :disabled="appDisabled" :save-value="saveAdapter" />
-          <GalaxySettingRow v-if="app" :row="appRow" :index="0" :busy="busy" :disabled="appDisabled" :save-value="saveApp" />
+          <template v-if="!newSetup">
+            <GalaxySettingRow :row="carTypeRow" :index="0" :busy="busy" :disabled="appDisabled" :save-value="saveCarType" />
+            <GalaxySettingRow v-if="adapterSetup" :row="adapterRow" :index="0" :busy="busy" :disabled="appDisabled" :save-value="saveAdapter" />
+            <GalaxySettingRow v-if="app" :row="appRow" :index="0" :busy="busy" :disabled="appDisabled" :save-value="saveApp" />
+          </template>
           ${AUTO_CONNECT}
           <ul v-if="wirelessHome" class="gx-starport-list" aria-label="Setup steps">
             <li class="gx-starport-row"><i class="bi bi-shield-check" aria-hidden="true"></i>

From b21952a392b5be000d6ca731d5a82f4032d32579 Mon Sep 17 00:00:00 2001
From: dirwin31 <83434411+dirwin31@users.noreply.github.com>
Date: Sun, 1 Nov 2026 17:09:09 -0800
Subject: [PATCH 21/38] Reuse the existing StarPort list, row and disclosure
 styles in the guided card

The guided card's lists, paired-car rows, checklist rows and handshake
disclosure now use the page's own gx-starport-list, gx-starport-row,
gx-starport-row__text and gx-starport-wiki classes, restyled once for the
card, instead of parallel guided-only copies. Radii, spacing and motion use
Galaxy's tokens. Only the step track, icon tiles, radio rows, segmented
control and checklist marks remain new, and the block is about a fifth
shorter.
---
 openpilot/starpilot/galaxy/web/css/galaxy.css | 154 +++++++++---------
 .../galaxy/web/js/starport-guided.js          |  24 +--
 2 files changed, 86 insertions(+), 92 deletions(-)

diff --git a/openpilot/starpilot/galaxy/web/css/galaxy.css b/openpilot/starpilot/galaxy/web/css/galaxy.css
index 5f3e5f7d46..04bca2eb75 100644
--- a/openpilot/starpilot/galaxy/web/css/galaxy.css
+++ b/openpilot/starpilot/galaxy/web/css/galaxy.css
@@ -2002,7 +2002,9 @@ progress { max-width: 100%; accent-color: var(--primary); }
   .gx-tuner__diagnostics dd { margin-bottom: 12px; }
 }
 
-/* Guided StarPort setup. Apple-style geometry and type on Galaxy's own colors, so light and dark both follow the theme. */
+/* Guided StarPort setup. Apple-style geometry and type on Galaxy's own colors, spacing, radii and motion tokens, so light and dark
+   both follow the theme. Rows, lists, pills, the disclosure and the prompt are the page's existing .gx-starport-* components,
+   restyled here; only the step track, icon tiles, radio rows, segmented control and checklist marks are new. */
 .gx-card.gx-guided {
   --g-ink: var(--on-surface);
   --g-muted: var(--on-surface-variant);
@@ -2013,30 +2015,29 @@ progress { max-width: 100%; accent-color: var(--primary); }
   --g-accent: var(--primary);
   --g-done: #30d158;
   --g-thumb: rgba(255, 255, 255, .18);
-  --g-ease: cubic-bezier(.32, .72, 0, 1);
-  display: grid; gap: 24px; padding: 28px 28px 24px; border-radius: 28px; margin-block: 16px;
+  display: grid; gap: var(--sp-5); padding: 28px 28px var(--sp-5); border-radius: var(--radius-lg); margin-block: var(--sp-4);
   font-family: -apple-system, BlinkMacSystemFont, "SF Pro Text", "Inter", system-ui, "Segoe UI", sans-serif;
   font-size: 16px; line-height: 1.4; color: var(--g-ink); -webkit-font-smoothing: antialiased;
 }
 [data-theme="light"] .gx-card.gx-guided { --g-done: #248a3d; --g-thumb: #fff; }
 
 /* The step track: three numbered nodes on a line that fills as the setup moves along. */
-.gx-guided__steps { list-style: none; margin: 0; padding: 0; display: grid; grid-template-columns: repeat(3, 1fr); position: relative; counter-reset: none; }
-.gx-guided__step { position: relative; display: grid; justify-items: center; gap: 8px; text-align: center; }
-.gx-guided__step::before, .gx-guided__step::after { content: ""; position: absolute; top: 15px; height: 2px; width: calc(50% - 8px); }
-.gx-guided__step::before { left: 0; background: var(--g-track); }
-.gx-guided__step::after  { right: 0; background: var(--g-track); }
+.gx-guided__steps { list-style: none; margin: 0; padding: 0; display: grid; grid-template-columns: repeat(3, 1fr); }
+.gx-guided__step { position: relative; display: grid; justify-items: center; gap: var(--sp-2); text-align: center; }
+.gx-guided__step::before, .gx-guided__step::after { content: ""; position: absolute; top: 15px; height: 2px; width: calc(50% - 8px); background: var(--g-track); }
+.gx-guided__step::before { left: 0; }
+.gx-guided__step::after { right: 0; }
 .gx-guided__step:first-child::before, .gx-guided__step:last-child::after { display: none; }
-.gx-guided__step.is-done::before, .gx-guided__step.is-done::after, .gx-guided__step.is-current::before { background: var(--g-done); }
+.gx-guided__step.is-done::before, .gx-guided__step.is-done::after, .gx-guided__step.is-current::before,
 .gx-guided__step.is-done + .gx-guided__step::before { background: var(--g-done); }
 .gx-guided__node {
-  position: relative; z-index: 1; display: grid; place-items: center; width: 32px; height: 32px; border-radius: 50%;
+  position: relative; z-index: 1; display: grid; place-items: center; width: 32px; height: 32px; border-radius: var(--radius-full);
   font-size: 15px; font-weight: 600; font-variant-numeric: tabular-nums; background: var(--g-fill); color: var(--g-muted);
-  transition: background .3s var(--g-ease), color .3s var(--g-ease), box-shadow .3s var(--g-ease), transform .3s var(--g-ease);
+  transition: background var(--motion-base), color var(--motion-base), box-shadow var(--motion-base);
 }
 .gx-guided__step.is-current .gx-guided__node { background: var(--g-accent); color: var(--on-primary); box-shadow: 0 0 0 5px color-mix(in srgb, var(--g-accent) 24%, transparent); }
-.gx-guided__step.is-done .gx-guided__node { background: var(--g-done); color: #fff; animation: gx-guided-pop .35s var(--g-ease); }
-.gx-guided__step-label { font-size: 13px; font-weight: 600; letter-spacing: -.005em; color: var(--g-muted); }
+.gx-guided__step.is-done .gx-guided__node { background: var(--g-done); color: #fff; animation: gx-guided-pop var(--motion-slow); }
+.gx-guided__step-label { font-size: 13px; font-weight: 600; color: var(--g-muted); }
 .gx-guided__step.is-current .gx-guided__step-label { color: var(--g-ink); }
 @keyframes gx-guided-pop { 0% { transform: scale(.7); } 60% { transform: scale(1.12); } 100% { transform: scale(1); } }
 .gx-guided__sr { position: absolute; width: 1px; height: 1px; overflow: hidden; clip-path: inset(50%); white-space: nowrap; }
@@ -2044,30 +2045,39 @@ progress { max-width: 100%; accent-color: var(--primary); }
 .gx-guided__header { display: grid; gap: 6px; max-width: 34rem; }
 .gx-guided__title { margin: 0; font-size: 30px; line-height: 1.12; font-weight: 650; letter-spacing: -.024em; text-wrap: balance; }
 .gx-guided__lede { margin: 0; font-size: 17px; line-height: 1.45; color: var(--g-muted); text-wrap: pretty; }
-
 .gx-guided__section { display: grid; gap: 10px; }
-.gx-guided__subhead { margin: 0 0 0 4px; font-size: 15px; font-weight: 600; letter-spacing: -.01em; color: var(--g-muted); }
-.gx-guided__hint { margin: 0 4px; font-size: 14px; color: var(--g-muted); }
+.gx-guided__subhead { margin: 0 0 0 var(--sp-1); font-size: 15px; font-weight: 600; color: var(--g-muted); }
+.gx-guided__hint { margin: 0 var(--sp-1); font-size: 14px; color: var(--g-muted); }
 
-/* Inset grouped lists, as in iOS Settings. */
-.gx-guided__group { list-style: none; margin: 0; padding: 0; background: var(--g-fill); border-radius: 18px; overflow: hidden; }
-.gx-guided__group > li { position: relative; }
-.gx-guided__group > li + li::before { content: ""; position: absolute; top: 0; left: 70px; right: 0; height: 1px; background: var(--g-line); }
-.gx-guided__option, .gx-guided__car, .gx-guided__checklist > li {
-  display: flex; align-items: center; gap: 14px; width: 100%; min-height: 60px; padding: 10px 16px; box-sizing: border-box;
-  background: none; border: 0; color: inherit; font: inherit; text-align: left;
+/* Inset grouped lists, as in iOS Settings: the page's .gx-starport-list and .gx-starport-row, restyled once, here, for the pairing
+   content and the card's own lists alike. --g-inset is where the hairline between rows starts (after the icon). */
+.gx-guided .gx-starport-list { --g-inset: 54px; background: var(--g-fill); border: 0; border-radius: var(--radius-md); box-shadow: none; }
+.gx-guided .gx-starport-list > li { position: relative; }
+.gx-guided .gx-starport-list > li + li::before { content: ""; position: absolute; top: 0; left: var(--g-inset); right: 0; height: 1px; background: var(--g-line); }
+.gx-guided .gx-starport-list > .gx-starport-row + .gx-starport-row { border-top: 0; }
+.gx-guided .gx-starport-list .gx-starport-row { background: none; box-shadow: none; }
+.gx-guided .gx-starport-row { min-height: 56px; padding: 10px var(--sp-4); gap: 14px; border: 0; border-radius: 0; flex-wrap: nowrap; }
+.gx-guided .gx-starport-row__text { flex: 1 1 0; }
+.gx-guided .gx-starport-row__text strong { font-size: 16px; font-weight: 590; letter-spacing: -.01em; }
+.gx-guided .gx-starport-row__text small { font-size: 14px; line-height: 1.3; color: var(--g-muted); }
+.gx-guided .gx-starport-row > i { color: var(--g-muted); font-size: 20px; }
+.gx-guided .gx-starport-ok { color: var(--g-done); }
+.gx-guided .gx-starport-pill { border: 0; background: var(--g-fill-hover); color: var(--g-muted); font-size: 13px; font-weight: 600; }
+.gx-guided .gx-starport-pill--ready { background: color-mix(in srgb, var(--g-done) 20%, transparent); color: var(--g-done); }
+
+/* Connection options: a radio row with a coloured icon tile, as in iOS Settings. */
+.gx-guided__options { --g-inset: 70px; }
+.gx-guided__options > li { display: block; }
+.gx-guided__option {
+  display: flex; align-items: center; gap: 14px; width: 100%; min-height: 60px; padding: 10px var(--sp-4); box-sizing: border-box;
+  background: none; border: 0; color: inherit; font: inherit; text-align: left; cursor: pointer; transition: background var(--motion-fast);
 }
-.gx-guided__checklist > li { min-height: 52px; }
-.gx-guided__option { cursor: pointer; transition: background .2s var(--g-ease); }
 .gx-guided__option:hover:not(:disabled) { background: var(--g-fill-hover); }
 .gx-guided__option:active:not(:disabled) { background: var(--g-line); }
 .gx-guided__option:disabled { cursor: default; opacity: .6; }
 .gx-guided__option:focus-visible, .gx-guided__segmented button:focus-visible, .gx-guided__link:focus-visible {
-  outline: 3px solid color-mix(in srgb, var(--g-accent) 70%, transparent); outline-offset: -3px; border-radius: 14px;
+  outline: 3px solid color-mix(in srgb, var(--g-accent) 70%, transparent); outline-offset: -3px; border-radius: var(--radius-sm);
 }
-.gx-guided__text { display: grid; gap: 1px; min-width: 0; flex: 1; }
-.gx-guided__text strong { font-size: 16px; font-weight: 590; letter-spacing: -.01em; }
-.gx-guided__text small { font-size: 14px; line-height: 1.3; color: var(--g-muted); }
 .gx-guided__tile {
   flex: none; display: grid; place-items: center; width: 40px; height: 40px; border-radius: 10px; color: #fff; font-size: 20px;
   box-shadow: inset 0 0 0 1px rgba(255, 255, 255, .14);
@@ -2076,91 +2086,75 @@ progress { max-width: 100%; accent-color: var(--primary); }
 .gx-guided__tile.is-orange { background: linear-gradient(180deg, #ffb84a, #ff9f0a); }
 .gx-guided__tile.is-gray { background: linear-gradient(180deg, #a1a1a6, #7c7c82); }
 .gx-guided__tile.is-purple { background: linear-gradient(180deg, #d58cff, #bf5af2); }
+.gx-guided__cars { --g-inset: 70px; }
 .gx-guided__radio {
-  flex: none; display: grid; place-items: center; width: 24px; height: 24px; border-radius: 50%; font-size: 14px; color: transparent;
-  border: 1.5px solid color-mix(in srgb, var(--on-surface) 28%, transparent); transition: background .25s var(--g-ease), border-color .25s var(--g-ease);
+  flex: none; display: grid; place-items: center; width: 24px; height: 24px; border-radius: var(--radius-full); font-size: 14px; color: transparent;
+  border: 1.5px solid color-mix(in srgb, var(--on-surface) 28%, transparent); transition: background var(--motion-base), border-color var(--motion-base);
 }
 .gx-guided__option[aria-checked="true"] .gx-guided__radio { background: var(--g-accent); border-color: var(--g-accent); color: var(--on-primary); }
-.gx-guided__option[aria-checked="true"] .gx-guided__text strong { color: var(--g-ink); }
 
-/* Segmented control for the adapter and app choices. */
-.gx-guided__segmented { display: flex; gap: 2px; padding: 3px; background: var(--g-fill); border-radius: 12px; }
+/* Segmented control for the adapter and app choices (Galaxy has none). */
+.gx-guided__segmented { display: flex; gap: 2px; padding: 3px; background: var(--g-fill); border-radius: var(--radius-sm); }
 .gx-guided__segmented button {
-  flex: 1; min-height: 44px; padding: 6px 8px; border: 0; border-radius: 9px; background: none; color: var(--g-muted);
-  font: inherit; font-size: 15px; font-weight: 560; line-height: 1.2; text-wrap: balance; cursor: pointer; transition: background .25s var(--g-ease), color .25s var(--g-ease), box-shadow .25s var(--g-ease);
+  flex: 1; min-height: 44px; padding: 6px 8px; border: 0; border-radius: calc(var(--radius-sm) - 3px); background: none; color: var(--g-muted);
+  font: inherit; font-size: 15px; font-weight: 560; line-height: 1.2; text-wrap: balance; cursor: pointer;
+  transition: background var(--motion-base), color var(--motion-base), box-shadow var(--motion-base);
 }
 .gx-guided__segmented button.is-selected { background: var(--g-thumb); color: var(--g-ink); box-shadow: 0 1px 3px rgba(0, 0, 0, .22), 0 0 0 .5px rgba(0, 0, 0, .06); }
-.gx-guided__segmented button:disabled { opacity: .6; cursor: default; }
 .gx-guided__segmented button:not(.is-selected):hover:not(:disabled) { color: var(--g-ink); }
+.gx-guided__segmented button:disabled { opacity: .6; cursor: default; }
 
-/* Live checklist. */
+/* Live checklist: the same rows, with a state mark where the icon goes. */
+.gx-guided__checklist { --g-inset: 58px; }
 .gx-guided__mark { flex: none; display: grid; place-items: center; width: 28px; font-size: 22px; color: color-mix(in srgb, var(--on-surface) 30%, transparent); }
-.gx-guided__checklist > li.is-done .gx-guided__mark, .gx-guided__checklist > li.is-worked .gx-guided__mark { color: var(--g-done); animation: gx-guided-pop .35s var(--g-ease); }
+.gx-guided__spinner { width: 20px; height: 20px; }
+.gx-guided__checklist > li.is-done .gx-guided__mark, .gx-guided__checklist > li.is-worked .gx-guided__mark { color: var(--g-done); animation: gx-guided-pop var(--motion-slow); }
 .gx-guided__checklist > li.is-active .gx-guided__mark, .gx-guided__checklist > li.is-current .gx-guided__mark, .gx-guided__checklist > li.is-retry .gx-guided__mark { color: var(--g-accent); }
 .gx-guided__checklist > li.is-failed .gx-guided__mark { color: var(--error); }
-.gx-guided__checklist > li.is-waiting .gx-guided__text strong, .gx-guided__checklist > li.is-skipped .gx-guided__text strong { color: var(--g-muted); font-weight: 500; }
-.gx-guided__spinner { width: 20px; height: 20px; }
-.gx-guided__checklist.gx-guided__group > li + li::before { left: 58px; }
-
-.gx-guided__disclosure { background: var(--g-fill); border-radius: 18px; overflow: hidden; }
-.gx-guided__disclosure > summary { list-style: none; cursor: pointer; padding: 14px 16px; font-size: 15px; font-weight: 590; display: flex; justify-content: space-between; align-items: center; }
-.gx-guided__disclosure > summary::-webkit-details-marker { display: none; }
-.gx-guided__disclosure > summary::after { content: "\203A"; font-size: 22px; color: var(--g-muted); transition: transform .25s var(--g-ease); }
-.gx-guided__disclosure[open] > summary::after { transform: rotate(90deg); }
-.gx-guided__disclosure .gx-guided__group { border-radius: 0; background: none; border-top: 1px solid var(--g-line); }
+.gx-guided__checklist > li.is-waiting strong, .gx-guided__checklist > li.is-skipped strong { color: var(--g-muted); font-weight: 500; }
 
 .gx-guided__callout {
-  display: flex; align-items: center; justify-content: space-between; gap: 14px; flex-wrap: wrap; margin: 0; padding: 14px 16px;
-  border-radius: 16px; background: color-mix(in srgb, var(--g-accent) 14%, transparent); font-size: 15px; line-height: 1.4;
+  display: flex; align-items: center; justify-content: space-between; gap: 14px; flex-wrap: wrap; margin: 0; padding: 14px var(--sp-4);
+  border-radius: var(--radius-sm); background: color-mix(in srgb, var(--g-accent) 14%, transparent); font-size: 15px; line-height: 1.4;
 }
 .gx-guided__callout--quiet { background: var(--g-fill); color: var(--g-muted); display: block; }
 
 /* The page's own pairing, cable and app content arrives through the car slot; it takes the same look here. */
 .gx-guided__body { display: grid; gap: 14px; }
 .gx-guided__body:empty { display: none; }
-.gx-guided .gx-starport-list { list-style: none; margin: 0; padding: 0; background: var(--g-fill); border-radius: 18px; overflow: hidden; box-shadow: none; border: 0; }
-.gx-guided .gx-starport-row { display: flex; align-items: center; gap: 14px; min-height: 56px; padding: 10px 16px; background: none; border: 0; border-radius: 0; }
-.gx-guided .gx-starport-list > li + li, .gx-guided .gx-starport-list > .gx-starport-row + .gx-starport-row { border-top: 1px solid var(--g-line); }
-.gx-guided .gx-starport-row__text { display: grid; gap: 1px; min-width: 0; flex: 1; }
-.gx-guided .gx-starport-row__text strong { font-size: 16px; font-weight: 590; }
-.gx-guided .gx-starport-row__text small { font-size: 14px; color: var(--g-muted); }
-.gx-guided .gx-starport-row > i.bi { font-size: 20px; color: var(--g-muted); }
-.gx-guided .gx-starport-ok { color: var(--g-done) !important; }
-.gx-guided .gx-starport-pill { border-radius: 999px; padding: 4px 12px; font-size: 13px; font-weight: 600; background: var(--g-fill-hover); color: var(--g-muted); border: 0; }
-.gx-guided .gx-starport-pill--ready { background: color-mix(in srgb, var(--g-done) 20%, transparent); color: var(--g-done); }
-.gx-guided .gx-note, .gx-guided .gx-notice, .gx-guided .gx-starport-guide { margin: 0; padding: 14px 16px; border-radius: 16px; background: var(--g-fill); font-size: 15px; line-height: 1.45; border: 0; }
-.gx-guided .gx-starport-prompt { padding: 18px; border-radius: 18px; background: var(--g-fill); display: grid; gap: 10px; border: 0; }
-.gx-guided .gx-starport-prompt__code { font-size: 34px; letter-spacing: .12em; font-weight: 650; font-variant-numeric: tabular-nums; }
-.gx-guided .gx-starport-wiki { background: var(--g-fill); border-radius: 16px; padding: 0; border: 0; overflow: hidden; }
-.gx-guided .gx-starport-wiki > summary { padding: 14px 16px; font-size: 15px; font-weight: 560; cursor: pointer; color: var(--g-ink); }
-.gx-guided .gx-starport-wiki > :not(summary) { margin-inline: 16px; font-size: 14px; line-height: 1.5; }
-.gx-guided .gx-starport-wiki > :last-child { margin-bottom: 16px; }
-.gx-guided .gx-field { min-height: 44px; border-radius: 12px; }
+.gx-guided .gx-note, .gx-guided .gx-notice, .gx-guided .gx-starport-guide { margin: 0; padding: 14px var(--sp-4); border: 0; border-radius: var(--radius-sm); background: var(--g-fill); font-size: 15px; line-height: 1.45; }
+.gx-guided .gx-starport-prompt { padding: 18px; border-radius: var(--radius-md); background: var(--g-fill); }
+.gx-guided .gx-starport-prompt__code { font-size: 34px; font-weight: 650; }
+.gx-guided .gx-starport-wiki { background: var(--g-fill); border: 0; border-radius: var(--radius-sm); padding: 0; overflow: hidden; color: var(--g-muted); }
+.gx-guided .gx-starport-wiki > summary { padding: 14px var(--sp-4); font-size: 15px; font-weight: 560; color: var(--g-ink); }
+.gx-guided .gx-starport-wiki > :not(summary) { margin-inline: var(--sp-4); font-size: 14px; line-height: 1.5; }
+.gx-guided .gx-starport-wiki > :last-child { margin-bottom: var(--sp-4); }
+.gx-guided .gx-starport-wiki > .gx-starport-list { margin-inline: 0; margin-top: 0; border-radius: 0; background: none; border-top: 1px solid var(--g-line); }
+.gx-guided .gx-field { min-height: 44px; border-radius: var(--radius-sm); }
 .gx-guided .gx-actions, .gx-guided .gx-driving__actions { display: flex; gap: 10px; flex-wrap: wrap; margin: 0; }
-.gx-guided .gx-row { background: var(--g-fill); border: 0; border-radius: 18px; padding: 12px 16px; }
+.gx-guided .gx-row { background: var(--g-fill); border: 0; border-radius: var(--radius-md); padding: var(--sp-3) var(--sp-4); }
 
-/* Buttons: pill-shaped primary, soft tonal. */
-.gx-guided .gx-btn { min-height: 44px; border-radius: 12px; font-size: 16px; font-weight: 590; letter-spacing: -.01em; padding-inline: 18px; box-shadow: none; }
+/* Buttons: soft tonal, and a large primary. */
+.gx-guided .gx-btn { min-height: 44px; border-radius: var(--radius-sm); font-size: 16px; font-weight: 590; letter-spacing: -.01em; padding-inline: 18px; box-shadow: none; }
 .gx-guided .gx-btn--tonal { background: var(--g-fill-hover); color: var(--g-ink); border: 0; }
 .gx-guided .gx-btn--tonal:hover:not(:disabled) { background: var(--g-line); }
-.gx-guided .gx-starport-cta { width: 100%; min-height: 54px; border-radius: 16px; font-size: 17px; }
-.gx-guided__footer { display: grid; gap: 12px; justify-items: stretch; }
+.gx-guided .gx-starport-cta { width: 100%; min-height: 54px; border-radius: var(--radius-md); font-size: 17px; }
+.gx-guided__footer { display: grid; gap: var(--sp-3); justify-items: stretch; }
 .gx-guided__footer .gx-guided__hint { text-align: center; }
-.gx-guided__link { justify-self: center; padding: 8px 12px; border: 0; background: none; color: var(--g-accent); font: inherit; font-size: 15px; font-weight: 560; cursor: pointer; }
+.gx-guided__link { justify-self: center; padding: var(--sp-2) var(--sp-3); border: 0; background: none; color: var(--g-accent); font: inherit; font-size: 15px; font-weight: 560; cursor: pointer; }
 .gx-guided__link:hover:not(:disabled) { text-decoration: underline; }
 .gx-guided__link:disabled { opacity: .5; cursor: default; }
 
 @media (max-width: 640px) {
-  .gx-card.gx-guided { padding: 22px 16px 18px; border-radius: 24px; gap: 20px; }
+  .gx-card.gx-guided { padding: 22px var(--sp-4) 18px; gap: 20px; }
   .gx-guided__title { font-size: 26px; }
   .gx-guided__lede { font-size: 16px; }
   .gx-guided__segmented button { font-size: 14px; }
-  .gx-guided__option, .gx-guided__car, .gx-guided__checklist > li { padding-inline: 14px; gap: 12px; }
-  .gx-guided__group > li + li::before { left: 66px; }
-  .gx-guided__checklist.gx-guided__group > li + li::before { left: 54px; }
+  .gx-guided__options, .gx-guided__cars { --g-inset: 66px; }
+  .gx-guided__checklist { --g-inset: 54px; }
   .gx-guided .gx-starport-cta { min-height: 56px; }
 }
 @media (prefers-reduced-motion: reduce) {
-  .gx-guided__node, .gx-guided__option, .gx-guided__radio, .gx-guided__segmented button, .gx-guided__disclosure > summary::after { transition: none; }
+  .gx-guided__node, .gx-guided__option, .gx-guided__radio, .gx-guided__segmented button { transition: none; }
   .gx-guided__step.is-done .gx-guided__node, .gx-guided__checklist > li.is-done .gx-guided__mark, .gx-guided__checklist > li.is-worked .gx-guided__mark { animation: none; }
 }
diff --git a/openpilot/starpilot/galaxy/web/js/starport-guided.js b/openpilot/starpilot/galaxy/web/js/starport-guided.js
index d5afa79ba7..f56dc23f3d 100644
--- a/openpilot/starpilot/galaxy/web/js/starport-guided.js
+++ b/openpilot/starpilot/galaxy/web/js/starport-guided.js
@@ -144,12 +144,12 @@ export const StarPortGuidedSetup = {
       </header>
 
       <div v-if="state.choices.length" class="gx-guided__section">
-        <ul class="gx-guided__group" role="radiogroup" aria-label="How your car connects">
+        <ul class="gx-starport-list gx-guided__options" role="radiogroup" aria-label="How your car connects">
           <li v-for="choice in state.choices" :key="choice.key">
             <button type="button" class="gx-guided__option" role="radio" :aria-checked="choice.selected ? 'true' : 'false'"
                 :disabled="busy" @click="$emit('choose-type', choice.key)">
               <span class="gx-guided__tile" :class="'is-' + choice.tone" aria-hidden="true"><i :class="'bi bi-' + choice.icon"></i></span>
-              <span class="gx-guided__text"><strong>{{ choice.title }}</strong><small>{{ choice.detail }}</small></span>
+              <span class="gx-starport-row__text"><strong>{{ choice.title }}</strong><small>{{ choice.detail }}</small></span>
               <span class="gx-guided__radio" aria-hidden="true"><i v-if="choice.selected" class="bi bi-check-lg"></i></span>
             </button>
           </li>
@@ -176,10 +176,10 @@ export const StarPortGuidedSetup = {
 
       <div v-if="state.candidates.length" class="gx-guided__section">
         <h3 class="gx-guided__subhead">Paired cars</h3>
-        <ul class="gx-guided__group" aria-label="Paired cars that offer Android Auto">
-          <li v-for="car in state.candidates" :key="car.address" class="gx-guided__car">
+        <ul class="gx-starport-list gx-guided__cars" aria-label="Paired cars that offer Android Auto">
+          <li v-for="car in state.candidates" :key="car.address" class="gx-starport-row">
             <span class="gx-guided__tile is-blue" aria-hidden="true"><i class="bi bi-car-front-fill"></i></span>
-            <span class="gx-guided__text"><strong>{{ car.name }}</strong><small>Paired and offers Android Auto</small></span>
+            <span class="gx-starport-row__text"><strong>{{ car.name }}</strong><small>Paired and offers Android Auto</small></span>
             <button type="button" class="gx-btn gx-btn--tonal" :disabled="busy" @click="$emit('use-car', car.address)">Use</button>
           </li>
         </ul>
@@ -191,23 +191,23 @@ export const StarPortGuidedSetup = {
       </div>
 
       <div v-if="state.progress.length" class="gx-guided__section">
-        <ol class="gx-guided__group gx-guided__checklist" aria-label="Connection progress">
-          <li v-for="step in state.progress" :key="step.id" :class="'is-' + step.state" :aria-current="step.state === 'active' || step.state === 'retry' ? 'step' : undefined">
+        <ol class="gx-starport-list gx-guided__checklist" aria-label="Connection progress">
+          <li v-for="step in state.progress" :key="step.id" class="gx-starport-row" :class="'is-' + step.state" :aria-current="step.state === 'active' || step.state === 'retry' ? 'step' : undefined">
             <span class="gx-guided__mark" aria-hidden="true">
               <i v-if="step.state === 'done'" class="bi bi-check-circle-fill"></i>
               <span v-else-if="step.state === 'active'" class="gx-spinner gx-guided__spinner"></span>
               <i v-else-if="step.state === 'retry'" class="bi bi-arrow-repeat"></i>
               <i v-else class="bi bi-circle"></i>
             </span>
-            <span class="gx-guided__text"><strong>{{ step.label }}</strong><small v-if="step.state === 'retry'">Trying again</small></span>
+            <span class="gx-starport-row__text"><strong>{{ step.label }}</strong><small v-if="step.state === 'retry'">Trying again</small></span>
           </li>
         </ol>
       </div>
 
-      <details v-if="state.handshake.length" class="gx-guided__disclosure" open>
+      <details v-if="state.handshake.length" class="gx-starport-wiki" open>
         <summary>What we are trying</summary>
-        <ol class="gx-guided__group gx-guided__checklist" aria-label="Handshake options">
-          <li v-for="step in state.handshake" :key="step.id" :class="'is-' + step.state">
+        <ol class="gx-starport-list gx-guided__checklist" aria-label="Handshake options">
+          <li v-for="step in state.handshake" :key="step.id" class="gx-starport-row" :class="'is-' + step.state">
             <span class="gx-guided__mark" aria-hidden="true">
               <i v-if="step.state === 'worked'" class="bi bi-check-circle-fill"></i>
               <i v-else-if="step.state === 'failed'" class="bi bi-x-circle"></i>
@@ -215,7 +215,7 @@ export const StarPortGuidedSetup = {
               <span v-else-if="step.state === 'current'" class="gx-spinner gx-guided__spinner"></span>
               <i v-else class="bi bi-circle"></i>
             </span>
-            <span class="gx-guided__text"><strong>{{ step.label }}</strong></span>
+            <span class="gx-starport-row__text"><strong>{{ step.label }}</strong></span>
           </li>
         </ol>
       </details>

From 363d942ec98e0aeff4c2bb4c658f3b472ea65782 Mon Sep 17 00:00:00 2001
From: dirwin31 <83434411+dirwin31@users.noreply.github.com>
Date: Sun, 1 Nov 2026 17:15:19 -0800
Subject: [PATCH 22/38] Theme the guided setup with Galaxy's own colors, font
 and icons

Done steps and checks use the theme's success color, the current step and
selection use the primary purple, text uses Galaxy's Inter and weight tokens,
and the connection options use the outline icons the rest of the page uses
(car-front, usb-symbol, usb-c, tablet) on a single primary-tinted tile
instead of Apple's multicolour gradients.
---
 openpilot/starpilot/galaxy/web/css/galaxy.css | 39 ++++++++-----------
 .../galaxy/web/js/starport-guided.js          | 12 +++---
 2 files changed, 22 insertions(+), 29 deletions(-)

diff --git a/openpilot/starpilot/galaxy/web/css/galaxy.css b/openpilot/starpilot/galaxy/web/css/galaxy.css
index 04bca2eb75..61ec741fd3 100644
--- a/openpilot/starpilot/galaxy/web/css/galaxy.css
+++ b/openpilot/starpilot/galaxy/web/css/galaxy.css
@@ -2013,13 +2013,13 @@ progress { max-width: 100%; accent-color: var(--primary); }
   --g-line: color-mix(in srgb, var(--on-surface) 11%, transparent);
   --g-track: color-mix(in srgb, var(--on-surface) 16%, var(--background));  /* opaque, so overlapping segments never show a seam */
   --g-accent: var(--primary);
-  --g-done: #30d158;
+  --g-done: var(--success);
   --g-thumb: rgba(255, 255, 255, .18);
   display: grid; gap: var(--sp-5); padding: 28px 28px var(--sp-5); border-radius: var(--radius-lg); margin-block: var(--sp-4);
-  font-family: -apple-system, BlinkMacSystemFont, "SF Pro Text", "Inter", system-ui, "Segoe UI", sans-serif;
+  font-family: var(--font-body);
   font-size: 16px; line-height: 1.4; color: var(--g-ink); -webkit-font-smoothing: antialiased;
 }
-[data-theme="light"] .gx-card.gx-guided { --g-done: #248a3d; --g-thumb: #fff; }
+[data-theme="light"] .gx-card.gx-guided { --g-thumb: #fff; }
 
 /* The step track: three numbered nodes on a line that fills as the setup moves along. */
 .gx-guided__steps { list-style: none; margin: 0; padding: 0; display: grid; grid-template-columns: repeat(3, 1fr); }
@@ -2032,21 +2032,21 @@ progress { max-width: 100%; accent-color: var(--primary); }
 .gx-guided__step.is-done + .gx-guided__step::before { background: var(--g-done); }
 .gx-guided__node {
   position: relative; z-index: 1; display: grid; place-items: center; width: 32px; height: 32px; border-radius: var(--radius-full);
-  font-size: 15px; font-weight: 600; font-variant-numeric: tabular-nums; background: var(--g-fill); color: var(--g-muted);
+  font-size: 15px; font-weight: var(--fw-bold); font-variant-numeric: tabular-nums; background: var(--g-fill); color: var(--g-muted);
   transition: background var(--motion-base), color var(--motion-base), box-shadow var(--motion-base);
 }
 .gx-guided__step.is-current .gx-guided__node { background: var(--g-accent); color: var(--on-primary); box-shadow: 0 0 0 5px color-mix(in srgb, var(--g-accent) 24%, transparent); }
-.gx-guided__step.is-done .gx-guided__node { background: var(--g-done); color: #fff; animation: gx-guided-pop var(--motion-slow); }
-.gx-guided__step-label { font-size: 13px; font-weight: 600; color: var(--g-muted); }
+.gx-guided__step.is-done .gx-guided__node { background: var(--g-done); color: var(--background); animation: gx-guided-pop var(--motion-slow); }
+.gx-guided__step-label { font-size: 13px; font-weight: var(--fw-bold); color: var(--g-muted); }
 .gx-guided__step.is-current .gx-guided__step-label { color: var(--g-ink); }
 @keyframes gx-guided-pop { 0% { transform: scale(.7); } 60% { transform: scale(1.12); } 100% { transform: scale(1); } }
 .gx-guided__sr { position: absolute; width: 1px; height: 1px; overflow: hidden; clip-path: inset(50%); white-space: nowrap; }
 
 .gx-guided__header { display: grid; gap: 6px; max-width: 34rem; }
-.gx-guided__title { margin: 0; font-size: 30px; line-height: 1.12; font-weight: 650; letter-spacing: -.024em; text-wrap: balance; }
+.gx-guided__title { margin: 0; font-size: 30px; line-height: 1.12; font-weight: var(--fw-bold); letter-spacing: -.02em; text-wrap: balance; }
 .gx-guided__lede { margin: 0; font-size: 17px; line-height: 1.45; color: var(--g-muted); text-wrap: pretty; }
 .gx-guided__section { display: grid; gap: 10px; }
-.gx-guided__subhead { margin: 0 0 0 var(--sp-1); font-size: 15px; font-weight: 600; color: var(--g-muted); }
+.gx-guided__subhead { margin: 0 0 0 var(--sp-1); font-size: 15px; font-weight: var(--fw-bold); color: var(--g-muted); }
 .gx-guided__hint { margin: 0 var(--sp-1); font-size: 14px; color: var(--g-muted); }
 
 /* Inset grouped lists, as in iOS Settings: the page's .gx-starport-list and .gx-starport-row, restyled once, here, for the pairing
@@ -2058,11 +2058,11 @@ progress { max-width: 100%; accent-color: var(--primary); }
 .gx-guided .gx-starport-list .gx-starport-row { background: none; box-shadow: none; }
 .gx-guided .gx-starport-row { min-height: 56px; padding: 10px var(--sp-4); gap: 14px; border: 0; border-radius: 0; flex-wrap: nowrap; }
 .gx-guided .gx-starport-row__text { flex: 1 1 0; }
-.gx-guided .gx-starport-row__text strong { font-size: 16px; font-weight: 590; letter-spacing: -.01em; }
+.gx-guided .gx-starport-row__text strong { font-size: 16px; font-weight: var(--fw-bold); letter-spacing: -.01em; }
 .gx-guided .gx-starport-row__text small { font-size: 14px; line-height: 1.3; color: var(--g-muted); }
 .gx-guided .gx-starport-row > i { color: var(--g-muted); font-size: 20px; }
 .gx-guided .gx-starport-ok { color: var(--g-done); }
-.gx-guided .gx-starport-pill { border: 0; background: var(--g-fill-hover); color: var(--g-muted); font-size: 13px; font-weight: 600; }
+.gx-guided .gx-starport-pill { border: 0; background: var(--g-fill-hover); color: var(--g-muted); font-size: 13px; font-weight: var(--fw-bold); }
 .gx-guided .gx-starport-pill--ready { background: color-mix(in srgb, var(--g-done) 20%, transparent); color: var(--g-done); }
 
 /* Connection options: a radio row with a coloured icon tile, as in iOS Settings. */
@@ -2078,14 +2078,7 @@ progress { max-width: 100%; accent-color: var(--primary); }
 .gx-guided__option:focus-visible, .gx-guided__segmented button:focus-visible, .gx-guided__link:focus-visible {
   outline: 3px solid color-mix(in srgb, var(--g-accent) 70%, transparent); outline-offset: -3px; border-radius: var(--radius-sm);
 }
-.gx-guided__tile {
-  flex: none; display: grid; place-items: center; width: 40px; height: 40px; border-radius: 10px; color: #fff; font-size: 20px;
-  box-shadow: inset 0 0 0 1px rgba(255, 255, 255, .14);
-}
-.gx-guided__tile.is-blue { background: linear-gradient(180deg, #4aa3ff, #0a84ff); }
-.gx-guided__tile.is-orange { background: linear-gradient(180deg, #ffb84a, #ff9f0a); }
-.gx-guided__tile.is-gray { background: linear-gradient(180deg, #a1a1a6, #7c7c82); }
-.gx-guided__tile.is-purple { background: linear-gradient(180deg, #d58cff, #bf5af2); }
+.gx-guided__tile { flex: none; display: grid; place-items: center; width: 40px; height: 40px; border-radius: 10px; background: var(--primary-container); color: var(--primary); font-size: 20px; }
 .gx-guided__cars { --g-inset: 70px; }
 .gx-guided__radio {
   flex: none; display: grid; place-items: center; width: 24px; height: 24px; border-radius: var(--radius-full); font-size: 14px; color: transparent;
@@ -2097,7 +2090,7 @@ progress { max-width: 100%; accent-color: var(--primary); }
 .gx-guided__segmented { display: flex; gap: 2px; padding: 3px; background: var(--g-fill); border-radius: var(--radius-sm); }
 .gx-guided__segmented button {
   flex: 1; min-height: 44px; padding: 6px 8px; border: 0; border-radius: calc(var(--radius-sm) - 3px); background: none; color: var(--g-muted);
-  font: inherit; font-size: 15px; font-weight: 560; line-height: 1.2; text-wrap: balance; cursor: pointer;
+  font: inherit; font-size: 15px; font-weight: var(--fw-medium); line-height: 1.2; text-wrap: balance; cursor: pointer;
   transition: background var(--motion-base), color var(--motion-base), box-shadow var(--motion-base);
 }
 .gx-guided__segmented button.is-selected { background: var(--g-thumb); color: var(--g-ink); box-shadow: 0 1px 3px rgba(0, 0, 0, .22), 0 0 0 .5px rgba(0, 0, 0, .06); }
@@ -2124,9 +2117,9 @@ progress { max-width: 100%; accent-color: var(--primary); }
 .gx-guided__body:empty { display: none; }
 .gx-guided .gx-note, .gx-guided .gx-notice, .gx-guided .gx-starport-guide { margin: 0; padding: 14px var(--sp-4); border: 0; border-radius: var(--radius-sm); background: var(--g-fill); font-size: 15px; line-height: 1.45; }
 .gx-guided .gx-starport-prompt { padding: 18px; border-radius: var(--radius-md); background: var(--g-fill); }
-.gx-guided .gx-starport-prompt__code { font-size: 34px; font-weight: 650; }
+.gx-guided .gx-starport-prompt__code { font-size: 34px; font-weight: var(--fw-bold); }
 .gx-guided .gx-starport-wiki { background: var(--g-fill); border: 0; border-radius: var(--radius-sm); padding: 0; overflow: hidden; color: var(--g-muted); }
-.gx-guided .gx-starport-wiki > summary { padding: 14px var(--sp-4); font-size: 15px; font-weight: 560; color: var(--g-ink); }
+.gx-guided .gx-starport-wiki > summary { padding: 14px var(--sp-4); font-size: 15px; font-weight: var(--fw-medium); color: var(--g-ink); }
 .gx-guided .gx-starport-wiki > :not(summary) { margin-inline: var(--sp-4); font-size: 14px; line-height: 1.5; }
 .gx-guided .gx-starport-wiki > :last-child { margin-bottom: var(--sp-4); }
 .gx-guided .gx-starport-wiki > .gx-starport-list { margin-inline: 0; margin-top: 0; border-radius: 0; background: none; border-top: 1px solid var(--g-line); }
@@ -2135,13 +2128,13 @@ progress { max-width: 100%; accent-color: var(--primary); }
 .gx-guided .gx-row { background: var(--g-fill); border: 0; border-radius: var(--radius-md); padding: var(--sp-3) var(--sp-4); }
 
 /* Buttons: soft tonal, and a large primary. */
-.gx-guided .gx-btn { min-height: 44px; border-radius: var(--radius-sm); font-size: 16px; font-weight: 590; letter-spacing: -.01em; padding-inline: 18px; box-shadow: none; }
+.gx-guided .gx-btn { min-height: 44px; border-radius: var(--radius-sm); font-size: 16px; font-weight: var(--fw-bold); letter-spacing: -.01em; padding-inline: 18px; box-shadow: none; }
 .gx-guided .gx-btn--tonal { background: var(--g-fill-hover); color: var(--g-ink); border: 0; }
 .gx-guided .gx-btn--tonal:hover:not(:disabled) { background: var(--g-line); }
 .gx-guided .gx-starport-cta { width: 100%; min-height: 54px; border-radius: var(--radius-md); font-size: 17px; }
 .gx-guided__footer { display: grid; gap: var(--sp-3); justify-items: stretch; }
 .gx-guided__footer .gx-guided__hint { text-align: center; }
-.gx-guided__link { justify-self: center; padding: var(--sp-2) var(--sp-3); border: 0; background: none; color: var(--g-accent); font: inherit; font-size: 15px; font-weight: 560; cursor: pointer; }
+.gx-guided__link { justify-self: center; padding: var(--sp-2) var(--sp-3); border: 0; background: none; color: var(--g-accent); font: inherit; font-size: 15px; font-weight: var(--fw-medium); cursor: pointer; }
 .gx-guided__link:hover:not(:disabled) { text-decoration: underline; }
 .gx-guided__link:disabled { opacity: .5; cursor: default; }
 
diff --git a/openpilot/starpilot/galaxy/web/js/starport-guided.js b/openpilot/starpilot/galaxy/web/js/starport-guided.js
index f56dc23f3d..f703c348f6 100644
--- a/openpilot/starpilot/galaxy/web/js/starport-guided.js
+++ b/openpilot/starpilot/galaxy/web/js/starport-guided.js
@@ -11,10 +11,10 @@ export const BLUETOOTH_FIRST = /connect your paired car in galaxy bluetooth firs
 export const BLUETOOTH_HINT = { text: "Connect your car in Bluetooth first, then come back and tap Connect.", href: "#/bluetooth", label: "Open Bluetooth" }
 
 const CHOICES = [
-  { key: "builtin", title: "Built-in wireless", detail: "Your car has wireless Android Auto.", icon: "car-front-fill", tone: "blue" },
-  { key: "adapter", title: "Wireless adapter", detail: "AAWireless, Motorola MA1 or similar, plugged into the car.", icon: "usb-plug-fill", tone: "orange" },
-  { key: "usb", title: "USB cable", detail: "A data cable from the car to your comma.", icon: "usb-c-fill", tone: "gray" },
-  { key: "app", title: "Tablet app", detail: "An iPad or Android tablet shows the dashboard.", icon: "tablet-fill", tone: "purple" },
+  { key: "builtin", title: "Built-in wireless", detail: "Your car has wireless Android Auto.", icon: "car-front" },
+  { key: "adapter", title: "Wireless adapter", detail: "AAWireless, Motorola MA1 or similar, plugged into the car.", icon: "usb-symbol" },
+  { key: "usb", title: "USB cable", detail: "A data cable from the car to your comma.", icon: "usb-c" },
+  { key: "app", title: "Tablet app", detail: "An iPad or Android tablet shows the dashboard.", icon: "tablet" },
 ]
 
 const INSTRUCTIONS = {
@@ -148,7 +148,7 @@ export const StarPortGuidedSetup = {
           <li v-for="choice in state.choices" :key="choice.key">
             <button type="button" class="gx-guided__option" role="radio" :aria-checked="choice.selected ? 'true' : 'false'"
                 :disabled="busy" @click="$emit('choose-type', choice.key)">
-              <span class="gx-guided__tile" :class="'is-' + choice.tone" aria-hidden="true"><i :class="'bi bi-' + choice.icon"></i></span>
+              <span class="gx-guided__tile" aria-hidden="true"><i :class="'bi bi-' + choice.icon"></i></span>
               <span class="gx-starport-row__text"><strong>{{ choice.title }}</strong><small>{{ choice.detail }}</small></span>
               <span class="gx-guided__radio" aria-hidden="true"><i v-if="choice.selected" class="bi bi-check-lg"></i></span>
             </button>
@@ -178,7 +178,7 @@ export const StarPortGuidedSetup = {
         <h3 class="gx-guided__subhead">Paired cars</h3>
         <ul class="gx-starport-list gx-guided__cars" aria-label="Paired cars that offer Android Auto">
           <li v-for="car in state.candidates" :key="car.address" class="gx-starport-row">
-            <span class="gx-guided__tile is-blue" aria-hidden="true"><i class="bi bi-car-front-fill"></i></span>
+            <span class="gx-guided__tile" aria-hidden="true"><i class="bi bi-car-front"></i></span>
             <span class="gx-starport-row__text"><strong>{{ car.name }}</strong><small>Paired and offers Android Auto</small></span>
             <button type="button" class="gx-btn gx-btn--tonal" :disabled="busy" @click="$emit('use-car', car.address)">Use</button>
           </li>

From 1d0525fe41be36c52e74c0d64aaa2d80225820b4 Mon Sep 17 00:00:00 2001
From: dirwin31 <83434411+dirwin31@users.noreply.github.com>
Date: Sun, 1 Nov 2026 17:23:04 -0800
Subject: [PATCH 23/38] Keep the guided card open after choosing how the car
 connects

Choosing a USB cable or a tablet app switches the connection at once, which
counts as setup done, so the card closed under the person's finger and left
no way to change the choice. A choice made in the card now holds it open
until Done. In the guided setup the home card's button reads Change how your
car connects, so the way back is visible.
---
 .../galaxy/tests/test_starport_guided.mjs     | 24 +++++++++++++++++++
 openpilot/starpilot/galaxy/web/js/starport.js | 10 ++++----
 2 files changed, 30 insertions(+), 4 deletions(-)

diff --git a/openpilot/starpilot/galaxy/tests/test_starport_guided.mjs b/openpilot/starpilot/galaxy/tests/test_starport_guided.mjs
index 14de96aff0..77240d19c1 100644
--- a/openpilot/starpilot/galaxy/tests/test_starport_guided.mjs
+++ b/openpilot/starpilot/galaxy/tests/test_starport_guided.mjs
@@ -213,3 +213,27 @@ console.log("StarPort guided setup: Bluetooth-first hint passed")
   assert.match(StarPortGuidedSetup.template, /<slot name="connect" \/>/)
 }
 console.log("StarPort guided setup: steps, adapter and app choices, reopening and classic-only dropdowns passed")
+
+// Choosing a cable or an app finishes the setup at once; a choice made in the card must not close the card.
+{
+  const calls = []
+  const vm = { showSteps: false, carTypeLabels: { app: "App", usb: "Wired AA" },
+    saveCarType: (index, label) => calls.push(["type", label]), saveAdapter: (index, label) => calls.push(["adapter", label]),
+    saveApp: (index, label) => calls.push(["app", label]) }
+  StarPortPage.methods.chooseType.call(vm, "app")
+  assert.equal(vm.showSteps, true)
+  vm.showSteps = false
+  StarPortPage.methods.chooseApp.call(vm, "headunitpad")
+  assert.equal(vm.showSteps, true)
+  vm.showSteps = false
+  StarPortPage.methods.chooseAdapter.call(vm, "aawireless")
+  assert.equal(vm.showSteps, true)
+  assert.deepEqual(calls, [["type", "App"], ["app", "HeadunitPad"], ["adapter", "AAWireless"]])
+  // With the card held open by a choice, the finished setup is shown for editing with its Done button, not hidden.
+  const held = guidedState({ setup, runtime: { running: false, state: "idle", connection: "headunitpad" }, setupDone: true, editing: true, carType: "app", appModels, app: "HeadunitPad" })
+  assert.equal(held.show, true)
+  assert.equal(held.editing, true)
+  assert.equal(held.choices.find((choice) => choice.selected).key, "app")
+  assert.equal(held.apps.options.find((option) => option.selected).key, "headunitpad")
+}
+console.log("StarPort guided setup: a choice keeps the card open passed")
diff --git a/openpilot/starpilot/galaxy/web/js/starport.js b/openpilot/starpilot/galaxy/web/js/starport.js
index 86c368ff77..ca5cdd9667 100644
--- a/openpilot/starpilot/galaxy/web/js/starport.js
+++ b/openpilot/starpilot/galaxy/web/js/starport.js
@@ -772,9 +772,11 @@ export const StarPortPage = {
       return stopping ? stopping.then((stopped) => stopped && next()) : next()
     },
     useCar(address) { return this.afterWaiting(() => this.control("select_receiver", { address })) },
-    chooseType(key) { return this.saveCarType(0, this.carTypeLabels[key]) },
-    chooseAdapter(key) { return this.saveAdapter(0, ADAPTER_MODELS[key]) },
-    chooseApp(key) { return this.saveApp(0, HEAD_UNIT_APPS[key]) },
+    // Choosing a cable or an app makes the setup count as done at once, which would close the card under the person's finger.
+    // A choice made in the card keeps it open (its Done button closes it), so the choice can still be changed.
+    chooseType(key) { this.showSteps = true; return this.saveCarType(0, this.carTypeLabels[key]) },
+    chooseAdapter(key) { this.showSteps = true; return this.saveAdapter(0, ADAPTER_MODELS[key]) },
+    chooseApp(key) { this.showSteps = true; return this.saveApp(0, HEAD_UNIT_APPS[key]) },
     useClassic() { return this.feed.setNewSetup(false) },
     useGuided() { return this.feed.setNewSetup(true) },
     saveCarType(index, value) {
@@ -1046,7 +1048,7 @@ export const StarPortPage = {
           <div class="gx-actions">
             <a class="gx-btn gx-btn--tonal" href="#/theme_maker/starport"><i class="bi bi-layout-text-window" aria-hidden="true"></i> Customize Layout</a>
             <button type="button" class="gx-btn gx-btn--tonal" :aria-expanded="showSteps" aria-controls="gx-starport-steps" @click="showSteps = !showSteps">
-              <i :class="showSteps ? 'bi bi-chevron-up' : 'bi bi-gear'" aria-hidden="true"></i> {{ showSteps ? 'Hide Setup' : 'Setup and Pairing' }}</button>
+              <i :class="showSteps ? 'bi bi-chevron-up' : 'bi bi-gear'" aria-hidden="true"></i> {{ showSteps ? 'Hide Setup' : newSetup ? 'Change how your car connects' : 'Setup and Pairing' }}</button>
           </div>
         </div>
       </section>

From 067f30dfa4527fd29f56efee7898eb56263eea0f Mon Sep 17 00:00:00 2001
From: dirwin31 <83434411+dirwin31@users.noreply.github.com>
Date: Sun, 1 Nov 2026 17:29:24 -0800
Subject: [PATCH 24/38] Bring the purple back to the guided setup's selections

The selected adapter or app segment is solid purple with a soft glow instead
of grey, the selected connection option gets a purple-tinted row and a filled
icon tile, the current step and the primary button glow, and a faint purple
wash sits behind the step track.
---
 openpilot/starpilot/galaxy/web/css/galaxy.css | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/openpilot/starpilot/galaxy/web/css/galaxy.css b/openpilot/starpilot/galaxy/web/css/galaxy.css
index 61ec741fd3..96bc7e570e 100644
--- a/openpilot/starpilot/galaxy/web/css/galaxy.css
+++ b/openpilot/starpilot/galaxy/web/css/galaxy.css
@@ -2014,12 +2014,11 @@ progress { max-width: 100%; accent-color: var(--primary); }
   --g-track: color-mix(in srgb, var(--on-surface) 16%, var(--background));  /* opaque, so overlapping segments never show a seam */
   --g-accent: var(--primary);
   --g-done: var(--success);
-  --g-thumb: rgba(255, 255, 255, .18);
   display: grid; gap: var(--sp-5); padding: 28px 28px var(--sp-5); border-radius: var(--radius-lg); margin-block: var(--sp-4);
   font-family: var(--font-body);
   font-size: 16px; line-height: 1.4; color: var(--g-ink); -webkit-font-smoothing: antialiased;
+  background-image: radial-gradient(120% 38% at 50% 0, var(--primary-container), transparent 72%);   /* a soft purple wash behind the steps */
 }
-[data-theme="light"] .gx-card.gx-guided { --g-thumb: #fff; }
 
 /* The step track: three numbered nodes on a line that fills as the setup moves along. */
 .gx-guided__steps { list-style: none; margin: 0; padding: 0; display: grid; grid-template-columns: repeat(3, 1fr); }
@@ -2035,7 +2034,7 @@ progress { max-width: 100%; accent-color: var(--primary); }
   font-size: 15px; font-weight: var(--fw-bold); font-variant-numeric: tabular-nums; background: var(--g-fill); color: var(--g-muted);
   transition: background var(--motion-base), color var(--motion-base), box-shadow var(--motion-base);
 }
-.gx-guided__step.is-current .gx-guided__node { background: var(--g-accent); color: var(--on-primary); box-shadow: 0 0 0 5px color-mix(in srgb, var(--g-accent) 24%, transparent); }
+.gx-guided__step.is-current .gx-guided__node { background: var(--g-accent); color: var(--on-primary); box-shadow: 0 0 0 5px color-mix(in srgb, var(--g-accent) 28%, transparent), 0 4px 16px var(--primary-glow); }
 .gx-guided__step.is-done .gx-guided__node { background: var(--g-done); color: var(--background); animation: gx-guided-pop var(--motion-slow); }
 .gx-guided__step-label { font-size: 13px; font-weight: var(--fw-bold); color: var(--g-muted); }
 .gx-guided__step.is-current .gx-guided__step-label { color: var(--g-ink); }
@@ -2084,6 +2083,8 @@ progress { max-width: 100%; accent-color: var(--primary); }
   flex: none; display: grid; place-items: center; width: 24px; height: 24px; border-radius: var(--radius-full); font-size: 14px; color: transparent;
   border: 1.5px solid color-mix(in srgb, var(--on-surface) 28%, transparent); transition: background var(--motion-base), border-color var(--motion-base);
 }
+.gx-guided__option[aria-checked="true"] { background: var(--primary-container); }
+.gx-guided__option[aria-checked="true"] .gx-guided__tile { background: var(--g-accent); color: var(--on-primary); box-shadow: 0 2px 10px var(--primary-glow); }
 .gx-guided__option[aria-checked="true"] .gx-guided__radio { background: var(--g-accent); border-color: var(--g-accent); color: var(--on-primary); }
 
 /* Segmented control for the adapter and app choices (Galaxy has none). */
@@ -2093,7 +2094,7 @@ progress { max-width: 100%; accent-color: var(--primary); }
   font: inherit; font-size: 15px; font-weight: var(--fw-medium); line-height: 1.2; text-wrap: balance; cursor: pointer;
   transition: background var(--motion-base), color var(--motion-base), box-shadow var(--motion-base);
 }
-.gx-guided__segmented button.is-selected { background: var(--g-thumb); color: var(--g-ink); box-shadow: 0 1px 3px rgba(0, 0, 0, .22), 0 0 0 .5px rgba(0, 0, 0, .06); }
+.gx-guided__segmented button.is-selected { background: var(--g-accent); color: var(--on-primary); box-shadow: 0 2px 12px var(--primary-glow); }
 .gx-guided__segmented button:not(.is-selected):hover:not(:disabled) { color: var(--g-ink); }
 .gx-guided__segmented button:disabled { opacity: .6; cursor: default; }
 
@@ -2131,7 +2132,7 @@ progress { max-width: 100%; accent-color: var(--primary); }
 .gx-guided .gx-btn { min-height: 44px; border-radius: var(--radius-sm); font-size: 16px; font-weight: var(--fw-bold); letter-spacing: -.01em; padding-inline: 18px; box-shadow: none; }
 .gx-guided .gx-btn--tonal { background: var(--g-fill-hover); color: var(--g-ink); border: 0; }
 .gx-guided .gx-btn--tonal:hover:not(:disabled) { background: var(--g-line); }
-.gx-guided .gx-starport-cta { width: 100%; min-height: 54px; border-radius: var(--radius-md); font-size: 17px; }
+.gx-guided .gx-starport-cta { width: 100%; min-height: 54px; border-radius: var(--radius-md); font-size: 17px; box-shadow: 0 6px 22px var(--primary-glow); }
 .gx-guided__footer { display: grid; gap: var(--sp-3); justify-items: stretch; }
 .gx-guided__footer .gx-guided__hint { text-align: center; }
 .gx-guided__link { justify-self: center; padding: var(--sp-2) var(--sp-3); border: 0; background: none; color: var(--g-accent); font: inherit; font-size: 15px; font-weight: var(--fw-medium); cursor: pointer; }

From 3b8d2018395a85a9706d28f08e49f7dcdc6010b7 Mon Sep 17 00:00:00 2001
From: dirwin31 <83434411+dirwin31@users.noreply.github.com>
Date: Mon, 2 Nov 2026 05:49:27 -0800
Subject: [PATCH 25/38] Hide other devices once selected one

---
 openpilot/starpilot/galaxy/web/js/starport.js | 15 ++++++++++++---
 1 file changed, 12 insertions(+), 3 deletions(-)

diff --git a/openpilot/starpilot/galaxy/web/js/starport.js b/openpilot/starpilot/galaxy/web/js/starport.js
index ca5cdd9667..956573e2af 100644
--- a/openpilot/starpilot/galaxy/web/js/starport.js
+++ b/openpilot/starpilot/galaxy/web/js/starport.js
@@ -124,7 +124,7 @@ const PAIR_UI = `
             <p v-if="pairing?.state === 'connecting'" role="status">Connecting to {{ pairing.receiver?.name || 'the selected device' }}…</p>
             <p v-if="['paired', 'connected'].includes(pairing?.state)" role="status"><i class="bi bi-check-circle-fill gx-starport-ok"></i> {{ pairing.receiver?.name || 'Device' }} {{ pairing.state === 'connected' ? 'connected' : 'paired' }}.</p>
             <GxNotice tone="danger" v-if="pairing?.error">{{ pairing.error }}</GxNotice>
-            <ul v-if="pairing?.active" class="gx-starport-list" aria-label="Nearby devices">
+            <ul v-if="pairing?.active && !deviceChosen" class="gx-starport-list" aria-label="Nearby devices">
               <li v-if="!pairing.devices?.length && waitingForCar" class="gx-starport-row gx-note" role="status"><span class="gx-spinner" aria-hidden="true"></span>Nothing found yet. Keep your car’s pairing screen open.</li>
               <li v-for="device in pairing.devices || []" :key="device.address" class="gx-starport-row">
                 <i :class="device.starport ? 'bi bi-car-front' : 'bi bi-bluetooth'" aria-hidden="true"></i>
@@ -132,7 +132,7 @@ const PAIR_UI = `
                 <button class="gx-btn gx-btn--tonal" :disabled="deviceSelectionBlocked" @click="selectDevice(device.address)">{{ device.paired ? 'Connect' : 'Pair' }}</button>
               </li>
             </ul>
-            <div v-if="pairing?.prompt" class="gx-starport-prompt" role="status"><strong>{{ pairing.receiver.name }}</strong>
+            <div v-if="pairing?.prompt" ref="pairPrompt" class="gx-starport-prompt" role="status"><strong>{{ pairing.receiver.name }}</strong>
               <p>{{ pairing.prompt.kind === 'confirmation' ? 'Check that this code matches your car, then confirm.' :
                 pairing.prompt.kind === 'pin' ? 'Enter the PIN shown by your car.' :
                 pairing.prompt.kind === 'passkey' ? 'Enter your car’s passkey.' :
@@ -595,7 +595,11 @@ export const StarPortPage = {
   watch: {
     mode() { if (!document.hidden) this.begin(); else this.feed?.stop(true) },
     localAccess() { if (!document.hidden) this.begin(); else this.feed?.stop(true) },
-    'pairing.prompt.id'() { this.pairValue = "" },
+    'pairing.prompt.id'(id) {
+      this.pairValue = ""
+      // Bring the code into view: the list above it can be long.
+      if (id !== undefined) this.$nextTick(() => this.$refs.pairPrompt?.scrollIntoView?.({ behavior: "smooth", block: "center" }))
+    },
     'pairing.active'(active, was) { if (was && !active) this.loadReceivers() },
     // Find car on a fresh device turns Android Auto on first, then searches once the service is up.
     'setup.serviceReady'() { this.resumePairing() },
@@ -759,6 +763,11 @@ export const StarPortPage = {
       return this.pairing?.active && !this.pairing?.receiver && !this.pairing?.prompt && !this.pairing?.approved &&
         !["pairing", "connecting", "paired", "connected", "failed"].includes(this.pairing?.state)
     },
+    // Once a device is picked the list only gets in the way of the code; it returns if pairing fails.
+    deviceChosen() {
+      const p = this.pairing
+      return !!(p?.receiver || p?.prompt || p?.approved || ["pairing", "connecting", "paired", "connected"].includes(p?.state))
+    },
     deviceSelectionBlocked() {
       return !!this.pairingReason || !this.pairing?.active ||
         !!this.pairing?.prompt || ["pairing", "connecting"].includes(this.pairing?.state) || !!this.linked

From f0c5a666c5a5e62f66174c7f37c514f85935ce49 Mon Sep 17 00:00:00 2001
From: dirwin31 <83434411+dirwin31@users.noreply.github.com>
Date: Mon, 2 Nov 2026 08:05:32 -0800
Subject: [PATCH 26/38] Galaxy Bluetooth setup: one systemd reload, after the
 radio has started

- Link the bridge and discovery units with --no-reload and reload once (was four reloads, 1-3 s each on a comma four).
- Wait (up to 45 s after boot) while starpilot-bluetooth-radio is still activating, so the reload can't stall btattach or bluetoothd.
- Failure handling unchanged; on a comma four this removed the ~20 s Bluetooth boots (now 16.4-16.6 s with stock AGNOS).
---
 .../starpilot/galaxy_bluetooth/bootstrap.py   | 62 +++++++++++++++----
 .../galaxy_bluetooth/tests/test_bootstrap.py  | 60 +++++++++++++++++-
 2 files changed, 109 insertions(+), 13 deletions(-)

diff --git a/openpilot/starpilot/galaxy_bluetooth/bootstrap.py b/openpilot/starpilot/galaxy_bluetooth/bootstrap.py
index 7439dcc4e2..19892f34b7 100644
--- a/openpilot/starpilot/galaxy_bluetooth/bootstrap.py
+++ b/openpilot/starpilot/galaxy_bluetooth/bootstrap.py
@@ -12,6 +12,8 @@ DATA = Path('/data/galaxy-ble')
 BRIDGE = Path(__file__).resolve().parent / 'bridge'
 UNIT = 'galaxy-ble-fork.service'
 LAN_UNIT = 'galaxy-lan-discovery.service'
+RADIO_UNIT = 'starpilot-bluetooth-radio.service'
+RADIO_WAIT_UNTIL = 45.  # seconds since boot; past this, never hold setup for the radio
 STATUS_HEARTBEAT = 30
 STATUS_STALE = 90  # Longer than the slowest step interval (60 s) plus the heartbeat.
 LOG = logging.getLogger('galaxy.bluetooth.setup')
@@ -75,6 +77,48 @@ class Bootstrap:
   def systemctl(self, *args, **kwargs):
     return self.command(['sudo', '-n', 'systemctl', *args], **kwargs)
 
+  def radio_starting(self):
+    """True while the comma Bluetooth radio unit is still starting after boot."""
+    if time.monotonic() > RADIO_WAIT_UNTIL:
+      return False
+    try:
+      result = self.run(['systemctl', 'show', RADIO_UNIT, '--property=ActiveState', '--value'],
+                        timeout=5, check=False, capture_output=True, text=True)
+    except (OSError, subprocess.SubprocessError):
+      return False
+    return result.stdout.strip() == 'activating'
+
+  def register_units(self):
+    """Link the bridge and discovery units with a single systemd reload.
+
+    A reload stalls every other systemd job for 1-3 s at boot, including the Bluetooth radio unit's own
+    steps (starting btattach and bluetoothd), so wait for that unit first and reload once for both units.
+    A bridge failure raises; a discovery failure only leaves discovery unregistered."""
+    if self.registered and self.discovery_registered:
+      return
+    while self.radio_starting():
+      time.sleep(0.5)
+    linked = []
+    if not self.registered:
+      self.systemctl('link', '--runtime', '--force', '--no-reload', str(self.bridge / UNIT), stdout=subprocess.DEVNULL)
+      linked.append(UNIT)
+    if not self.discovery_registered:
+      try:
+        self.systemctl('link', '--runtime', '--force', '--no-reload', str(self.bridge / LAN_UNIT), stdout=subprocess.DEVNULL)
+        linked.append(LAN_UNIT)
+      except (OSError, subprocess.SubprocessError):
+        pass
+    if not linked:
+      return
+    try:
+      self.systemctl('daemon-reload', stdout=subprocess.DEVNULL)
+    except (OSError, subprocess.SubprocessError):
+      if UNIT in linked:
+        raise
+      return
+    self.registered = self.registered or UNIT in linked
+    self.discovery_registered = self.discovery_registered or LAN_UNIT in linked
+
   def step(self):
     wake = self.data / 'wake-setup.json'
     if wake.exists():
@@ -93,20 +137,14 @@ class Bootstrap:
       # The bridge runs before any phone is paired; an empty phone list accepts no one.
       from openpilot.starpilot.galaxy_bluetooth.bridge.pairing import ensure_store
       ensure_store(self.data / 'pairing.json')
-      if not self.registered:
-        self.systemctl('link', '--runtime', '--force', str(self.bridge / UNIT), stdout=subprocess.DEVNULL)
-        self.systemctl('daemon-reload', stdout=subprocess.DEVNULL)
-        self.registered = True
+      self.register_units()
       # Discovery remains available when Bluetooth is off or the BLE service retries.
       # An optional discovery failure must not prevent Bluetooth startup.
-      try:
-        if not self.discovery_registered:
-          self.systemctl('link', '--runtime', '--force', str(self.bridge / LAN_UNIT), stdout=subprocess.DEVNULL)
-          self.systemctl('daemon-reload', stdout=subprocess.DEVNULL)
-          self.discovery_registered = True
-        self.systemctl('start', LAN_UNIT, stdout=subprocess.DEVNULL)
-      except (OSError, subprocess.SubprocessError):
-        pass
+      if self.discovery_registered:
+        try:
+          self.systemctl('start', LAN_UNIT, stdout=subprocess.DEVNULL)
+        except (OSError, subprocess.SubprocessError):
+          pass
       from openpilot.starpilot.bluetooth.radio_preference import RadioPreference
       if not RadioPreference().enabled():
         self.run(['sudo', '-n', 'systemctl', 'stop', UNIT], timeout=20, check=False,
diff --git a/openpilot/starpilot/galaxy_bluetooth/tests/test_bootstrap.py b/openpilot/starpilot/galaxy_bluetooth/tests/test_bootstrap.py
index 5f9cb4b5e5..11683a0110 100644
--- a/openpilot/starpilot/galaxy_bluetooth/tests/test_bootstrap.py
+++ b/openpilot/starpilot/galaxy_bluetooth/tests/test_bootstrap.py
@@ -1,10 +1,11 @@
 """Setup never downloads packages and never turns on the shared Bluetooth radio."""
 from pathlib import Path
+import subprocess
 import tempfile
 from types import SimpleNamespace
 import unittest
 from unittest.mock import Mock, patch
-from openpilot.starpilot.galaxy_bluetooth.bootstrap import Bootstrap, UNIT
+from openpilot.starpilot.galaxy_bluetooth.bootstrap import Bootstrap, LAN_UNIT, RADIO_UNIT, RADIO_WAIT_UNTIL, UNIT
 
 
 class BootstrapTest(unittest.TestCase):
@@ -106,5 +107,62 @@ class BootstrapTest(unittest.TestCase):
     self.assertFalse(any('restart' in call for call in self.calls))
     self.assertFalse(any('bluetooth.service' in call for call in self.calls))
 
+  def test_both_units_link_with_one_reload(self):
+    with patch('openpilot.starpilot.bluetooth.radio_preference.RadioPreference.enabled', return_value=True):
+      self.worker.step()
+    links = [call for call in self.calls if 'link' in call]
+    self.assertEqual(len(links), 2)
+    self.assertTrue(all('--no-reload' in call for call in links))
+    self.assertEqual(len([call for call in self.calls if 'daemon-reload' in call]), 1)
+    self.assertTrue(self.worker.registered and self.worker.discovery_registered)
+
+  def test_setup_waits_for_the_radio_unit_at_boot(self):
+    states = iter(['activating', 'activating', 'active'])
+    def run(args, **kwargs):
+      self.calls.append(args)
+      if 'show' in args and RADIO_UNIT in args:
+        return SimpleNamespace(stdout=next(states) + '\n', returncode=0)
+      self.assertNotIn('show', args)
+      return SimpleNamespace(stdout='1', returncode=0)
+    self.worker.run = run
+    with patch('openpilot.starpilot.bluetooth.radio_preference.RadioPreference.enabled', return_value=True), \
+         patch('openpilot.starpilot.galaxy_bluetooth.bootstrap.time.monotonic', return_value=12.0), \
+         patch('openpilot.starpilot.galaxy_bluetooth.bootstrap.time.sleep') as sleep:
+      self.worker.step()
+    self.assertEqual(sleep.call_count, 2)
+    first_link = next(i for i, call in enumerate(self.calls) if 'link' in call)
+    radio_checks = [i for i, call in enumerate(self.calls) if 'show' in call and RADIO_UNIT in call]
+    self.assertEqual(len(radio_checks), 3)
+    self.assertLess(max(radio_checks), first_link)
+
+  def test_setup_never_waits_for_the_radio_late_in_the_boot(self):
+    with patch('openpilot.starpilot.bluetooth.radio_preference.RadioPreference.enabled', return_value=True), \
+         patch('openpilot.starpilot.galaxy_bluetooth.bootstrap.time.monotonic', return_value=RADIO_WAIT_UNTIL + 1):
+      self.worker.step()
+    self.assertFalse(any('show' in call and RADIO_UNIT in call for call in self.calls))
+    self.assertTrue(self.worker.registered)
+
+  def test_discovery_link_failure_still_registers_the_bridge(self):
+    def run(args, **kwargs):
+      self.calls.append(args)
+      if 'link' in args and str(self.bridge / LAN_UNIT) in args:
+        raise subprocess.CalledProcessError(1, args)
+      return SimpleNamespace(stdout='1', returncode=0)
+    self.worker.run = run
+    with patch('openpilot.starpilot.bluetooth.radio_preference.RadioPreference.enabled', return_value=True):
+      self.worker.step()
+    self.assertTrue(self.worker.registered)
+    self.assertFalse(self.worker.discovery_registered)
+    self.assertEqual(len([call for call in self.calls if 'daemon-reload' in call]), 1)
+    self.assertFalse(any('start' in call and LAN_UNIT in call for call in self.calls))
+    self.assertTrue(any('start' in call and UNIT in call for call in self.calls))
+
+  def test_registered_units_never_reload_or_check_the_radio(self):
+    self.worker.registered = self.worker.discovery_registered = True
+    with patch('openpilot.starpilot.bluetooth.radio_preference.RadioPreference.enabled', return_value=True):
+      self.worker.step()
+    self.assertFalse(any('daemon-reload' in call or 'link' in call for call in self.calls))
+    self.assertFalse(any('show' in call and RADIO_UNIT in call for call in self.calls))
+
 if __name__ == '__main__':
   unittest.main()

From e99e552f217dc9873cad570685f58730d517efdf Mon Sep 17 00:00:00 2001
From: dirwin31 <83434411+dirwin31@users.noreply.github.com>
Date: Mon, 2 Nov 2026 16:36:36 -0800
Subject: [PATCH 27/38] StarPort: wait out the comma's own Wi-Fi switching
 networks, and say so on the car screen

- When the comma's Wi-Fi joins or roams while the car is on aa0, wait up to 8 s for video acks instead of 2.5 s; reconnect at once if the car takes its screen back.
- After a drop it causes, the car screen shows "Reconnected: comma Wi-Fi Joined <network>" (the network's SSID) for 8 s; Galaxy and bug reports name it too.
- Logs ack_grace, ack_grace_recovered and other_wifi_changed events.
---
 .../system/starport/bugsink_diagnosis.py      |   3 +
 .../system/starport/current_car_ui.py         |   4 +-
 .../starpilot/system/starport/network.py      |  31 ++++
 .../system/starport/projection_onroad.py      |  20 ++-
 .../system/starport/reconnect_notice.py       |  51 ++++++
 .../starpilot/system/starport/session.py      |  46 ++++-
 .../starpilot/system/starport/supervisor.py   |  70 +++++++-
 .../tests/test_projection_onroad_boundary.py  |  34 ++++
 .../starport/tests/test_shared_radio_grace.py | 166 ++++++++++++++++++
 9 files changed, 420 insertions(+), 5 deletions(-)
 create mode 100644 openpilot/starpilot/system/starport/reconnect_notice.py
 create mode 100644 openpilot/starpilot/system/starport/tests/test_shared_radio_grace.py

diff --git a/openpilot/starpilot/system/starport/bugsink_diagnosis.py b/openpilot/starpilot/system/starport/bugsink_diagnosis.py
index 61b4fc0374..f9a3d97dae 100644
--- a/openpilot/starpilot/system/starport/bugsink_diagnosis.py
+++ b/openpilot/starpilot/system/starport/bugsink_diagnosis.py
@@ -98,6 +98,9 @@ def attempt_records(events):
 
 
 STREAM_LOSS = {
+  "shared_radio": ("comma's own Wi-Fi", "The car stopped acknowledging video while the comma's own Wi-Fi joined or roamed; both share one radio.",
+                   ["Check the other_wifi_changed and ack_grace events for the network and how long acks stopped.",
+                    "Repeated drops at home or on a hotspot mean the 8 s grace is too short or the car takes its screen back first."]),
   "stalled": ("Video acknowledgement older than", "The car kept the link but stopped acknowledging video for too long, so the stream was ended.",
               ["Compare the Wi-Fi signal, frame age and encoder recoveries around the stall.",
                "If it repeats at the same place or speed, look for the comma stalling (CPU, thermal) rather than the car."]),
diff --git a/openpilot/starpilot/system/starport/current_car_ui.py b/openpilot/starpilot/system/starport/current_car_ui.py
index fee76b7488..55230853a0 100644
--- a/openpilot/starpilot/system/starport/current_car_ui.py
+++ b/openpilot/starpilot/system/starport/current_car_ui.py
@@ -188,12 +188,14 @@ def run(frames_path: str, touch_path: str | None = None, control_path: str | Non
     gui_app._width, gui_app._height = geometry.logical_width, geometry.logical_height
     gui_app._scale = 1.0
     gui_app._render_texture = None
+    from openpilot.starpilot.system.starport import reconnect_notice
     from openpilot.starpilot.system.starport.identity import certificate_days_left
     from openpilot.starpilot.system.starport.projection_layout_runtime import ProjectionLayoutWatcher, comma_display_seed
     viewport = (geometry.logical_width, geometry.logical_height)
     watcher = ProjectionLayoutWatcher(viewport, display_seed=comma_display_seed)
     layout = ProjectionOnroad(viewport=viewport, customization=watcher.load(),
-                              certificate_days=certificate_days_left(), layout_watcher=watcher)
+                              certificate_days=certificate_days_left(), layout_watcher=watcher,
+                              reconnect_notice=reconnect_notice.take())
     resources.callback(layout.close)
     watcher.start()
     resources.callback(watcher.close)
diff --git a/openpilot/starpilot/system/starport/network.py b/openpilot/starpilot/system/starport/network.py
index 1611016419..9609b64492 100644
--- a/openpilot/starpilot/system/starport/network.py
+++ b/openpilot/starpilot/system/starport/network.py
@@ -109,6 +109,37 @@ def recover_autoconnect(log: Callable[..., None], marker: Path = AUTOCONNECT_MAR
   return True
 
 
+SETTINGS_PROFILE_PREFIX = "openpilot connection "  # system/ui/lib/wifi_manager.py names saved networks this way
+
+
+def profile_network_name(profile: str) -> str:
+  """A saved connection's network name: "openpilot connection Home" -> "Home"; other profiles as they are."""
+  return profile[len(SETTINGS_PROFILE_PREFIX):] if profile.startswith(SETTINGS_PROFILE_PREFIX) else profile
+
+
+def wifi_network_name(interface: str = "wlan0") -> str:
+  """The network the comma's own Wi-Fi is on or joining, for telling the driver; "" if none or unknown.
+
+  Its own D-Bus connection: never the car lease's, whose lock the link check and reconnect wait on."""
+  lease = NetworkLease(lambda *args, **kwargs: None, interface)
+  try:
+    for path, name in lease._wifi_devices():
+      if name != interface:
+        continue
+      access_point = lease._get(path, NM_WIRELESS_IFACE, "ActiveAccessPoint")
+      if access_point and access_point != "/":
+        ssid = bytes(lease._get(access_point, NM_AP_IFACE, "Ssid")).decode("utf-8", "replace").strip()
+        if ssid:
+          return ssid
+      # Still joining (no access point yet): the profile's name, which the comma's Wi-Fi settings prefix.
+      active = lease._get(path, NM_DEVICE_IFACE, "ActiveConnection")
+      return profile_network_name(str(lease._get(active, NM_ACTIVE_IFACE, "Id"))) if active and active != "/" else ""
+    return ""
+  finally:
+    if lease.router is not None:
+      lease.router.close()
+
+
 def connection_settings(credentials: WifiCredentials, interface: str) -> dict:
   wireless = {
     "ssid": ("ay", credentials.ssid.encode("utf-8")),
diff --git a/openpilot/starpilot/system/starport/projection_onroad.py b/openpilot/starpilot/system/starport/projection_onroad.py
index 72e2499a4c..52a8a8181d 100644
--- a/openpilot/starpilot/system/starport/projection_onroad.py
+++ b/openpilot/starpilot/system/starport/projection_onroad.py
@@ -14,6 +14,7 @@ from openpilot.starpilot.system.starport.projection_map_lease import MapLeaseWri
 CERTIFICATE_NOTICE_NS = 10_000_000_000  # how long the expiry heads-up stays at the start of a drive
 BOOKMARK_NOTICE_NS = 2_000_000_000  # how long "Bookmark Saved" stays after the drive is bookmarked
 MODE_NOTICE_NS = 2_000_000_000  # how long the driving-mode banner stays after the mode changes
+RECONNECT_NOTICE_NS = 8_000_000_000  # how long "why it reconnected" stays once the car screen is back
 DRIVER_MONITOR_HOLD_NS = 350_000_000
 STANDBY_LOGO = Path(__file__).parents[3] / 'selfdrive/assets/images/starpilot_logo.png'
 BUBBLE_REDUNDANT_ALERTS = frozenset(('preLaneChangeLeft', 'preLaneChangeRight', 'laneChange',
@@ -150,12 +151,14 @@ class ProjectionOnroad:
   """Separate renderer with projected actions; native UIState stays read-only."""
 
   def __init__(self, *, dependencies=None, viewport=None, customization=None, certificate_days=None, native_focus=None,
-               layout_watcher=None):
+               layout_watcher=None, reconnect_notice=""):
     viewport = FALLBACK_VIEWPORT if viewport is None else viewport
     self.width, self.height = viewport
     self.customization = customization
     self._certificate_notice = certificate_notice(certificate_days)
     self._certificate_notice_until_ns: int | None = None
+    self._reconnect_notice = reconnect_notice
+    self._reconnect_notice_until_ns: int | None = None
     self._bookmark_notice_until_ns: int | None = None
     self._mode_label: str | None = None  # the drive's last known driving mode
     self._mode_engaged: bool | None = None
@@ -424,6 +427,18 @@ class ProjectionOnroad:
     return replace(state, alert=self.native.alert(size=sizes.SMALL, text1=self._certificate_notice,
                                                   alert_type='androidAutoCertificate/warning'))
 
+  def _with_reconnect_notice(self, state, now_ns):
+    """Say why the car screen just came back (the comma's Wi-Fi switched networks); a real alert always wins."""
+    if not self._reconnect_notice:
+      return state
+    if self._reconnect_notice_until_ns is None:
+      self._reconnect_notice_until_ns = now_ns + RECONNECT_NOTICE_NS
+    sizes = self.native.alert_size
+    if now_ns >= self._reconnect_notice_until_ns or state.alert.size != sizes.NONE:
+      return state
+    return replace(state, alert=self.native.alert(size=sizes.SMALL, text1=self._reconnect_notice,
+                                                  alert_type='androidAutoReconnected/info'))
+
   def bookmark_saved(self, now_ns=None):
     """A bookmark was published for this drive (from any button): confirm it on the car screen."""
     self._bookmark_notice_until_ns = (time.monotonic_ns() if now_ns is None else now_ns) + BOOKMARK_NOTICE_NS
@@ -516,7 +531,8 @@ class ProjectionOnroad:
       # Touch hit-tests read viewport_width; the view draws at the car canvas width (1920 for a 1280x720 head unit).
       if state.viewport_width != self.width:
         state = replace(state, viewport_width=self.width)
-      state = self._with_bookmark_notice(self._with_certificate_notice(state, now_ns), now_ns)
+      state = self._with_certificate_notice(self._with_reconnect_notice(state, now_ns), now_ns)
+      state = self._with_bookmark_notice(state, now_ns)
       self._state = self._with_mode_notice(state, now_ns)
       if self._slc_input is not None:
         self._state = self._slc_input.present(self._state)
diff --git a/openpilot/starpilot/system/starport/reconnect_notice.py b/openpilot/starpilot/system/starport/reconnect_notice.py
new file mode 100644
index 0000000000..9862e9e66d
--- /dev/null
+++ b/openpilot/starpilot/system/starport/reconnect_notice.py
@@ -0,0 +1,51 @@
+"""Why the last projection reconnected, handed from the supervisor to the next car-screen renderer."""
+
+from __future__ import annotations
+
+import json
+import os
+import time
+from pathlib import Path
+
+from openpilot.starpilot.system.starport import identity as identity_store
+
+NOTICE_PATH = identity_store.DATA_DIR / "reconnect_notice.json"
+NOTICE_FRESH_S = 120.0  # a notice older than this is about an earlier drive or reconnect (monotonic: same boot only)
+NAME_MAX = 24
+
+
+def shared_radio_text(network: str) -> str:
+  """The car-screen line for a drop caused by the comma's own Wi-Fi joining or roaming."""
+  name = network.strip()
+  if len(name) > NAME_MAX:
+    name = name[:NAME_MAX - 3].rstrip() + "..."  # plain dots: the car-screen fonts may lack an ellipsis glyph
+  return f"Reconnected: comma Wi-Fi Joined {name}" if name else "Reconnected: comma Wi-Fi Was Switching Networks"
+
+
+def write(text: str, path: Path = NOTICE_PATH, now: float | None = None) -> None:
+  try:
+    path.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
+    temporary = path.with_suffix(".tmp")
+    temporary.write_text(json.dumps({"text": text, "written": time.monotonic() if now is None else now}))
+    os.replace(temporary, path)
+  except OSError:
+    pass  # the notice is a courtesy; projection never depends on it
+
+
+def take(path: Path = NOTICE_PATH, now: float | None = None) -> str:
+  """Read and remove the pending notice; "" if there is none or it is stale."""
+  try:
+    record = json.loads(path.read_text())
+  except (OSError, ValueError):
+    return ""
+  try:
+    path.unlink()
+  except OSError:
+    pass
+  now = time.monotonic() if now is None else now
+  if not isinstance(record, dict) or not isinstance(record.get("text"), str):
+    return ""
+  written = record.get("written")
+  if not isinstance(written, (int, float)) or not 0 <= now - written <= NOTICE_FRESH_S:
+    return ""
+  return record["text"]
diff --git a/openpilot/starpilot/system/starport/session.py b/openpilot/starpilot/system/starport/session.py
index 22f3ff284f..5eb2221bf1 100644
--- a/openpilot/starpilot/system/starport/session.py
+++ b/openpilot/starpilot/system/starport/session.py
@@ -116,6 +116,14 @@ class PeerRequestedStop(EOFError):
   pass
 
 
+class SharedRadioStall(TimeoutError):
+  """The car stopped acknowledging video while the comma's other Wi-Fi network was joining or roaming."""
+
+  def __init__(self, message: str, network: str):
+    super().__init__(message)
+    self.network = network
+
+
 START_CODE = re.compile(b"\x00\x00(?:\x00)?\x01")
 
 
@@ -644,9 +652,22 @@ class ProjectionSession(Session):
   # held it ~1 s on 2026-10-01 while the car kept acking in 27-219 ms. Stays under the 3 s after which a Honda takes
   # its screen back without video.
   ACK_TIMEOUT = 2.5
+  # The radio is shared with the comma's own Wi-Fi (aa0 + wlan0): joining or roaming there stalled the car's acks past
+  # 2.5 s on 2026-11-02 (hotspot join, home join, mesh roam). While that happens, wait this long before reconnecting.
+  ACK_GRACE_TIMEOUT = 8.0
   ACK_DRAIN_SECONDS = 0.1  # before calling an ACK late, read what already arrived, for at most this long
   MAX_WINDOW = 2
   nav = None
+  grace_frame: float | None = None  # send time of the frame whose late ack is being waited out
+  grace_network = ""
+  grace_focus_lost = False
+
+  @staticmethod
+  def radio_change() -> str | None:
+    """Replaced by the supervisor: the comma's other Wi-Fi network's name if it joined or roamed in the last few
+    seconds ("" when unnamed), else None."""
+    return None
+
   # HeadunitPad acknowledges every fragment (codec config included) rather than every frame.
   fragment_acks = False
 
@@ -885,6 +906,8 @@ class ProjectionSession(Session):
     granted = focus in (FOCUS_PROJECTED, FOCUS_PROJECTED_NO_INPUT)
     self.focused = granted and self.allow_projection
     self.event("video_focus", focus=focus, unsolicited=unsolicited, focused=self.focused)
+    if was_focused and not self.focused and self.grace_frame is not None:
+      self.grace_focus_lost = True  # the car gave up on the stalled video: reconnect rather than wait unfocused
     if was_focused and not self.focused and self.touch is not None:
       self.touch_events.extend(self.touch.reset())
     if self.focused and not was_focused:
@@ -943,6 +966,9 @@ class ProjectionSession(Session):
     self.unacked -= count
     self.acked += count
     self.epoch_acked += count
+    if self.grace_frame is not None and (not self.pending or self.pending[0] != self.grace_frame):
+      self.event("ack_grace_recovered", network=self.grace_network, gap_ms=round((now - self.grace_frame) * 1000))
+      self.grace_frame = None
     self._confirm_video()
 
   def _confirm_video(self) -> None:
@@ -966,6 +992,8 @@ class ProjectionSession(Session):
   def check_progress(self, now: float | None = None) -> None:
     measured = now is None
     now = time.monotonic() if measured else now
+    if self.grace_focus_lost:
+      raise SharedRadioStall("The car took its screen back while the comma's Wi-Fi was switching networks", self.grace_network)
     if self._ack_overdue(now):
       # ACKs that arrived while this loop was busy (a slow encode, a CPU burst) still sit in the socket; the
       # streaming loop drains only a bounded batch per pass, so read what is there before calling the car silent.
@@ -975,12 +1003,28 @@ class ProjectionSession(Session):
       if measured:
         now = time.monotonic()
       if self._ack_overdue(now):
-        raise TimeoutError(f"Video acknowledgement older than {self.ACK_TIMEOUT:.1f} s")
+        self._wait_out_radio_change(now)
     # Only a receiver known to answer pings can be declared dead by silence; for
     # others a lost link surfaces as a socket error or a dropped Wi-Fi lease.
     if self.ping_responses and now - self.last_rx > 15.0:
       raise TimeoutError("Head unit stopped answering for 15 s")
 
+  def _wait_out_radio_change(self, now: float) -> None:
+    """The oldest frame is past ACK_TIMEOUT: give up, unless the comma's other Wi-Fi just changed networks."""
+    oldest = self.pending[0]
+    if self.grace_frame == oldest:
+      network = self.grace_network
+    else:
+      changed = self.radio_change()
+      if changed is None:
+        raise TimeoutError(f"Video acknowledgement older than {self.ACK_TIMEOUT:.1f} s")
+      self.grace_frame, self.grace_network = oldest, changed
+      self.event("ack_grace", network=changed, after_ms=round((now - oldest) * 1000))
+      network = changed
+    if now - oldest > self.ACK_GRACE_TIMEOUT:
+      message = f"Video acknowledgement older than {self.ACK_GRACE_TIMEOUT:.1f} s while the comma's Wi-Fi was switching networks"
+      raise SharedRadioStall(message, network)
+
   def send_frame(self, data: bytes, timestamp_us: int, *, keyframe: bool) -> None:
     if not self.can_send():
       raise RuntimeError("Cannot send without video focus and window credit")
diff --git a/openpilot/starpilot/system/starport/supervisor.py b/openpilot/starpilot/system/starport/supervisor.py
index 19f7d42b98..37376dd798 100644
--- a/openpilot/starpilot/system/starport/supervisor.py
+++ b/openpilot/starpilot/system/starport/supervisor.py
@@ -34,6 +34,7 @@ from typing import Any
 
 from openpilot.common.hardware import COMMA_HARDWARE
 from openpilot.starpilot.system.starport import car_profiles, device_health, identity as identity_store, new_setup, reachability, setup_ladder, system_slice
+from openpilot.starpilot.system.starport import reconnect_notice
 from openpilot.starpilot.system.starport.auto_connect import AutoConnectPolicy
 from openpilot.starpilot.system.starport.bootstrap import MODERN_MAJOR, NAMES, BootstrapError, BootstrapTimeout, WirelessBootstrap
 from openpilot.starpilot.system.starport.bugsink_report import PairingAttempt
@@ -42,7 +43,7 @@ from openpilot.starpilot.system.starport.frame_source import (DEFAULT_PATH as DE
 from openpilot.starpilot.system.starport.projection_control import DEFAULT_CONTROL_SOCKET, NATIVE_FOCUS
 from openpilot.starpilot.system.starport.touch import DEFAULT_TOUCH_SOCKET
 from openpilot.starpilot.system.starport.view import CAR_FRAME_PATH, ViewSource, renderer_available
-from openpilot.starpilot.system.starport.session import CODEC_H265, AuthenticationRejected, PeerRequestedStop, ProjectionSession
+from openpilot.starpilot.system.starport.session import CODEC_H265, AuthenticationRejected, PeerRequestedStop, ProjectionSession, SharedRadioStall
 
 BACKOFF_SECONDS = (2.0, 4.0, 8.0, 15.0, 30.0)
 STABLE_SESSION_SECONDS = 30.0
@@ -67,6 +68,8 @@ USB_CONFIGURE_WAIT = 15.0    # slower receivers need time to enumerate after the
 LINK_CHECK_INTERVAL = 1.0    # how often the link watcher asks whether the car's Wi-Fi is still up
 LINK_CHECK_SLOW = 1.0        # a link check slower than this is logged (NetworkManager answers over D-Bus)
 STREAM_STALL_LOG = 1.0       # a streaming loop pass slower than this is logged
+RADIO_CHECK_INTERVAL = 0.5   # how often the comma's own Wi-Fi is checked for a join or roam (a sysfs read)
+RADIO_CHANGE_WINDOW = 15.0   # a join or roam this recent can still stall the car (11-02: stall came 7.5 s after a roam)
 REPORTED_SETTINGS = ("connection", "usb_mode", "view", "encoder", "fps", "bitrate_kbps", "rate_control", "gpu_nv12",
                      "async_readback", "wifi_interface", "dedicated_wifi_interface", "verify_head_unit", "version_status",
                      "rfcomm_channel", "phone_class", "auto_connect", "allow_hevc")
@@ -250,6 +253,60 @@ class LinkWatch:
       self._stop.wait(self.interval)
 
 
+class SharedRadioWatch:
+  """Notices the comma's own Wi-Fi joining or roaming while the car is on aa0; both share one radio.
+
+  The link going down or up bumps carrier_changes, a plain sysfs read. The network's name comes from
+  NetworkManager on this thread, never the streaming one.
+  """
+
+  def __init__(self, log: Callable[..., None], interface: str = "wlan0", interval: float = RADIO_CHECK_INTERVAL,
+               counter: Path | None = None, name: Callable[[str], str] | None = None):
+    self.log, self.interface, self.interval = log, interface, interval
+    if name is None:
+      from openpilot.starpilot.system.starport.network import wifi_network_name as name
+    self.name = name
+    self.counter = counter or Path(f"/sys/class/net/{interface}/carrier_changes")
+    self.changed_at: float | None = None
+    self.network = ""
+    self._stop = threading.Event()
+    self._thread = threading.Thread(target=self._run, name="aa_radio_watch", daemon=True)
+
+  def start(self) -> SharedRadioWatch:
+    self._thread.start()
+    return self
+
+  def stop(self) -> None:
+    self._stop.set()
+
+  def recent(self, now: float | None = None) -> str | None:
+    """The other network's name if it changed within RADIO_CHANGE_WINDOW ("" if unnamed), else None."""
+    changed_at = self.changed_at
+    now = time.monotonic() if now is None else now
+    return self.network if changed_at is not None and now - changed_at <= RADIO_CHANGE_WINDOW else None
+
+  def _read(self) -> str | None:
+    try:
+      return self.counter.read_text().strip()
+    except OSError:
+      return None
+
+  def _run(self) -> None:
+    last = self._read()
+    while not self._stop.wait(self.interval):
+      current = self._read()
+      if current is None or current == last:
+        continue
+      last = current
+      self.network = ""  # named below; D-Bus can be slow, and the change must count from now
+      self.changed_at = time.monotonic()
+      try:
+        self.network = self.name(self.interface)
+      except Exception:
+        self.network = ""
+      self.log("other_wifi_changed", interface=self.interface, network=self.network)
+
+
 class EventLog:
   """Sanitized JSONL session log under /data/starport/logs, plus the recent tail in memory.
 
@@ -1263,6 +1320,8 @@ class Supervisor:
           self._set(error=message)
           reach = reachability.classify(stage, type(error).__name__, f"{message} {error}")
           self.log("attempt_failed", stage=stage, error=message, kind=type(error).__name__, where=_where(error), reach=reach)
+          if isinstance(error, SharedRadioStall):
+            reconnect_notice.write(reconnect_notice.shared_radio_text(error.network))
           if isinstance(error, StrayLinkError):
             self._clear_stray_link()
             car_first = True  # the car pages right back once its link drops; let it, rather than crossing it again
@@ -1305,6 +1364,9 @@ class Supervisor:
   def _describe_error(stage: str, error: Exception) -> str:
     if isinstance(error, AuthenticationRejected):
       return "The car rejected the Android Auto identity; it may have expired"
+    if isinstance(error, SharedRadioStall):
+      joined = f"joined {error.network}" if error.network else "was switching networks"
+      return f"The car's Wi-Fi stalled while the comma's own Wi-Fi {joined}; reconnecting"
     text = str(error) or type(error).__name__
     if stage == "authenticating" and "certificate" in text.lower():
       text += " (set verify_head_unit false in config.json to test without verifying the car)"
@@ -1667,6 +1729,10 @@ class Supervisor:
                         renderer_log=identity_store.LOG_DIR / "car_ui.log")
     self._set(view=source.label, encoder=getattr(encoder, "backend", "libx264"), target_fps=fps)
     watch = LinkWatch(lease, self.log).start()
+    radio = None
+    if getattr(lease, "dedicated", False) and getattr(lease, "interface", "wlan0") != "wlan0":
+      radio = SharedRadioWatch(self.log).start()
+      session.radio_change = radio.recent
     try:
       from openpilot.starpilot.system.starport.media_audio import MediaAudio, music_control
       from openpilot.starpilot.system.starport.media_status import MediaStatus
@@ -1690,6 +1756,8 @@ class Supervisor:
       if getattr(session, "nav", None) is not None:
         session.nav.close()
       watch.stop()
+      if radio is not None:
+        radio.stop()
       source.close()
       encoder.close()
       if self._stop.is_set():
diff --git a/openpilot/starpilot/system/starport/tests/test_projection_onroad_boundary.py b/openpilot/starpilot/system/starport/tests/test_projection_onroad_boundary.py
index bb2afe0a54..1a7a47af27 100644
--- a/openpilot/starpilot/system/starport/tests/test_projection_onroad_boundary.py
+++ b/openpilot/starpilot/system/starport/tests/test_projection_onroad_boundary.py
@@ -401,6 +401,40 @@ class TestProjectionOnroad(unittest.TestCase):
     self.assertEqual(shown, [notice, notice, 'Lane Departure Detected', '', notice])
     view.close()
 
+  def test_reconnect_notice_shows_eight_seconds_under_real_alerts_and_before_the_certificate(self):
+    native, _ = self.dependencies()
+
+    @dataclass(frozen=True)
+    class Alert:
+      size: str = 'none'
+      text1: str = ''
+      alert_type: str = ''
+
+    real = {'alert': Alert()}
+    native.alert, native.alert_size = Alert, SimpleNamespace(NONE='none', SMALL='small')
+    native.adapter = lambda *_: SimpleNamespace(build=lambda *_a, **_k: SimpleNamespace(
+      onroad=OnroadState(False, False, None, None, SpeedLimitObservation(), alert=cast(Any, real['alert']))))
+    reconnected = 'Reconnected: comma Wi-Fi Joined Home'
+    view = projection.ProjectionOnroad(dependencies=native, certificate_days=3, reconnect_notice=reconnected)
+    shown = []
+    view.onroad.render = lambda state: shown.append(state.alert.text1)
+    clock = [0]
+    original = projection.time
+    projection.time = SimpleNamespace(monotonic_ns=lambda: clock[0])
+    try:
+      native.ui_state.started = True
+      for clock[0] in (100, 7_000_000_000):
+        view.render()
+      real['alert'] = Alert('mid', 'Lane Departure Detected')
+      view.render()  # a real alert always wins
+      real['alert'] = Alert()
+      clock[0] = 8_000_000_200
+      view.render()  # past eight seconds: the certificate heads-up gets its remaining time
+    finally:
+      projection.time = original
+    self.assertEqual(shown, [reconnected, reconnected, 'Lane Departure Detected', 'Heads Up: AA Certificate Expires in 3 Days'])
+    view.close()
+
   def test_no_certificate_notice_when_far_from_expiry(self):
     native, _ = self.dependencies()
     view = projection.ProjectionOnroad(dependencies=native, certificate_days=200)
diff --git a/openpilot/starpilot/system/starport/tests/test_shared_radio_grace.py b/openpilot/starpilot/system/starport/tests/test_shared_radio_grace.py
new file mode 100644
index 0000000000..f72918f3ec
--- /dev/null
+++ b/openpilot/starpilot/system/starport/tests/test_shared_radio_grace.py
@@ -0,0 +1,166 @@
+"""2026-11-02: the comma's own Wi-Fi joining or roaming stalled the car's video acks (one shared radio)."""
+import time
+
+import pytest
+
+from openpilot.starpilot.system.starport import reconnect_notice
+from openpilot.starpilot.system.starport.bugsink_diagnosis import stream_loss_kind
+from openpilot.starpilot.system.starport import supervisor as supervisor_module
+from openpilot.starpilot.system.starport.session import ProjectionSession, SharedRadioStall
+from openpilot.starpilot.system.starport.supervisor import SharedRadioWatch, Supervisor
+from openpilot.starpilot.system.starport.tests.fake_head_unit import FakeHeadUnit, make_identity
+from openpilot.starpilot.system.starport.tests.test_starport import end_session, pump_until, sent_frame, streaming_session
+
+
+@pytest.fixture(scope="module")
+def identity(tmp_path_factory):
+  return make_identity(tmp_path_factory.mktemp("identity"))
+
+
+def stalled(identity, network: str | None):
+  hu = FakeHeadUnit(identity)
+  session = streaming_session(hu, identity)
+  session.radio_change = lambda: network
+  hu.hold_acks.set()
+  return hu, session, sent_frame(hu, session)
+
+
+def test_no_radio_change_keeps_the_standard_limit(identity):
+  hu, session, sent = stalled(identity, None)
+  with pytest.raises(TimeoutError, match="2.5 s") as raised:
+    session.check_progress(now=sent + ProjectionSession.ACK_TIMEOUT + 0.05)
+  assert not isinstance(raised.value, SharedRadioStall)
+  end_session(session, hu)
+
+
+def test_radio_change_waits_up_to_the_grace_limit_then_names_the_network(identity):
+  hu, session, sent = stalled(identity, "Huckleberrys House")
+  session.check_progress(now=sent + ProjectionSession.ACK_TIMEOUT + 0.05)
+  session.check_progress(now=sent + ProjectionSession.ACK_GRACE_TIMEOUT - 0.1)
+  with pytest.raises(SharedRadioStall) as raised:
+    session.check_progress(now=sent + ProjectionSession.ACK_GRACE_TIMEOUT + 0.05)
+  assert raised.value.network == "Huckleberrys House"
+  end_session(session, hu)
+
+
+def test_grace_started_by_a_change_survives_the_change_ageing_out(identity):
+  hu, session, sent = stalled(identity, "Home")
+  session.check_progress(now=sent + ProjectionSession.ACK_TIMEOUT + 0.05)
+  session.radio_change = lambda: None  # same stall: the decision was made when it began
+  session.check_progress(now=sent + ProjectionSession.ACK_GRACE_TIMEOUT - 0.1)
+  end_session(session, hu)
+
+
+def test_acks_resuming_during_the_grace_keep_the_session_and_log_the_gap(identity):
+  hu, session, sent = stalled(identity, "Home")
+  events = []
+  session.event = lambda name, **fields: events.append((name, fields))
+  session.check_progress(now=sent + ProjectionSession.ACK_TIMEOUT + 0.05)
+  hu.hold_acks.clear()
+  hu._ack(session.session_id)
+  pump_until(session, lambda: not session.pending)
+  assert session.grace_frame is None
+  assert [name for name, _ in events] == ["ack_grace", "ack_grace_recovered"]
+  session.check_progress(now=sent + ProjectionSession.ACK_GRACE_TIMEOUT + 1)  # nothing pending: no timeout
+  end_session(session, hu)
+
+
+def test_car_taking_its_screen_back_during_the_grace_reconnects(identity):
+  hu, session, sent = stalled(identity, "Home")
+  session.check_progress(now=sent + ProjectionSession.ACK_TIMEOUT + 0.05)
+  hu.set_focus(False)
+  pump_until(session, lambda: not session.focused)
+  with pytest.raises(SharedRadioStall, match="took its screen back"):
+    session.check_progress(now=sent + ProjectionSession.ACK_TIMEOUT + 0.5)
+  end_session(session, hu)
+
+
+def test_unfocus_outside_a_grace_is_the_normal_reverse_camera(identity):
+  hu = FakeHeadUnit(identity)
+  session = streaming_session(hu, identity)
+  hu.set_focus(False)
+  pump_until(session, lambda: not session.focused)
+  session.check_progress()
+  end_session(session, hu)
+
+
+def home(interface):
+  return "Huckleberrys House"
+
+
+def test_watch_reports_a_carrier_change_with_the_network_name(tmp_path, monkeypatch):
+  counter = tmp_path / "carrier_changes"
+  counter.write_text("4\n")
+  logged = []
+  watch = SharedRadioWatch(lambda name, **fields: logged.append((name, fields)), interval=0.01, counter=counter, name=home).start()
+  try:
+    time.sleep(0.05)
+    assert watch.recent() is None  # the starting value is not a change
+    counter.write_text("5\n")
+    deadline = time.monotonic() + 2
+    while watch.recent() != "Huckleberrys House":
+      assert time.monotonic() < deadline
+      time.sleep(0.01)
+    assert logged == [("other_wifi_changed", {"interface": "wlan0", "network": "Huckleberrys House"})]
+    assert watch.recent(now=watch.changed_at + supervisor_module.RADIO_CHANGE_WINDOW + 0.1) is None
+  finally:
+    watch.stop()
+
+
+def test_watch_without_the_counter_never_reports(tmp_path):
+  watch = SharedRadioWatch(lambda *a, **k: None, interval=0.01, counter=tmp_path / "missing", name=home).start()
+  try:
+    time.sleep(0.05)
+    assert watch.recent() is None
+  finally:
+    watch.stop()
+
+
+def test_name_lookup_failure_still_counts_the_change(tmp_path):
+  def broken(interface):
+    raise RuntimeError("NetworkManager timed out")
+
+  counter = tmp_path / "carrier_changes"
+  counter.write_text("1")
+  watch = SharedRadioWatch(lambda *a, **k: None, interval=0.01, counter=counter, name=broken).start()
+  try:
+    counter.write_text("2")
+    deadline = time.monotonic() + 2
+    while watch.recent() is None:
+      assert time.monotonic() < deadline
+      time.sleep(0.01)
+    assert watch.recent() == ""
+  finally:
+    watch.stop()
+
+
+def test_notice_text_is_short_and_plain():
+  assert reconnect_notice.shared_radio_text("Huckleberrys House") == "Reconnected: comma Wi-Fi Joined Huckleberrys House"
+  assert reconnect_notice.shared_radio_text("") == "Reconnected: comma Wi-Fi Was Switching Networks"
+  long = reconnect_notice.shared_radio_text("A" * 60)
+  assert long.endswith("...") and len(long) <= len("Reconnected: comma Wi-Fi Joined ") + reconnect_notice.NAME_MAX
+
+
+def test_notice_is_shown_once_and_only_while_fresh(tmp_path):
+  path = tmp_path / "notice.json"
+  reconnect_notice.write("Reconnected", path, now=1000.0)
+  assert reconnect_notice.take(path, now=1010.0) == "Reconnected"
+  assert reconnect_notice.take(path, now=1010.0) == ""  # taken
+  reconnect_notice.write("Reconnected", path, now=1000.0)
+  assert reconnect_notice.take(path, now=1000.0 + reconnect_notice.NOTICE_FRESH_S + 1) == ""
+  assert not path.exists()
+
+
+def test_galaxy_status_says_what_happened():
+  text = Supervisor._describe_error("streaming", SharedRadioStall("stalled", "Huckleberrys House"))
+  assert text == "The car's Wi-Fi stalled while the comma's own Wi-Fi joined Huckleberrys House; reconnecting"
+  assert "switching networks" in Supervisor._describe_error("streaming", SharedRadioStall("stalled", ""))
+  assert stream_loss_kind(text) == "shared_radio"  # bug reports file it apart from ordinary stalls
+  assert stream_loss_kind("projecting: Video acknowledgement older than 2.5 s") == "stalled"
+
+
+
+def test_saved_profile_names_become_the_network_name():
+  from openpilot.starpilot.system.starport.network import profile_network_name
+  assert profile_network_name("openpilot connection Huckleberrys House") == "Huckleberrys House"
+  assert profile_network_name("iPhone") == "iPhone"

From 15b2612d7faacd6bb145bb28406aedf3cf74e680 Mon Sep 17 00:00:00 2001
From: Danny <dannyirwin31@yahoo.com>
Date: Mon, 2 Nov 2026 16:52:21 -0800
Subject: [PATCH 28/38] Hold RFComm for a moment, Better Traces.

---
 .../system/starport/bugsink_report.py         | 26 +++---
 openpilot/starpilot/system/starport/sdp.py    |  6 +-
 .../starpilot/system/starport/supervisor.py   | 42 ++++++++-
 .../starport/tests/test_bugsink_report.py     | 12 +++
 .../system/starport/tests/test_stray_link.py  | 87 +++++++++++++++++++
 5 files changed, 157 insertions(+), 16 deletions(-)

diff --git a/openpilot/starpilot/system/starport/bugsink_report.py b/openpilot/starpilot/system/starport/bugsink_report.py
index c174225fc5..81bf6a89f1 100644
--- a/openpilot/starpilot/system/starport/bugsink_report.py
+++ b/openpilot/starpilot/system/starport/bugsink_report.py
@@ -27,8 +27,8 @@ MAX_FAILURES = 5           # distinct failures detailed per drive report
 MAX_BREADCRUMBS = 100
 TRACE_QUIET = frozenset({"nav_guidance_sent", "nav_focus", "nav_focus_requested", "nav_status_state", "media_key", "media_audio_state",
                          "media_audio_focus", "media_status_state", "hfp_command", "video_focus"})
-TRACE_SESSION_BYTES = 40 << 10   # per failed session; the oldest events go first
-TRACE_TOTAL_BYTES = 160 << 10    # all traces in one report, well under the sender's event cap
+TRACE_SESSION_BYTES = 64 << 10   # per failed session; the middle goes first
+TRACE_TOTAL_BYTES = 200 << 10    # all traces in one report, well under the sender's event cap
 EVENT_BUDGET = 400 << 10         # a report is shed down to this before sending; the sender refuses more than 512 KB
 MAX_ATTENTION = 6                # sessions per report that get a trace and a device slice
 SERIES_KEYS = ("fps", "encode_ms", "frame_age_p95_ms", "wifi_dbm", "wifi_link", "wifi_noise", "load1", "mem_available_mb",
@@ -151,15 +151,19 @@ def quiet_counts(events: list[dict]) -> dict:
 
 
 def bounded_trace(trace: list[dict], limit: int) -> dict:
-  """The newest events that fit in ``limit`` bytes of JSON, with how many older ones were left out."""
-  kept, size = [], 0
-  for event in reversed(trace):
-    size += len(json.dumps(event, default=str)) + 2
-    if size > limit:
-      break
-    kept.append(event)
-  kept.reverse()
-  return {"events": kept, "omitted": len(trace) - len(kept)}
+  """The first quarter and the newest events that fit in ``limit`` bytes of JSON, with how many in between were left out."""
+  sizes = [len(json.dumps(event, default=str)) + 2 for event in trace]
+  if sum(sizes) <= limit:
+    return {"events": list(trace), "omitted": 0}
+  head_end, used = 0, 0
+  while head_end < len(trace) and used + sizes[head_end] <= limit // 4:
+    used += sizes[head_end]
+    head_end += 1
+  tail_start = len(trace)
+  while tail_start > head_end and used + sizes[tail_start - 1] <= limit:
+    tail_start -= 1
+    used += sizes[tail_start]
+  return {"events": trace[:head_end] + trace[tail_start:], "omitted": tail_start - head_end, "head": head_end}
 
 
 MAX_OFFERED_MODES = 16
diff --git a/openpilot/starpilot/system/starport/sdp.py b/openpilot/starpilot/system/starport/sdp.py
index 7fcbc79150..85a2d66807 100644
--- a/openpilot/starpilot/system/starport/sdp.py
+++ b/openpilot/starpilot/system/starport/sdp.py
@@ -30,7 +30,9 @@ ERRORS = {1: "invalid SDP version", 2: "invalid service record handle", 3: "inva
 
 
 class SdpError(RuntimeError):
-  pass
+  def __init__(self, message: str, raw: bytes = b""):
+    super().__init__(message)
+    self.raw = raw   # what the car sent, for the log when the record is not usable
 
 
 def build_request(continuation: bytes, service: uuid.UUID = AA_WIRELESS_UUID, transaction_id: int = 0) -> bytes:
@@ -107,5 +109,5 @@ def query_channel(sock, timeout: float = 10.0) -> int:
     raise SdpError("Head unit does not advertise Android Auto Wireless (SDP record missing)")
   channel = rfcomm_channel(bytes(collected))
   if channel is None:
-    raise SdpError("Android Auto Wireless SDP record has no RFCOMM channel")
+    raise SdpError("Android Auto Wireless SDP record has no RFCOMM channel", bytes(collected))
   return channel
diff --git a/openpilot/starpilot/system/starport/supervisor.py b/openpilot/starpilot/system/starport/supervisor.py
index 37376dd798..8db49b4e27 100644
--- a/openpilot/starpilot/system/starport/supervisor.py
+++ b/openpilot/starpilot/system/starport/supervisor.py
@@ -61,6 +61,8 @@ ENCODER_RECOVERIES = 3       # hardware encoder reopens allowed per window befor
 ENCODER_RECOVERY_WINDOW = 10.0
 CAR_LINK_HOLD = 10.0         # a hands-free connection from the car counts as "car present" this long
 HFP_FRESH = 3.0              # a hands-free link from the car this recent still means "the car is reaching out now"
+COMMA_PAGE_WINDOW = 6.0         # a hands-free link this soon after we paged the car is ours; later is the car's
+RFCOMM_BUSY_WAITS = (1.0, 2.0)   # the kernel can still hold the last session's channel for a moment
 CAR_FIRST_WAIT = 8.0         # at ignition, give the car this long to open hands-free before the comma pages it
 NO_STARPORT_WAIT = 8.0    # a paired device must offer wireless projection within this long
 USB_HANDSHAKE_WAIT = 10.0    # the car connected but sent no AOA START this long -> present as an accessory directly
@@ -429,6 +431,8 @@ class Supervisor:
     self._pairing_attempt: PairingAttempt | None = None
     self._pairing_seen: tuple = ()
     self._car_seen_at = -CAR_LINK_HOLD
+    self._paged_at = -COMMA_PAGE_WINDOW   # when this comma last asked BlueZ to connect to the car
+    self._attempt_ended_at: float | None = None
     self._hfp_link = threading.Event()  # set when the chosen car opens the hands-free link
     self._modern_reply: dict[str, bool] = {}  # car address -> answer its v4+ version request like a current phone
     self._ladder = setup_ladder.SetupLadder(identity_store.CONFIG_PATH.with_name("setup_state.json"))   # which handshake to try for each car, and which one last worked
@@ -1110,7 +1114,10 @@ class Supervisor:
 
   def _hfp_connected(self, address: str) -> None:
     if address.upper() in (self.config["receiver_address"].upper(), self.config.get("companion_address", "").upper()):
-      self._car_seen_at = time.monotonic()
+      now = time.monotonic()
+      since_page = now - self._paged_at
+      self.log("hfp_initiator", initiator="comma" if since_page < COMMA_PAGE_WINDOW else "car", since_page_s=round(since_page, 1))
+      self._car_seen_at = now
       self._hfp_link.set()
 
   def _release_phone(self) -> None:
@@ -1327,6 +1334,7 @@ class Supervisor:
             car_first = True  # the car pages right back once its link drops; let it, rather than crossing it again
         finally:
           self._close_sockets()
+          self._attempt_ended_at = time.monotonic()
           try:
             lease.release(restore=False)
           except Exception as error:
@@ -1402,6 +1410,7 @@ class Supervisor:
     if delay := car_profiles.tuning(config)["connect_delay_s"]:
       self.log("car_profile_connect_delay", seconds=delay)
       self._wait(delay)
+    self._paged_at = time.monotonic()
     bluez.connect_device(address)
     self._wait(1.0)
 
@@ -1426,7 +1435,7 @@ class Supervisor:
              channel_type=strategy.channel_type, patience=strategy.patience, experiments=strategy.experiments)
     try:
       self._stage("rfcomm", f"channel {channel}")
-      rfcomm = self._track(bt_sockets.connect_rfcomm(address, channel))
+      rfcomm = self._connect_rfcomm(address, channel)
       boot = WirelessBootstrap(rfcomm, self._bootstrap_log, device_serial=config["device_name"],
                                version_status=int(config.get("version_status", 0)),
                                experiment="all" if car_profiles.tuning(config)["bootstrap_experiments"] or strategy.experiments else "",
@@ -1465,6 +1474,33 @@ class Supervisor:
     finally:
       keepalive_stop.set()
 
+  def _connect_rfcomm(self, address: str, channel: int):
+    from openpilot.starpilot.system.starport import bt_sockets
+    ended = self._attempt_ended_at
+    since_end = round(time.monotonic() - ended, 1) if ended is not None else None
+    waited = 0.0
+    for tries, delay in enumerate(RFCOMM_BUSY_WAITS, 1):
+      try:
+        sock = self._track(bt_sockets.connect_rfcomm(address, channel))
+      except OSError as error:
+        if error.errno != errno.EBUSY:
+          raise
+        self.log("rfcomm_busy_retry", channel=channel, wait_s=delay, since_last_attempt_s=since_end)
+        self._wait(delay)
+        waited += delay
+        continue
+      if tries > 1:
+        self.log("rfcomm_busy_cleared", channel=channel, tries=tries, waited_s=waited, since_last_attempt_s=since_end)
+      return sock
+    try:
+      sock = self._track(bt_sockets.connect_rfcomm(address, channel))
+    except OSError as error:
+      if error.errno == errno.EBUSY:
+        self.log("rfcomm_busy_gave_up", channel=channel, waited_s=waited, since_last_attempt_s=since_end)
+      raise
+    self.log("rfcomm_busy_cleared", channel=channel, tries=len(RFCOMM_BUSY_WAITS) + 1, waited_s=waited, since_last_attempt_s=since_end)
+    return sock
+
   def _discover_channel(self, address: str) -> int:
     from openpilot.starpilot.system.starport import bt_sockets, sdp
     last_error: Exception | None = None
@@ -1478,7 +1514,7 @@ class Supervisor:
         if _stray_link(error):
           raise StrayLinkError(f"Bluetooth link to the car is stuck: {error}") from error  # retrying cannot clear it
         last_error = error
-        self.log("sdp_retry", error=str(error), settle=settle)
+        self.log("sdp_retry", error=str(error), settle=settle, **({"record_hex": error.raw.hex()[:400]} if getattr(error, "raw", b"") else {}))
         self._wait(0.35)
     raise RuntimeError(f"Could not find the car's Android Auto service: {last_error}")
 
diff --git a/openpilot/starpilot/system/starport/tests/test_bugsink_report.py b/openpilot/starpilot/system/starport/tests/test_bugsink_report.py
index 396776b379..dd41ff85eb 100644
--- a/openpilot/starpilot/system/starport/tests/test_bugsink_report.py
+++ b/openpilot/starpilot/system/starport/tests/test_bugsink_report.py
@@ -515,3 +515,15 @@ def test_report_says_how_the_rfcomm_channel_was_found(tmp_path):
   events.insert(2, (0, 2, "rfcomm_channel", {"channel": 8, "source": "sdp"}))
   assert br.session_record(write_session(tmp_path, 1, events))["sdp"] == {"channel": 8, "source": "sdp", "retries": 1}
   assert br.session_record(write_session(tmp_path, 2, STREAMED))["sdp"] == {}
+
+
+def test_trace_keeps_how_the_session_started_as_well_as_how_it_ended(tmp_path):
+  noisy = [(0, 0, "session_start", {}), (0, 1, "hfp_initiator", {"initiator": "car"})]
+  noisy += [(i // 60, i % 60, "sdp_retry", {"error": "x" * 250, "n": i}) for i in range(2, 400)]
+  noisy.append((9, 0, "attempt_failed", {"stage": "discovering", "error": "gone", "kind": "RuntimeError"}))
+  event = br.drive_event([br.session_record(write_session(tmp_path, 1, noisy))])
+  trace = event["contexts"]["starport_trace_session_1"]
+  names = [e["event"] for e in trace["events"]]
+  assert names[:2] == ["session_start", "hfp_initiator"] and names[-2:] == ["attempt_failed", "session_stop"]
+  assert trace["omitted"] > 0 and 0 < trace["head"] < len(names)
+  assert len(json.dumps(trace)) <= br.TRACE_SESSION_BYTES + 1024
diff --git a/openpilot/starpilot/system/starport/tests/test_stray_link.py b/openpilot/starpilot/system/starport/tests/test_stray_link.py
index 462ff78ac3..5ddd77e52d 100644
--- a/openpilot/starpilot/system/starport/tests/test_stray_link.py
+++ b/openpilot/starpilot/system/starport/tests/test_stray_link.py
@@ -179,3 +179,90 @@ def test_disconnect_stray_link_without_a_handle_only_logs(monkeypatch):
   phone, commands, events = _phone_with(monkeypatch, {"journalctl": ("", 0)})
   assert phone.disconnect_stray_link() is None
   assert len(commands) == 1 and events == ["stray_link_not_found"]
+
+
+def _rfcomm_attempts(sup, monkeypatch, outcomes):
+  from openpilot.starpilot.system.starport import bt_sockets
+  calls = []
+
+  def connect(*args, **kwargs):
+    calls.append(args)
+    outcome = outcomes[min(len(calls), len(outcomes)) - 1]
+    if isinstance(outcome, int):
+      raise OSError(outcome, "boom")
+    return outcome
+
+  monkeypatch.setattr(bt_sockets, "connect_rfcomm", connect)
+  return calls
+
+
+def test_busy_rfcomm_channel_is_retried_in_the_same_attempt(identity, tmp_path, monkeypatch):
+  sup, _ = make_supervisor(identity, tmp_path, monkeypatch, lambda *a, **k: socket.socketpair()[0])
+  _virtual_time(sup, monkeypatch)
+  good = socket.socketpair()[0]
+  calls = _rfcomm_attempts(sup, monkeypatch, [errno.EBUSY, good])
+  assert sup._connect_rfcomm(CAR, 6) is good
+  assert len(calls) == 2 and len(_events(sup, "rfcomm_busy_retry")) == 1
+
+
+def test_busy_rfcomm_channel_gives_up_after_the_waits(identity, tmp_path, monkeypatch):
+  from openpilot.starpilot.system.starport import supervisor
+  sup, _ = make_supervisor(identity, tmp_path, monkeypatch, lambda *a, **k: socket.socketpair()[0])
+  _virtual_time(sup, monkeypatch)
+  calls = _rfcomm_attempts(sup, monkeypatch, [errno.EBUSY])
+  with pytest.raises(OSError) as raised:
+    sup._connect_rfcomm(CAR, 6)
+  assert raised.value.errno == errno.EBUSY and len(calls) == len(supervisor.RFCOMM_BUSY_WAITS) + 1
+
+
+def test_other_rfcomm_errors_are_not_retried(identity, tmp_path, monkeypatch):
+  sup, _ = make_supervisor(identity, tmp_path, monkeypatch, lambda *a, **k: socket.socketpair()[0])
+  _virtual_time(sup, monkeypatch)
+  calls = _rfcomm_attempts(sup, monkeypatch, [errno.ECONNRESET])
+  with pytest.raises(OSError):
+    sup._connect_rfcomm(CAR, 6)
+  assert len(calls) == 1 and not _events(sup, "rfcomm_busy_retry")
+
+
+def test_a_retried_busy_channel_logs_how_it_ended(identity, tmp_path, monkeypatch):
+  sup, _ = make_supervisor(identity, tmp_path, monkeypatch, lambda *a, **k: socket.socketpair()[0])
+  now = _virtual_time(sup, monkeypatch)
+  sup._attempt_ended_at = now[0] - 4.0
+  _rfcomm_attempts(sup, monkeypatch, [errno.EBUSY, errno.EBUSY, socket.socketpair()[0]])
+  sup._connect_rfcomm(CAR, 6)
+  assert _events(sup, "rfcomm_busy_cleared")[0]["tries"] == 3
+  assert _events(sup, "rfcomm_busy_retry")[0]["since_last_attempt_s"] == 4.0
+
+
+def test_a_channel_that_stays_busy_logs_that_it_gave_up(identity, tmp_path, monkeypatch):
+  sup, _ = make_supervisor(identity, tmp_path, monkeypatch, lambda *a, **k: socket.socketpair()[0])
+  _virtual_time(sup, monkeypatch)
+  _rfcomm_attempts(sup, monkeypatch, [errno.EBUSY])
+  with pytest.raises(OSError):
+    sup._connect_rfcomm(CAR, 6)
+  assert _events(sup, "rfcomm_busy_gave_up")[0]["waited_s"] == 3.0
+
+
+def test_hands_free_logs_who_started_the_link(identity, tmp_path, monkeypatch):
+  sup, _ = make_supervisor(identity, tmp_path, monkeypatch, lambda *a, **k: socket.socketpair()[0])
+  now = _virtual_time(sup, monkeypatch)
+  sup._paged_at = now[0] - 1.0
+  sup._hfp_connected(CAR)
+  sup._paged_at = now[0] - 60.0
+  sup._hfp_connected(CAR)
+  assert [e["initiator"] for e in _events(sup, "hfp_initiator")] == ["comma", "car"]
+
+
+def test_unusable_sdp_record_is_logged_with_what_the_car_sent(identity, tmp_path, monkeypatch):
+  from openpilot.starpilot.system.starport import bt_sockets, sdp
+  sup, _ = make_supervisor(identity, tmp_path, monkeypatch, lambda *a, **k: socket.socketpair()[0])
+  _virtual_time(sup, monkeypatch)
+  monkeypatch.setattr(bt_sockets, "connect_l2cap", lambda *a, **k: socket.socketpair()[0])
+
+  def query(_):
+    raise sdp.SdpError("Android Auto Wireless SDP record has no RFCOMM channel", b"\x35\x03\x19\x11\x1f")
+
+  monkeypatch.setattr(sdp, "query_channel", query)
+  with pytest.raises(RuntimeError):
+    sup._discover_channel(CAR)
+  assert _events(sup, "sdp_retry")[0]["record_hex"] == "350319111f"

From fb9b3516b110200de5782c10a24821fd0fd200e6 Mon Sep 17 00:00:00 2001
From: Danny <dannyirwin31@yahoo.com>
Date: Mon, 2 Nov 2026 17:24:14 -0800
Subject: [PATCH 29/38] Allow Disconnect from Galaxy for Starport Projecting
 Car

---
 .../starpilot/system/starport/auto_connect.py |  3 ++
 .../starpilot/system/starport/supervisor.py   | 44 ++++++++++++++++++-
 .../starport/tests/test_auto_connect.py       |  7 +++
 3 files changed, 52 insertions(+), 2 deletions(-)

diff --git a/openpilot/starpilot/system/starport/auto_connect.py b/openpilot/starpilot/system/starport/auto_connect.py
index ca6598896e..35bdc3ee30 100644
--- a/openpilot/starpilot/system/starport/auto_connect.py
+++ b/openpilot/starpilot/system/starport/auto_connect.py
@@ -36,6 +36,9 @@ class AutoConnectPolicy:
     if running:
       self.suppressed = True
 
+  def hold(self) -> None:
+    self.suppressed = True
+
   def start_refused(self, now: float) -> None:
     self._not_before = now + START_REFUSED_WAIT
 
diff --git a/openpilot/starpilot/system/starport/supervisor.py b/openpilot/starpilot/system/starport/supervisor.py
index 8db49b4e27..bad64b1df4 100644
--- a/openpilot/starpilot/system/starport/supervisor.py
+++ b/openpilot/starpilot/system/starport/supervisor.py
@@ -1064,6 +1064,8 @@ class Supervisor:
       return None
     if operation == 'forget' and self.config['receiver_address'].upper() == address.upper():
       return self._forget_selected_car(owner, address, session)
+    if operation == 'disconnect' and self.config['receiver_address'].upper() == address.upper():
+      return self._disconnect_selected_car(owner, address, session)
     # select_receiver takes the supervisor lock before releasing an owner lease.
     # Keep that same order through connection, save and admission pruning so an
     # old adapter's successful action cannot save its car under a new adapter.
@@ -1096,6 +1098,26 @@ class Supervisor:
         identity_store.save_config(self.config)
       return result
 
+  def _disconnect_selected_car(self, owner, address: str, session: tuple):
+    """Disconnect the chosen car and keep auto-connect from reconnecting it until the next drive or a manual Start."""
+    from openpilot.starpilot.bluetooth.owner import BluetoothRejected
+    lease = owner.phone_lease
+    if not owner.session_valid(session):
+      raise BluetoothRejected('Galaxy session expired', code='session_expired')
+    if lease is not None and not lease.released and lease.session is not None:
+      raise BluetoothRejected('Finish Android Auto pairing first', code='busy')
+    self.auto.hold()
+    self.stop()
+    if self._session_alive():
+      raise BluetoothRejected('Android Auto is still stopping', code='busy')
+    lease = owner.phone_lease
+    if lease is None or lease.released:
+      return None
+    device = lease.phone.device(address)
+    if device is not None and device['connected']:
+      lease.phone._call(device['path'], 'org.bluez.Device1', 'Disconnect', timeout=12.0)
+    return owner.snapshot(session=session)
+
   def _forget_selected_car(self, owner, address: str, session: tuple):
     """Forget the chosen car even while auto-connect is retrying it: stop the attempt, then delete the pairing."""
     from openpilot.starpilot.bluetooth.owner import BluetoothRejected
@@ -1108,10 +1130,28 @@ class Supervisor:
     self.stop()
     if self._session_alive():
       raise BluetoothRejected('Android Auto is still stopping', code='busy')
-    result = owner.request('forget', address=address)
-    self.forget_receiver(address)
+    try:
+      result = owner.request('forget', address=address)
+    except Exception as error:
+      self.log("forget_car_error", error=repr(error)[:300])
+      result = self._forgotten_snapshot(owner, address, session, error)
+    try:
+      self.forget_receiver(address)
+    except Exception as error:
+      self.log("forget_receiver_error", error=repr(error)[:300])
     return result
 
+  def _forgotten_snapshot(self, owner, address: str, session: tuple, error: Exception):
+    """The pairing may already be gone when a later step fails: report success then, else re-raise."""
+    from openpilot.starpilot.bluetooth.owner import BluetoothRejected
+    try:
+      owner._client()._device_path(address)
+    except BluetoothRejected:
+      return owner.snapshot(session=session)
+    except Exception:
+      pass
+    raise error
+
   def _hfp_connected(self, address: str) -> None:
     if address.upper() in (self.config["receiver_address"].upper(), self.config.get("companion_address", "").upper()):
       now = time.monotonic()
diff --git a/openpilot/starpilot/system/starport/tests/test_auto_connect.py b/openpilot/starpilot/system/starport/tests/test_auto_connect.py
index 1cdb884ff5..d86663f50c 100644
--- a/openpilot/starpilot/system/starport/tests/test_auto_connect.py
+++ b/openpilot/starpilot/system/starport/tests/test_auto_connect.py
@@ -51,6 +51,13 @@ def test_policy_leaves_sessions_that_never_saw_the_car():
     assert decide(policy, now, running=True) is None
 
 
+def test_policy_hold_blocks_start_while_idle_until_next_drive():
+  policy = AutoConnectPolicy()
+  policy.hold()
+  assert decide(policy, 0, car_link=True) is None
+  assert decide(policy, 1, onroad=True, car_link=True) == "start"
+
+
 def test_policy_manual_stop_holds_until_next_drive():
   policy = AutoConnectPolicy()
   assert decide(policy, 0, onroad=True) == "start"

From 5be95f48df4dbe8d2e4067b765be0cb42d19ca6d Mon Sep 17 00:00:00 2001
From: Danny <dannyirwin31@yahoo.com>
Date: Mon, 2 Nov 2026 17:33:41 -0800
Subject: [PATCH 30/38] AAwireless: Stop tearing the Session down every 60s

---
 .../starpilot/system/starport/auto_connect.py      |  4 ++--
 .../starpilot/system/starport/car_profiles.py      |  4 ++--
 openpilot/starpilot/system/starport/supervisor.py  |  3 ++-
 .../system/starport/tests/test_auto_connect.py     | 14 ++++++++++++--
 4 files changed, 18 insertions(+), 7 deletions(-)

diff --git a/openpilot/starpilot/system/starport/auto_connect.py b/openpilot/starpilot/system/starport/auto_connect.py
index 35bdc3ee30..51355b52d8 100644
--- a/openpilot/starpilot/system/starport/auto_connect.py
+++ b/openpilot/starpilot/system/starport/auto_connect.py
@@ -42,12 +42,12 @@ class AutoConnectPolicy:
   def start_refused(self, now: float) -> None:
     self._not_before = now + START_REFUSED_WAIT
 
-  def decide(self, now: float, *, enabled: bool, onroad: bool, car_link: bool, ready: bool, running: bool) -> str | None:
+  def decide(self, now: float, *, enabled: bool, onroad: bool, car_link: bool, ready: bool, running: bool, linked: bool = False) -> str | None:
     """Return "start", "stop" or None."""
     if onroad and not self._was_onroad:
       self.suppressed = False  # a new drive
     self._was_onroad = onroad
-    present = onroad or car_link
+    present = onroad or car_link or (running and linked)
 
     if running:
       if present:
diff --git a/openpilot/starpilot/system/starport/car_profiles.py b/openpilot/starpilot/system/starport/car_profiles.py
index faeda26273..f04b7b4a9d 100644
--- a/openpilot/starpilot/system/starport/car_profiles.py
+++ b/openpilot/starpilot/system/starport/car_profiles.py
@@ -2,13 +2,13 @@
 import re
 
 DEFAULTS = {"connect_delay_s": 0.0, "max_window": 2, "phone_services": False, "phone_frames": False,
-            "bootstrap_experiments": False}
+            "bootstrap_experiments": False, "stay_while_projecting": False}
 
 FINGERPRINT_KEYS = ("head_unit_make", "head_unit_model", "car_make", "car_model", "car_year")
 
 RULES: list[dict] = [
   {"id": "aawireless", "label": "AAWireless", "match": {},
-   "tuning": {"max_window": 30, "phone_services": True, "phone_frames": True}},
+   "tuning": {"max_window": 30, "phone_services": True, "phone_frames": True, "stay_while_projecting": True}},
   {"id": "unofficial", "label": "Unofficial dongle", "match": {}, "tuning": {"bootstrap_experiments": True}},
 ]
 
diff --git a/openpilot/starpilot/system/starport/supervisor.py b/openpilot/starpilot/system/starport/supervisor.py
index bad64b1df4..82ff4dd80b 100644
--- a/openpilot/starpilot/system/starport/supervisor.py
+++ b/openpilot/starpilot/system/starport/supervisor.py
@@ -930,7 +930,8 @@ class Supervisor:
         self._set(error=f'Waiting for selected car: {error}'[:300])
     car_link = bool(car_device and car_device["connected"]) or now - self._car_seen_at < CAR_LINK_HOLD
     onroad = self._onroad()
-    action = self.auto.decide(now, enabled=True, onroad=onroad, car_link=car_link,
+    linked = car_profiles.tuning(self.config)["stay_while_projecting"] and self._status.get("state") in ("streaming", "suspended")
+    action = self.auto.decide(now, enabled=True, onroad=onroad, car_link=car_link, linked=linked,
                               ready=adapter_ready and bool(device and device["paired"]) and (not companion or car_link), running=running)
     self._apply_auto_action(now, action, onroad)
 
diff --git a/openpilot/starpilot/system/starport/tests/test_auto_connect.py b/openpilot/starpilot/system/starport/tests/test_auto_connect.py
index d86663f50c..73b88f451b 100644
--- a/openpilot/starpilot/system/starport/tests/test_auto_connect.py
+++ b/openpilot/starpilot/system/starport/tests/test_auto_connect.py
@@ -19,8 +19,8 @@ def identity(tmp_path_factory):
   return make_identity(tmp_path_factory.mktemp("identity"))
 
 
-def decide(policy, now, onroad=False, car_link=False, ready=True, running=False, enabled=True):
-  return policy.decide(now, enabled=enabled, onroad=onroad, car_link=car_link, ready=ready, running=running)
+def decide(policy, now, onroad=False, car_link=False, ready=True, running=False, enabled=True, linked=False):
+  return policy.decide(now, enabled=enabled, onroad=onroad, car_link=car_link, ready=ready, running=running, linked=linked)
 
 
 # -------------------------------------------------------------------- policy
@@ -45,6 +45,16 @@ def test_policy_stops_after_car_gone():
   assert decide(policy, 100) is None                             # stopped, car still gone: no restart
 
 
+def test_policy_keeps_a_projecting_session_when_the_car_link_drops():
+  policy = AutoConnectPolicy()
+  assert decide(policy, 0, car_link=True) == "start"
+  assert decide(policy, 1, car_link=True, running=True) is None
+  for now in range(2, 400, 10):
+    assert decide(policy, now, running=True, linked=True) is None
+  assert decide(policy, 400, running=True) is None                # stream ended: grace period starts
+  assert decide(policy, 400 + auto_connect.STOP_AFTER, running=True) == "stop"
+
+
 def test_policy_leaves_sessions_that_never_saw_the_car():
   policy = AutoConnectPolicy()
   for now in range(0, 300, 10):

From cfdcd14ca8ef6b03b6a9259891ec8b2fb1ebb156 Mon Sep 17 00:00:00 2001
From: Danny <dannyirwin31@yahoo.com>
Date: Mon, 2 Nov 2026 17:39:00 -0800
Subject: [PATCH 31/38] Show car vs app in pairing

---
 openpilot/starpilot/galaxy/web/js/starport.js | 23 ++++++++++---------
 1 file changed, 12 insertions(+), 11 deletions(-)

diff --git a/openpilot/starpilot/galaxy/web/js/starport.js b/openpilot/starpilot/galaxy/web/js/starport.js
index 956573e2af..0afbac9db6 100644
--- a/openpilot/starpilot/galaxy/web/js/starport.js
+++ b/openpilot/starpilot/galaxy/web/js/starport.js
@@ -108,8 +108,8 @@ const PAIR_UI = `
               </li>
             </ul>
             <p v-else-if="!pairing?.active && selected" class="gx-starport-row"><i class="bi bi-car-front" aria-hidden="true"></i><span class="gx-starport-row__text"><strong>{{ selected.name }}</strong><small>Used for Android Auto</small></span></p>
-            <p v-if="!pairing?.active && endReason === 'canceled'" class="gx-note" role="status">Pairing canceled. Start again when your car is ready.</p>
-            <p v-else-if="!pairing?.active && endReason" class="gx-note" role="status">The pairing window ended without choosing a car. Try again when your car’s pairing screen is open.</p>
+            <p v-if="!pairing?.active && endReason === 'canceled'" class="gx-note" role="status">Pairing canceled. Start again when your {{ deviceWord }} is ready.</p>
+            <p v-else-if="!pairing?.active && endReason" class="gx-note" role="status">The pairing window ended without choosing a {{ deviceWord }}. Try again when your {{ adapterSetup ? 'adapter is in pairing mode' : 'car’s pairing screen is open' }}.</p>
             <ol v-if="showPairSteps" class="gx-starport-list" aria-label="Pairing progress">
               <li v-for="step in pairSteps" :key="step.label" class="gx-starport-row" :class="'gx-starport-row--' + step.status" :aria-current="step.status === 'active' ? 'step' : undefined">
                 <i v-if="step.status === 'done'" class="bi bi-check-circle-fill gx-starport-ok" aria-hidden="true"></i>
@@ -118,14 +118,14 @@ const PAIR_UI = `
                 <span class="gx-starport-row__text"><strong>{{ step.label }}</strong></span>
               </li>
             </ol>
-            <p v-if="waitingForCar" role="status">{{ pairing.discovering ? "Searching for nearby cars and adapters…" : "Choose your car or wireless adapter below." }}</p>
+            <p v-if="waitingForCar" role="status">{{ pairing.discovering ? "Searching for your " + deviceWord + "…" : "Choose your " + deviceWord + " below." }}</p>
             <p v-else-if="pairing?.active && pairing.approved && (!pairing.state || pairing.state === 'idle')" role="status">Approved {{ pairing.receiver?.name }}. Finishing Bluetooth pairing…</p>
             <p v-if="pairing?.state === 'pairing' && !pairing.prompt && !pairing.approved" role="status">Pairing with {{ pairing.receiver?.name || 'the selected device' }}…</p>
             <p v-if="pairing?.state === 'connecting'" role="status">Connecting to {{ pairing.receiver?.name || 'the selected device' }}…</p>
             <p v-if="['paired', 'connected'].includes(pairing?.state)" role="status"><i class="bi bi-check-circle-fill gx-starport-ok"></i> {{ pairing.receiver?.name || 'Device' }} {{ pairing.state === 'connected' ? 'connected' : 'paired' }}.</p>
             <GxNotice tone="danger" v-if="pairing?.error">{{ pairing.error }}</GxNotice>
             <ul v-if="pairing?.active && !deviceChosen" class="gx-starport-list" aria-label="Nearby devices">
-              <li v-if="!pairing.devices?.length && waitingForCar" class="gx-starport-row gx-note" role="status"><span class="gx-spinner" aria-hidden="true"></span>Nothing found yet. Keep your car’s pairing screen open.</li>
+              <li v-if="!pairing.devices?.length && waitingForCar" class="gx-starport-row gx-note" role="status"><span class="gx-spinner" aria-hidden="true"></span>Nothing found yet. {{ adapterSetup ? 'Keep your adapter in pairing mode.' : 'Keep your car’s pairing screen open.' }}</li>
               <li v-for="device in pairing.devices || []" :key="device.address" class="gx-starport-row">
                 <i :class="device.starport ? 'bi bi-car-front' : 'bi bi-bluetooth'" aria-hidden="true"></i>
                 <span class="gx-starport-row__text"><strong>{{ device.name }}</strong><small>{{ device.starport ? 'StarPort ready' : 'Bluetooth device' }} · {{ device.connected ? 'Connected' : device.paired ? 'Paired before' : 'Nearby' }}</small></span>
@@ -133,13 +133,13 @@ const PAIR_UI = `
               </li>
             </ul>
             <div v-if="pairing?.prompt" ref="pairPrompt" class="gx-starport-prompt" role="status"><strong>{{ pairing.receiver.name }}</strong>
-              <p>{{ pairing.prompt.kind === 'confirmation' ? 'Check that this code matches your car, then confirm.' :
-                pairing.prompt.kind === 'pin' ? 'Enter the PIN shown by your car.' :
-                pairing.prompt.kind === 'passkey' ? 'Enter your car’s passkey.' :
-                pairing.prompt.kind === 'authorization' ? 'Allow this car to pair?' : 'Enter this code in your car.' }}</p>
+              <p>{{ pairing.prompt.kind === 'confirmation' ? 'Check that this code matches your ' + deviceWord + ', then confirm.' :
+                pairing.prompt.kind === 'pin' ? 'Enter the PIN shown by your ' + deviceWord + '.' :
+                pairing.prompt.kind === 'passkey' ? 'Enter your ' + deviceWord + '’s passkey.' :
+                pairing.prompt.kind === 'authorization' ? 'Allow this ' + deviceWord + ' to pair?' : 'Enter this code in your ' + deviceWord + '.' }}</p>
               <strong v-if="pairing.prompt.value" class="gx-starport-prompt__code">{{ pairing.prompt.value }}</strong>
               <input v-if="['pin','passkey'].includes(pairing.prompt.kind)" class="gx-field" type="text" maxlength="16" autocomplete="off"
-                :inputmode="pairing.prompt.kind === 'passkey' ? 'numeric' : 'text'" :aria-label="pairing.prompt.kind === 'pin' ? 'Car PIN' : 'Car passkey'" v-model="pairValue" />
+                :inputmode="pairing.prompt.kind === 'passkey' ? 'numeric' : 'text'" :aria-label="pairing.prompt.kind === 'pin' ? (adapterSetup ? 'Adapter' : 'Car') + ' PIN' : (adapterSetup ? 'Adapter' : 'Car') + ' passkey'" v-model="pairValue" />
               <div v-if="!pairing.prompt.displayOnly" class="gx-driving__actions gx-actions">
                 <button class="gx-btn gx-btn--tonal" @click="respond(false)">Reject</button>
                 <button class="gx-btn" :disabled="!canRespond" @click="respond(true)">{{ pairing.prompt.kind === 'pin' ? 'Send PIN' : pairing.prompt.kind === 'passkey' ? 'Send Passkey' : 'Confirm' }}</button></div>
@@ -653,6 +653,7 @@ export const StarPortPage = {
     },
     carType() { return this.runtime?.car_type || (this.wired ? "usb" : this.app ? "app" : "builtin") },
     adapterSetup() { return this.carType === "adapter" },
+    deviceWord() { return this.adapterSetup ? "adapter" : "car" },
     pairsHere() { return this.carType === "builtin" || this.carType === "adapter" },
     findLabel() { return this.adapterSetup ? "adapter" : "car" },
     carTypeLabels() { return { ...CAR_TYPES, app: this.app ? `App (${this.app})` : CAR_TYPES.app } },
@@ -752,9 +753,9 @@ export const StarPortPage = {
       const steps = [
         `Start the search${this.starting ? "…" : ""}`,
         `Put your ${what} in pairing mode, then pick it from the list`,
-        this.pairing?.prompt ? "Confirm the code on both screens" : "Pair with your device",
+        this.pairing?.prompt ? "Confirm the code on both screens" : `Pair with your ${what}`,
         "Finish Bluetooth pairing",
-        "Finish connecting to your device"
+        `Finish connecting to your ${what}`
       ]
       return steps.map((label, index) => ({ label, status: index < rank ? "done" : index === rank ? (failed ? "failed" : "active") : "pending" }))
     },

From 6d99039382d445f220a6ab8a34d9c18da035d5fa Mon Sep 17 00:00:00 2001
From: Danny <dannyirwin31@yahoo.com>
Date: Mon, 2 Nov 2026 18:10:16 -0800
Subject: [PATCH 32/38] Test Fixes

---
 openpilot/starpilot/galaxy/server.py             |  3 ++-
 openpilot/starpilot/galaxy/starport_send.py      |  2 +-
 openpilot/starpilot/galaxy/web/css/galaxy.css    |  2 +-
 .../starpilot/system/starport/bugsink_report.py  | 16 +++++++++-------
 openpilot/starpilot/system/starport/new_setup.py |  2 +-
 openpilot/starpilot/system/starport/session.py   |  8 +++-----
 .../starpilot/system/starport/setup_ladder.py    |  2 +-
 .../starpilot/system/starport/supervisor.py      |  3 +--
 .../system/starport/tests/test_bugsink_report.py | 10 +++++-----
 .../system/starport/tests/test_car_adoption.py   |  3 ++-
 .../starport/tests/test_car_never_answered.py    |  1 +
 .../system/starport/tests/test_reachability.py   |  3 ++-
 .../system/starport/tests/test_setup_ladder.py   | 10 +++++-----
 .../starport/tests/test_shared_radio_grace.py    |  1 +
 14 files changed, 35 insertions(+), 31 deletions(-)

diff --git a/openpilot/starpilot/galaxy/server.py b/openpilot/starpilot/galaxy/server.py
index bb70c8956f..360aca1521 100644
--- a/openpilot/starpilot/galaxy/server.py
+++ b/openpilot/starpilot/galaxy/server.py
@@ -97,7 +97,8 @@ def make_server(*, port=8082, host='127.0.0.1', monitor=None, owner=None, crashe
                 sounds=None, software_operations=None, drive_stats=None, layout_preview_socket=None, controllers_socket=None,
                 remote_pairing=None, parked=None, camera_snapshot=None, clock=time.monotonic, starport_setup=None,
                 starport_client=None, navigation=None, offline_maps=None, drive_state=None, cloud_provider=None, cloud_offroad=None, projection_layout=None,
-                local_access=None, tmux_live=None, starport_logs=None, starport_log_sender=None, hotspot=None, toyota_tools=None, replay_client=None, replay_root=None,
+                local_access=None, tmux_live=None, starport_logs=None, starport_log_sender=None, hotspot=None, toyota_tools=None,
+                replay_client=None, replay_root=None,
                 spotify_setup=None, companion=None, phone_location=None, reverse_proxy=None):
   from openpilot.starpilot.galaxy.companion import CompanionRegistry, APK_PATH
   from openpilot.starpilot.gps.phone import PhoneGpsPublisher
diff --git a/openpilot/starpilot/galaxy/starport_send.py b/openpilot/starpilot/galaxy/starport_send.py
index fc1045dbe4..2be1c6d37d 100644
--- a/openpilot/starpilot/galaxy/starport_send.py
+++ b/openpilot/starpilot/galaxy/starport_send.py
@@ -279,7 +279,7 @@ class StarPortLogSender:
         left_out = " The device snapshot was left out to fit Discord's 10 MB limit."
       self._set(message="Sending logs")
       warning = self._sender(data, name, note, summary)
-      self._set(state="sent", message=f"Logs sent.{left_out} {warning or 'Thanks!'}".strip(), sentAt=int(time.time()))
+      self._set(state="sent", message=f"Logs sent.{left_out} {warning or 'Thanks!'}".strip(), sentAt=int(time.time()))  # noqa: TID251 shown as a wall-clock time
     except SendRejected as error:
       self._set(state="failed", message=str(error)[:400])
     except Exception as error:
diff --git a/openpilot/starpilot/galaxy/web/css/galaxy.css b/openpilot/starpilot/galaxy/web/css/galaxy.css
index 96bc7e570e..63bbb1f223 100644
--- a/openpilot/starpilot/galaxy/web/css/galaxy.css
+++ b/openpilot/starpilot/galaxy/web/css/galaxy.css
@@ -2064,7 +2064,7 @@ progress { max-width: 100%; accent-color: var(--primary); }
 .gx-guided .gx-starport-pill { border: 0; background: var(--g-fill-hover); color: var(--g-muted); font-size: 13px; font-weight: var(--fw-bold); }
 .gx-guided .gx-starport-pill--ready { background: color-mix(in srgb, var(--g-done) 20%, transparent); color: var(--g-done); }
 
-/* Connection options: a radio row with a coloured icon tile, as in iOS Settings. */
+/* Connection options: a radio row with a colored icon tile, as in iOS Settings. */
 .gx-guided__options { --g-inset: 70px; }
 .gx-guided__options > li { display: block; }
 .gx-guided__option {
diff --git a/openpilot/starpilot/system/starport/bugsink_report.py b/openpilot/starpilot/system/starport/bugsink_report.py
index 81bf6a89f1..887faf3e51 100644
--- a/openpilot/starpilot/system/starport/bugsink_report.py
+++ b/openpilot/starpilot/system/starport/bugsink_report.py
@@ -170,6 +170,11 @@ MAX_OFFERED_MODES = 16
 SETUP_TYPES = ("builtin", "adapter", "usb", "app")
 
 
+def _config_field(config: dict, number: int, default=None):
+  values = config.get(str(number), config.get(number))
+  return values[0] if isinstance(values, list) and values and isinstance(values[0], int) else default
+
+
 def offered_modes(events: list[dict]) -> list[str]:
   """Every video mode the head unit offered, e.g. "1280x720 H.264 margins 0x240", from its service discovery.
 
@@ -182,14 +187,11 @@ def offered_modes(events: list[dict]) -> list[str]:
       if not isinstance(config, dict):
         continue
 
-      def field(number, default=None):
-        values = config.get(str(number), config.get(number))
-        return values[0] if isinstance(values, list) and values and isinstance(values[0], int) else default
-
-      resolution, codec = field(1), field(10, CODEC_H264_BP)
+      resolution, codec = _config_field(config, 1), _config_field(config, 10, CODEC_H264_BP)
       text = f"{RESOLUTION_NAMES.get(resolution, f'resolution {resolution}')} {CODEC_NAMES.get(codec, f'codec {codec}')}"
-      if field(3, 0) or field(4, 0):
-        text += f" margins {field(3, 0)}x{field(4, 0)}"
+      margins = _config_field(config, 3, 0), _config_field(config, 4, 0)
+      if any(margins):
+        text += f" margins {margins[0]}x{margins[1]}"
       modes.append(text)
   return modes[:MAX_OFFERED_MODES]
 
diff --git a/openpilot/starpilot/system/starport/new_setup.py b/openpilot/starpilot/system/starport/new_setup.py
index 1123928930..49708eecb1 100644
--- a/openpilot/starpilot/system/starport/new_setup.py
+++ b/openpilot/starpilot/system/starport/new_setup.py
@@ -11,7 +11,7 @@ FLAG_PATH = DATA_DIR / "new_setup"
 
 
 def enabled(path: Path | None = None) -> bool:
-  """Absent, unreadable or unrecognised means on; only an explicit 0 turns the new flow off."""
+  """Absent, unreadable or unrecognized means on; only an explicit 0 turns the new flow off."""
   try:
     return (path or FLAG_PATH).read_text().strip() != "0"
   except (OSError, UnicodeError):
diff --git a/openpilot/starpilot/system/starport/session.py b/openpilot/starpilot/system/starport/session.py
index 5eb2221bf1..f7d19ff8f9 100644
--- a/openpilot/starpilot/system/starport/session.py
+++ b/openpilot/starpilot/system/starport/session.py
@@ -662,11 +662,9 @@ class ProjectionSession(Session):
   grace_network = ""
   grace_focus_lost = False
 
-  @staticmethod
-  def radio_change() -> str | None:
-    """Replaced by the supervisor: the comma's other Wi-Fi network's name if it joined or roamed in the last few
-    seconds ("" when unnamed), else None."""
-    return None
+  # Replaced by the supervisor: the comma's other Wi-Fi network's name if it joined or roamed in the last few
+  # seconds ("" when unnamed), else None.
+  radio_change: Callable[..., str | None] = staticmethod(lambda: None)
 
   # HeadunitPad acknowledges every fragment (codec config included) rather than every frame.
   fragment_acks = False
diff --git a/openpilot/starpilot/system/starport/setup_ladder.py b/openpilot/starpilot/system/starport/setup_ladder.py
index d433f459a3..11ab9c6a1a 100644
--- a/openpilot/starpilot/system/starport/setup_ladder.py
+++ b/openpilot/starpilot/system/starport/setup_ladder.py
@@ -133,7 +133,7 @@ def _clean(entry) -> dict:
 
 
 class SetupLadder:
-  def __init__(self, path: Path | None = None, boot_id=_boot_id, clock=time.time):
+  def __init__(self, path: Path | None = None, boot_id=_boot_id, clock=time.time):  # noqa: TID251 persisted timestamps
     self.path = path or STATE_PATH
     self.boot_id, self.clock = boot_id, clock
     self.cars: dict[str, dict] = {}
diff --git a/openpilot/starpilot/system/starport/supervisor.py b/openpilot/starpilot/system/starport/supervisor.py
index 82ff4dd80b..90dbe7a196 100644
--- a/openpilot/starpilot/system/starport/supervisor.py
+++ b/openpilot/starpilot/system/starport/supervisor.py
@@ -435,7 +435,7 @@ class Supervisor:
     self._attempt_ended_at: float | None = None
     self._hfp_link = threading.Event()  # set when the chosen car opens the hands-free link
     self._modern_reply: dict[str, bool] = {}  # car address -> answer its v4+ version request like a current phone
-    self._ladder = setup_ladder.SetupLadder(identity_store.CONFIG_PATH.with_name("setup_state.json"))   # which handshake to try for each car, and which one last worked
+    self._ladder = setup_ladder.SetupLadder(identity_store.CONFIG_PATH.with_name("setup_state.json"))  # handshake to try per car
     self._strategy: setup_ladder.Strategy | None = None   # the one this attempt runs
     self._video_seen = False                    # video was acknowledged in this session: later failures say nothing about the handshake
     self._run_started = 0.0
@@ -1455,7 +1455,6 @@ class Supervisor:
     bluez.connect_device(address)
     self._wait(1.0)
 
-    from openpilot.starpilot.system.starport import bt_sockets
     channel = int(config.get("rfcomm_channel") or 0)
     source = "config"
     if not channel:
diff --git a/openpilot/starpilot/system/starport/tests/test_bugsink_report.py b/openpilot/starpilot/system/starport/tests/test_bugsink_report.py
index dd41ff85eb..475b4b22e8 100644
--- a/openpilot/starpilot/system/starport/tests/test_bugsink_report.py
+++ b/openpilot/starpilot/system/starport/tests/test_bugsink_report.py
@@ -450,7 +450,7 @@ OFFER = {"channels": [{"id": 3, "video_configs": [
 
 
 def adapter_session():
-  events = [list(item) for item in STREAMED]
+  events: list = [list(item) for item in STREAMED]
   events[0] = (0, 0, "session_start", {"receiver": "AAWireless", "trigger": "auto",
                                        "setup": {"type": "adapter", "profile": "aawireless", "profile_source": "override"}})
   events[5] = (0, 10, "discovered", {**OFFER, "head_unit": STREAMED[5][3]["head_unit"]})
@@ -479,7 +479,7 @@ def test_report_keeps_setup_offered_modes_and_the_working_strategy(tmp_path):
 
 
 def test_report_records_that_the_address_was_not_sent_and_old_logs_still_report(tmp_path):
-  events = [list(item) for item in STREAMED]
+  events: list = [list(item) for item in STREAMED]
   events.insert(6, (0, 10, "bluetooth_opened", {"channel": 6, "phone_address": ""}))
   assert br.drive_event([br.session_record(write_session(tmp_path, 1, events))])["tags"]["aa.phone_address_sent"] == "no"
   old = br.session_record(write_session(tmp_path, 2, STREAMED))  # a log written before these fields existed
@@ -489,14 +489,14 @@ def test_report_records_that_the_address_was_not_sent_and_old_logs_still_report(
 
 
 def test_unknown_setup_values_are_dropped(tmp_path):
-  events = [list(item) for item in STREAMED]
+  events: list = [list(item) for item in STREAMED]
   events[0] = (0, 0, "session_start", {"setup": {"type": "<script>", "profile": "x" * 90, "profile_source": "guess"}})
   setup = br.session_record(write_session(tmp_path, 1, events))["setup"]
   assert "type" not in setup and "profile_source" not in setup and len(setup["profile"]) <= 40
 
 
 def test_report_shows_what_the_ladder_tried_and_what_worked(tmp_path):
-  events = [list(item) for item in STREAMED]
+  events: list = [list(item) for item in STREAMED]
   events.insert(1, (0, 1, "ladder_strategy", {"rung": "standard", "learned": False}))
   events.insert(2, (0, 5, "ladder_failed", {"outcome": "advanced", "rung": "standard", "next": "other_reply"}))
   events.insert(3, (0, 6, "ladder_strategy", {"rung": "other_reply", "learned": False}))
@@ -510,7 +510,7 @@ def test_report_shows_what_the_ladder_tried_and_what_worked(tmp_path):
 
 
 def test_report_says_how_the_rfcomm_channel_was_found(tmp_path):
-  events = [list(item) for item in STREAMED]
+  events: list = [list(item) for item in STREAMED]
   events.insert(1, (0, 1, "sdp_retry", {"error": "x"}))
   events.insert(2, (0, 2, "rfcomm_channel", {"channel": 8, "source": "sdp"}))
   assert br.session_record(write_session(tmp_path, 1, events))["sdp"] == {"channel": 8, "source": "sdp", "retries": 1}
diff --git a/openpilot/starpilot/system/starport/tests/test_car_adoption.py b/openpilot/starpilot/system/starport/tests/test_car_adoption.py
index 6741cb15dd..1c10590dc3 100644
--- a/openpilot/starpilot/system/starport/tests/test_car_adoption.py
+++ b/openpilot/starpilot/system/starport/tests/test_car_adoption.py
@@ -44,7 +44,8 @@ def test_the_only_candidate_is_chosen_trusted_and_the_projection_role_given_back
   sup._adopt_only_car(1000.0)
   assert sup.config["receiver_address"] == CAR and sup.config["receiver_name"] == "Civic"
   assert identity_store.load_config()["receiver_address"] == CAR
-  assert bluez.trusted[-1] == CAR and bluez.acquired == sup.baseline + 1 and bluez.class_restored >= 1  # the phone look is given back; the standby gateway stays
+  # the phone look is given back; the standby gateway stays
+  assert bluez.trusted[-1] == CAR and bluez.acquired == sup.baseline + 1 and bluez.class_restored >= 1
   assert "car_adopted" in names(sup) and sup._candidates == []
 
 
diff --git a/openpilot/starpilot/system/starport/tests/test_car_never_answered.py b/openpilot/starpilot/system/starport/tests/test_car_never_answered.py
index 26970b2f2c..48e34b9cc9 100644
--- a/openpilot/starpilot/system/starport/tests/test_car_never_answered.py
+++ b/openpilot/starpilot/system/starport/tests/test_car_never_answered.py
@@ -40,6 +40,7 @@ class TestChooseOnlyCar(unittest.TestCase):
   def test_exactly_one_paired_android_auto_device_is_adopted(self):
     from openpilot.starpilot.system.starport.supervisor import choose_only_car
     only, candidates = choose_only_car([self.car("A"), self.car("B", starport=False), self.car("C", paired=False)])
+    assert only is not None
     self.assertEqual((only["address"], [c["address"] for c in candidates]), ("A", ["A"]))
 
   def test_two_candidates_or_none_are_never_guessed(self):
diff --git a/openpilot/starpilot/system/starport/tests/test_reachability.py b/openpilot/starpilot/system/starport/tests/test_reachability.py
index b067042f15..23d37d9b42 100644
--- a/openpilot/starpilot/system/starport/tests/test_reachability.py
+++ b/openpilot/starpilot/system/starport/tests/test_reachability.py
@@ -61,7 +61,8 @@ def test_stream_losses_are_told_apart_by_what_the_log_says(tmp_path):
   assert stream_loss_kind("projecting: Head unit disconnected after 4/8 bytes") == "disconnected"
   assert stream_loss_kind("something else") == "other"
   for text, kind in (("Video acknowledgement older than 2.5 s", "stalled"), ("Head unit disconnected after 4/8 bytes", "disconnected")):
-    events = [(0, 0, "session_start", {}), (0, 1, "stage", {"state": "streaming"}), (0, 9, "attempt_failed", {"stage": "streaming", "kind": "EOFError", "error": text})]
+    events = [(0, 0, "session_start", {}), (0, 1, "stage", {"state": "streaming"}),
+              (0, 9, "attempt_failed", {"stage": "streaming", "kind": "EOFError", "error": text})]
     event = br.drive_event([br.session_record(write_session(tmp_path, 3 if kind == "stalled" else 4, events))])
     assert event["tags"]["aa.cause"] == "projection_interrupted" and event["tags"]["aa.loss_kind"] == kind
 
diff --git a/openpilot/starpilot/system/starport/tests/test_setup_ladder.py b/openpilot/starpilot/system/starport/tests/test_setup_ladder.py
index fbb7e65acc..38ceec6f85 100644
--- a/openpilot/starpilot/system/starport/tests/test_setup_ladder.py
+++ b/openpilot/starpilot/system/starport/tests/test_setup_ladder.py
@@ -18,7 +18,7 @@ def ladder(tmp_path):
 
 
 def refuse(ladder, strategy, **overrides):
-  values = dict(ladder_failure=True, video_seen=False, version_major=4, adapter=False)
+  values = {"ladder_failure": True, "video_seen": False, "version_major": 4, "adapter": False}
   values.update(overrides)
   return ladder.failed(CAR, strategy, **values)
 
@@ -157,11 +157,11 @@ def test_only_sixteen_cars_are_kept_newest_first(tmp_path):
 
 
 # ---- the supervisor's use of it -------------------------------------------------------------------------------------
-import time as _time  # noqa: E402
-from types import SimpleNamespace  # noqa: E402
+import time as _time
+from types import SimpleNamespace
 
-from openpilot.starpilot.system.starport.tests.fake_head_unit import make_identity  # noqa: E402
-from openpilot.starpilot.system.starport.tests.test_starport import make_supervisor  # noqa: E402
+from openpilot.starpilot.system.starport.tests.fake_head_unit import make_identity
+from openpilot.starpilot.system.starport.tests.test_starport import make_supervisor
 
 RECEIVER = "AA:BB:CC:DD:EE:01"  # the car make_supervisor selects
 
diff --git a/openpilot/starpilot/system/starport/tests/test_shared_radio_grace.py b/openpilot/starpilot/system/starport/tests/test_shared_radio_grace.py
index f72918f3ec..33c02df4c6 100644
--- a/openpilot/starpilot/system/starport/tests/test_shared_radio_grace.py
+++ b/openpilot/starpilot/system/starport/tests/test_shared_radio_grace.py
@@ -102,6 +102,7 @@ def test_watch_reports_a_carrier_change_with_the_network_name(tmp_path, monkeypa
       assert time.monotonic() < deadline
       time.sleep(0.01)
     assert logged == [("other_wifi_changed", {"interface": "wlan0", "network": "Huckleberrys House"})]
+    assert watch.changed_at is not None
     assert watch.recent(now=watch.changed_at + supervisor_module.RADIO_CHANGE_WINDOW + 0.1) is None
   finally:
     watch.stop()

From 80f707aa3d165b3375af373ba6f9cd89da408cd4 Mon Sep 17 00:00:00 2001
From: Danny <dannyirwin31@yahoo.com>
Date: Mon, 2 Nov 2026 19:15:18 -0800
Subject: [PATCH 33/38] StarPort: Review fixes for the stall notice, car forget
 and car adoption Reuse atomic_write and the sr-only class, drop dead code,
 update stale tests

---
 openpilot/starpilot/galaxy/starport_send.py   | 14 +---
 .../starpilot/galaxy/tests/test_starport.mjs  |  5 +-
 openpilot/starpilot/galaxy/web/css/galaxy.css |  1 -
 .../galaxy/web/js/starport-guided.js          |  2 +-
 .../starpilot/system/starport/bootstrap.py    |  8 --
 .../system/starport/bugsink_diagnosis.py      |  2 +-
 .../starpilot/system/starport/network.py      | 31 --------
 .../starpilot/system/starport/new_setup.py    |  6 +-
 .../system/starport/reconnect_notice.py       | 17 +---
 .../starpilot/system/starport/session.py      | 31 +++-----
 .../starpilot/system/starport/setup_ladder.py | 16 +---
 .../starpilot/system/starport/supervisor.py   | 35 +++------
 .../tests/test_bootstrap_receivers.py         | 13 ----
 .../starport/tests/test_car_adoption.py       | 10 +++
 .../system/starport/tests/test_forget_car.py  |  8 ++
 .../starport/tests/test_shared_radio_grace.py | 78 +++++--------------
 16 files changed, 78 insertions(+), 199 deletions(-)

diff --git a/openpilot/starpilot/galaxy/starport_send.py b/openpilot/starpilot/galaxy/starport_send.py
index 2be1c6d37d..91e668a32c 100644
--- a/openpilot/starpilot/galaxy/starport_send.py
+++ b/openpilot/starpilot/galaxy/starport_send.py
@@ -11,15 +11,14 @@ from __future__ import annotations
 import base64
 import hashlib
 import json
-import os
 import re
-import tempfile
 import threading
 import time
 from collections.abc import Callable
 from pathlib import Path
 from urllib.parse import parse_qsl, urlencode, urlsplit, urlunsplit
 
+from openpilot.common.utils import atomic_write
 from openpilot.starpilot.system.starport import identity as identity_store
 
 MESSAGE_LIMIT = 60
@@ -148,15 +147,8 @@ def _response_json(response) -> dict:
 def _save_thread_id(path: Path, key: str, thread_id: str) -> None:
   path.parent.mkdir(parents=True, exist_ok=True)
   # A power loss during a write must not truncate the previous cache entry.
-  with tempfile.NamedTemporaryFile(mode="w", dir=path.parent, delete=False) as temporary:
-    temporary_path = Path(temporary.name)
-    try:
-      json.dump({"key": key, "thread_id": thread_id}, temporary)
-      temporary.flush()
-      os.fsync(temporary.fileno())
-      os.replace(temporary_path, path)
-    finally:
-      temporary_path.unlink(missing_ok=True)
+  with atomic_write(str(path), overwrite=True) as handle:
+    json.dump({"key": key, "thread_id": thread_id}, handle)
 
 
 def send(data: bytes, name: str, note: str, summary: dict, url: str | None = None, post=None,
diff --git a/openpilot/starpilot/galaxy/tests/test_starport.mjs b/openpilot/starpilot/galaxy/tests/test_starport.mjs
index f2ef23f936..a29a6b9c7b 100644
--- a/openpilot/starpilot/galaxy/tests/test_starport.mjs
+++ b/openpilot/starpilot/galaxy/tests/test_starport.mjs
@@ -17,7 +17,7 @@ assert.equal(validPromptInput({ kind: "pin" }, "1234"), true)
 assert.equal(validPromptInput({ kind: "pin" }, "\n"), false)
 assert.equal(validPromptInput({ kind: "passkey" }, "1234567"), false)
 assert.equal(validPromptInput(prompt, ""), true)
-assert.match(StarPortPage.template, /Check that this code matches your car/)
+assert.match(StarPortPage.template, /Check that this code matches your/)
 assert.match(StarPortPage.template, /Cancel Search \/ Pairing/)
 assert.doesNotMatch(StarPortPage.template, /:row="wiredRow"/)
 assert.match(StarPortPage.template, /Read the Android Auto troubleshooting guide/)
@@ -484,6 +484,9 @@ typed.runtime = { car_type: 'adapter' }
 assert.equal(typed.adapterSetup, true)
 assert.equal(typed.pairsHere, true)
 assert.equal(typed.findLabel, 'adapter')
+assert.equal(typed.deviceWord, 'adapter', 'the pairing prompts name the adapter, not the car')
+typed.runtime = { car_type: 'builtin' }
+assert.equal(typed.deviceWord, 'car')
 typed.runtime = { car_type: 'usb' }
 assert.equal(typed.pairsHere, false, 'a USB cable needs no Bluetooth pairing')
 typed.runtime = { running: false, connection: 'wired' }
diff --git a/openpilot/starpilot/galaxy/web/css/galaxy.css b/openpilot/starpilot/galaxy/web/css/galaxy.css
index 63bbb1f223..a995d57cdd 100644
--- a/openpilot/starpilot/galaxy/web/css/galaxy.css
+++ b/openpilot/starpilot/galaxy/web/css/galaxy.css
@@ -2039,7 +2039,6 @@ progress { max-width: 100%; accent-color: var(--primary); }
 .gx-guided__step-label { font-size: 13px; font-weight: var(--fw-bold); color: var(--g-muted); }
 .gx-guided__step.is-current .gx-guided__step-label { color: var(--g-ink); }
 @keyframes gx-guided-pop { 0% { transform: scale(.7); } 60% { transform: scale(1.12); } 100% { transform: scale(1); } }
-.gx-guided__sr { position: absolute; width: 1px; height: 1px; overflow: hidden; clip-path: inset(50%); white-space: nowrap; }
 
 .gx-guided__header { display: grid; gap: 6px; max-width: 34rem; }
 .gx-guided__title { margin: 0; font-size: 30px; line-height: 1.12; font-weight: var(--fw-bold); letter-spacing: -.02em; text-wrap: balance; }
diff --git a/openpilot/starpilot/galaxy/web/js/starport-guided.js b/openpilot/starpilot/galaxy/web/js/starport-guided.js
index f703c348f6..ade56ed1e6 100644
--- a/openpilot/starpilot/galaxy/web/js/starport-guided.js
+++ b/openpilot/starpilot/galaxy/web/js/starport-guided.js
@@ -134,7 +134,7 @@ export const StarPortGuidedSetup = {
         <li v-for="(step, index) in state.steps" :key="step.id" class="gx-guided__step" :class="'is-' + step.state"
             :aria-current="step.state === 'current' ? 'step' : undefined">
           <span class="gx-guided__node" aria-hidden="true"><i v-if="step.state === 'done'" class="bi bi-check-lg"></i><template v-else>{{ index + 1 }}</template></span>
-          <span class="gx-guided__step-label">{{ step.label }}<span class="gx-guided__sr">{{ step.state === 'done' ? ', done' : step.state === 'current' ? ', current step' : '' }}</span></span>
+          <span class="gx-guided__step-label">{{ step.label }}<span class="gx-sr-only">{{ step.state === 'done' ? ', done' : step.state === 'current' ? ', current step' : '' }}</span></span>
         </li>
       </ol>
 
diff --git a/openpilot/starpilot/system/starport/bootstrap.py b/openpilot/starpilot/system/starport/bootstrap.py
index 9e23f0d0c4..2836bb6089 100644
--- a/openpilot/starpilot/system/starport/bootstrap.py
+++ b/openpilot/starpilot/system/starport/bootstrap.py
@@ -275,7 +275,6 @@ class WirelessBootstrap:
     self.patience = patience                # stage timeouts a car that keeps saying "not ready" gets (setup ladder)
     self.channel_override = channel_override  # Wi-Fi band to answer with inside the phone-style reply; None keeps the car's own
     self.version_major = 0
-    self.car_started = False
     self.flags = EXPERIMENTS[self.experiment][1] if self.experiment else set()
     self.initial_kick_delay = initial_kick_delay
     self.join_ping_interval = join_ping_interval
@@ -347,11 +346,6 @@ class WirelessBootstrap:
     self.log("bootstrap_version_reply", style="modern", channel_type=selected, hex=reply.hex())
     return reply
 
-  def silent_after_modern_version(self, error: BaseException) -> bool:
-    """A v4+ head unit took our version reply but never started; the other reply style may suit it."""
-    return (isinstance(error, BootstrapTimeout) and error.stage == "wifi_start" and self.version_major >= MODERN_MAJOR
-            and not self.car_started)
-
   def service(self, message_id: int, payload: bytes) -> bool:
     """Handle stage-independent frames; returns True when consumed."""
     if message_id == WIFI_PING_REQUEST:
@@ -423,7 +417,6 @@ class WirelessBootstrap:
         if start_request_at is None:
           start_request_at = time.monotonic() + self.start_request_delay
       elif message_id == WIFI_START_REQUEST:
-        self.car_started = True
         parsed = parse_endpoint(payload)
         if parsed is None:
           raise BootstrapError(self.stage, "WifiStartRequest has no valid IPv4 endpoint")
@@ -431,7 +424,6 @@ class WirelessBootstrap:
         if "start_response_first" in self.flags:
           self.send(WIFI_START_RESPONSE, field(3, STATUS_SUCCESS))
       elif message_id == WIFI_START_RESPONSE:
-        self.car_started = True
         # The car's answer to our WifiStartRequest (2025 Honda): ip=1, port=2, status=3 once it is
         # ready, or a negative status alone before then (it may follow up on its own; ask again anyway).
         status = signed(one(parse_fields(payload), 3, STATUS_SUCCESS))
diff --git a/openpilot/starpilot/system/starport/bugsink_diagnosis.py b/openpilot/starpilot/system/starport/bugsink_diagnosis.py
index f9a3d97dae..b7630d0187 100644
--- a/openpilot/starpilot/system/starport/bugsink_diagnosis.py
+++ b/openpilot/starpilot/system/starport/bugsink_diagnosis.py
@@ -99,7 +99,7 @@ def attempt_records(events):
 
 STREAM_LOSS = {
   "shared_radio": ("comma's own Wi-Fi", "The car stopped acknowledging video while the comma's own Wi-Fi joined or roamed; both share one radio.",
-                   ["Check the other_wifi_changed and ack_grace events for the network and how long acks stopped.",
+                   ["Check the other_wifi_changed and ack_grace events for when it changed and how long acks stopped.",
                     "Repeated drops at home or on a hotspot mean the 8 s grace is too short or the car takes its screen back first."]),
   "stalled": ("Video acknowledgement older than", "The car kept the link but stopped acknowledging video for too long, so the stream was ended.",
               ["Compare the Wi-Fi signal, frame age and encoder recoveries around the stall.",
diff --git a/openpilot/starpilot/system/starport/network.py b/openpilot/starpilot/system/starport/network.py
index 9609b64492..1611016419 100644
--- a/openpilot/starpilot/system/starport/network.py
+++ b/openpilot/starpilot/system/starport/network.py
@@ -109,37 +109,6 @@ def recover_autoconnect(log: Callable[..., None], marker: Path = AUTOCONNECT_MAR
   return True
 
 
-SETTINGS_PROFILE_PREFIX = "openpilot connection "  # system/ui/lib/wifi_manager.py names saved networks this way
-
-
-def profile_network_name(profile: str) -> str:
-  """A saved connection's network name: "openpilot connection Home" -> "Home"; other profiles as they are."""
-  return profile[len(SETTINGS_PROFILE_PREFIX):] if profile.startswith(SETTINGS_PROFILE_PREFIX) else profile
-
-
-def wifi_network_name(interface: str = "wlan0") -> str:
-  """The network the comma's own Wi-Fi is on or joining, for telling the driver; "" if none or unknown.
-
-  Its own D-Bus connection: never the car lease's, whose lock the link check and reconnect wait on."""
-  lease = NetworkLease(lambda *args, **kwargs: None, interface)
-  try:
-    for path, name in lease._wifi_devices():
-      if name != interface:
-        continue
-      access_point = lease._get(path, NM_WIRELESS_IFACE, "ActiveAccessPoint")
-      if access_point and access_point != "/":
-        ssid = bytes(lease._get(access_point, NM_AP_IFACE, "Ssid")).decode("utf-8", "replace").strip()
-        if ssid:
-          return ssid
-      # Still joining (no access point yet): the profile's name, which the comma's Wi-Fi settings prefix.
-      active = lease._get(path, NM_DEVICE_IFACE, "ActiveConnection")
-      return profile_network_name(str(lease._get(active, NM_ACTIVE_IFACE, "Id"))) if active and active != "/" else ""
-    return ""
-  finally:
-    if lease.router is not None:
-      lease.router.close()
-
-
 def connection_settings(credentials: WifiCredentials, interface: str) -> dict:
   wireless = {
     "ssid": ("ay", credentials.ssid.encode("utf-8")),
diff --git a/openpilot/starpilot/system/starport/new_setup.py b/openpilot/starpilot/system/starport/new_setup.py
index 49708eecb1..6cca56c184 100644
--- a/openpilot/starpilot/system/starport/new_setup.py
+++ b/openpilot/starpilot/system/starport/new_setup.py
@@ -5,6 +5,7 @@ read and change with the StarPort service down or broken, and it needs no device
 """
 from pathlib import Path
 
+from openpilot.common.utils import atomic_write
 from openpilot.starpilot.system.starport.identity import DATA_DIR
 
 FLAG_PATH = DATA_DIR / "new_setup"
@@ -22,9 +23,8 @@ def set_enabled(value: bool, path: Path | None = None) -> bool:
   target = path or FLAG_PATH
   try:
     target.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
-    temporary = target.with_name(f".{target.name}.tmp")
-    temporary.write_text("1" if value else "0")
-    temporary.replace(target)
+    with atomic_write(str(target), overwrite=True) as handle:
+      handle.write("1" if value else "0")
   except OSError:
     return False
   return enabled(target) == value
diff --git a/openpilot/starpilot/system/starport/reconnect_notice.py b/openpilot/starpilot/system/starport/reconnect_notice.py
index 9862e9e66d..0cf7a42792 100644
--- a/openpilot/starpilot/system/starport/reconnect_notice.py
+++ b/openpilot/starpilot/system/starport/reconnect_notice.py
@@ -3,31 +3,22 @@
 from __future__ import annotations
 
 import json
-import os
 import time
 from pathlib import Path
 
+from openpilot.common.utils import atomic_write
 from openpilot.starpilot.system.starport import identity as identity_store
 
 NOTICE_PATH = identity_store.DATA_DIR / "reconnect_notice.json"
 NOTICE_FRESH_S = 120.0  # a notice older than this is about an earlier drive or reconnect (monotonic: same boot only)
-NAME_MAX = 24
-
-
-def shared_radio_text(network: str) -> str:
-  """The car-screen line for a drop caused by the comma's own Wi-Fi joining or roaming."""
-  name = network.strip()
-  if len(name) > NAME_MAX:
-    name = name[:NAME_MAX - 3].rstrip() + "..."  # plain dots: the car-screen fonts may lack an ellipsis glyph
-  return f"Reconnected: comma Wi-Fi Joined {name}" if name else "Reconnected: comma Wi-Fi Was Switching Networks"
+SHARED_RADIO_TEXT = "Reconnected: comma Wi-Fi Was Switching Networks"  # on the car screen after a drop caused by the comma's own Wi-Fi
 
 
 def write(text: str, path: Path = NOTICE_PATH, now: float | None = None) -> None:
   try:
     path.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
-    temporary = path.with_suffix(".tmp")
-    temporary.write_text(json.dumps({"text": text, "written": time.monotonic() if now is None else now}))
-    os.replace(temporary, path)
+    with atomic_write(str(path), overwrite=True) as handle:
+      json.dump({"text": text, "written": time.monotonic() if now is None else now}, handle)
   except OSError:
     pass  # the notice is a courtesy; projection never depends on it
 
diff --git a/openpilot/starpilot/system/starport/session.py b/openpilot/starpilot/system/starport/session.py
index f7d19ff8f9..f577caca8f 100644
--- a/openpilot/starpilot/system/starport/session.py
+++ b/openpilot/starpilot/system/starport/session.py
@@ -118,12 +118,6 @@ class PeerRequestedStop(EOFError):
 
 class SharedRadioStall(TimeoutError):
   """The car stopped acknowledging video while the comma's other Wi-Fi network was joining or roaming."""
-
-  def __init__(self, message: str, network: str):
-    super().__init__(message)
-    self.network = network
-
-
 START_CODE = re.compile(b"\x00\x00(?:\x00)?\x01")
 
 
@@ -659,12 +653,10 @@ class ProjectionSession(Session):
   MAX_WINDOW = 2
   nav = None
   grace_frame: float | None = None  # send time of the frame whose late ack is being waited out
-  grace_network = ""
   grace_focus_lost = False
 
-  # Replaced by the supervisor: the comma's other Wi-Fi network's name if it joined or roamed in the last few
-  # seconds ("" when unnamed), else None.
-  radio_change: Callable[..., str | None] = staticmethod(lambda: None)
+  # Replaced by the supervisor: whether the comma's other Wi-Fi joined or roamed in the last few seconds.
+  radio_change: Callable[..., bool] = staticmethod(lambda: False)
 
   # HeadunitPad acknowledges every fragment (codec config included) rather than every frame.
   fragment_acks = False
@@ -965,7 +957,7 @@ class ProjectionSession(Session):
     self.acked += count
     self.epoch_acked += count
     if self.grace_frame is not None and (not self.pending or self.pending[0] != self.grace_frame):
-      self.event("ack_grace_recovered", network=self.grace_network, gap_ms=round((now - self.grace_frame) * 1000))
+      self.event("ack_grace_recovered", gap_ms=round((now - self.grace_frame) * 1000))
       self.grace_frame = None
     self._confirm_video()
 
@@ -991,7 +983,7 @@ class ProjectionSession(Session):
     measured = now is None
     now = time.monotonic() if measured else now
     if self.grace_focus_lost:
-      raise SharedRadioStall("The car took its screen back while the comma's Wi-Fi was switching networks", self.grace_network)
+      raise SharedRadioStall("The car took its screen back while the comma's Wi-Fi was switching networks")
     if self._ack_overdue(now):
       # ACKs that arrived while this loop was busy (a slow encode, a CPU burst) still sit in the socket; the
       # streaming loop drains only a bounded batch per pass, so read what is there before calling the car silent.
@@ -1010,18 +1002,13 @@ class ProjectionSession(Session):
   def _wait_out_radio_change(self, now: float) -> None:
     """The oldest frame is past ACK_TIMEOUT: give up, unless the comma's other Wi-Fi just changed networks."""
     oldest = self.pending[0]
-    if self.grace_frame == oldest:
-      network = self.grace_network
-    else:
-      changed = self.radio_change()
-      if changed is None:
+    if self.grace_frame != oldest:
+      if not self.radio_change():
         raise TimeoutError(f"Video acknowledgement older than {self.ACK_TIMEOUT:.1f} s")
-      self.grace_frame, self.grace_network = oldest, changed
-      self.event("ack_grace", network=changed, after_ms=round((now - oldest) * 1000))
-      network = changed
+      self.grace_frame = oldest
+      self.event("ack_grace", after_ms=round((now - oldest) * 1000))
     if now - oldest > self.ACK_GRACE_TIMEOUT:
-      message = f"Video acknowledgement older than {self.ACK_GRACE_TIMEOUT:.1f} s while the comma's Wi-Fi was switching networks"
-      raise SharedRadioStall(message, network)
+      raise SharedRadioStall(f"Video acknowledgement older than {self.ACK_GRACE_TIMEOUT:.1f} s while the comma's Wi-Fi was switching networks")
 
   def send_frame(self, data: bytes, timestamp_us: int, *, keyframe: bool) -> None:
     if not self.can_send():
diff --git a/openpilot/starpilot/system/starport/setup_ladder.py b/openpilot/starpilot/system/starport/setup_ladder.py
index 11ab9c6a1a..40b5187b2c 100644
--- a/openpilot/starpilot/system/starport/setup_ladder.py
+++ b/openpilot/starpilot/system/starport/setup_ladder.py
@@ -15,12 +15,11 @@ The first pass for a car is exactly what ran before (rung ``standard``); the lat
 from __future__ import annotations
 
 import json
-import os
-import tempfile
 import time
 from dataclasses import dataclass
 from pathlib import Path
 
+from openpilot.common.utils import atomic_write
 from openpilot.starpilot.system.starport.bootstrap import CHANNEL_24GHZ, CHANNEL_DUAL, MODERN_MAJOR, REFUSAL_PATIENCE
 from openpilot.starpilot.system.starport.identity import DATA_DIR
 
@@ -152,17 +151,8 @@ class SetupLadder:
     self.cars = ordered
     try:
       self.path.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
-      fd, temporary = tempfile.mkstemp(dir=self.path.parent, prefix=".setup-state-")
-      try:
-        with os.fdopen(fd, "w") as handle:
-          json.dump({"version": STATE_VERSION, "cars": ordered}, handle, separators=(",", ":"))
-          handle.flush()
-          os.fsync(handle.fileno())
-        os.chmod(temporary, 0o600)
-        os.replace(temporary, self.path)
-      finally:
-        if os.path.exists(temporary):
-          os.unlink(temporary)
+      with atomic_write(str(self.path), overwrite=True) as handle:
+        json.dump({"version": STATE_VERSION, "cars": ordered}, handle, separators=(",", ":"))
     except OSError:
       return False  # progress is a convenience; a read-only disk must never stop a connection
     return True
diff --git a/openpilot/starpilot/system/starport/supervisor.py b/openpilot/starpilot/system/starport/supervisor.py
index 90dbe7a196..2ba3b6da0b 100644
--- a/openpilot/starpilot/system/starport/supervisor.py
+++ b/openpilot/starpilot/system/starport/supervisor.py
@@ -258,19 +258,14 @@ class LinkWatch:
 class SharedRadioWatch:
   """Notices the comma's own Wi-Fi joining or roaming while the car is on aa0; both share one radio.
 
-  The link going down or up bumps carrier_changes, a plain sysfs read. The network's name comes from
-  NetworkManager on this thread, never the streaming one.
+  The link going down or up bumps carrier_changes, a plain sysfs read. The network's name is never read or logged.
   """
 
   def __init__(self, log: Callable[..., None], interface: str = "wlan0", interval: float = RADIO_CHECK_INTERVAL,
-               counter: Path | None = None, name: Callable[[str], str] | None = None):
+               counter: Path | None = None):
     self.log, self.interface, self.interval = log, interface, interval
-    if name is None:
-      from openpilot.starpilot.system.starport.network import wifi_network_name as name
-    self.name = name
     self.counter = counter or Path(f"/sys/class/net/{interface}/carrier_changes")
     self.changed_at: float | None = None
-    self.network = ""
     self._stop = threading.Event()
     self._thread = threading.Thread(target=self._run, name="aa_radio_watch", daemon=True)
 
@@ -281,11 +276,11 @@ class SharedRadioWatch:
   def stop(self) -> None:
     self._stop.set()
 
-  def recent(self, now: float | None = None) -> str | None:
-    """The other network's name if it changed within RADIO_CHANGE_WINDOW ("" if unnamed), else None."""
+  def recent(self, now: float | None = None) -> bool:
+    """Whether the other network joined or roamed within RADIO_CHANGE_WINDOW."""
     changed_at = self.changed_at
     now = time.monotonic() if now is None else now
-    return self.network if changed_at is not None and now - changed_at <= RADIO_CHANGE_WINDOW else None
+    return changed_at is not None and now - changed_at <= RADIO_CHANGE_WINDOW
 
   def _read(self) -> str | None:
     try:
@@ -300,13 +295,8 @@ class SharedRadioWatch:
       if current is None or current == last:
         continue
       last = current
-      self.network = ""  # named below; D-Bus can be slow, and the change must count from now
       self.changed_at = time.monotonic()
-      try:
-        self.network = self.name(self.interface)
-      except Exception:
-        self.network = ""
-      self.log("other_wifi_changed", interface=self.interface, network=self.network)
+      self.log("other_wifi_changed", interface=self.interface)
 
 
 class EventLog:
@@ -597,11 +587,11 @@ class Supervisor:
       cache, replies = dict(self.config["rfcomm_cache"]), dict(self.config.get("modern_reply_cache", {}))
       cached = cache.pop(address, None) is not None
       cached = replies.pop(address, None) is not None or cached
-      if not (chosen or companion or cached):
+      learned = self._ladder.forget(address)
+      if not (chosen or companion or cached or learned):
         return False  # nothing of this device was kept
       self.config.update(rfcomm_cache=cache, modern_reply_cache=replies)
       self._modern_reply.pop(address, None)
-      self._ladder.forget(address)
       if chosen:
         if self._bluez is not None:
           self._bluez.release()
@@ -846,7 +836,7 @@ class Supervisor:
       return
     self._adopt_at = now
     try:
-      car, candidates = choose_only_car(self._phone().devices())
+      car, candidates = choose_only_car(self.devices())
     except Exception as error:
       self._adopt_note("car_adopt_unavailable", kind=type(error).__name__, error=str(error)[:120])
       return
@@ -860,7 +850,7 @@ class Supervisor:
       return
     try:
       self.select_receiver(car["address"], car.get("name") or "")
-    except (RuntimeError, ValueError) as error:
+    except Exception as error:
       self._adopt_note("car_adopt_failed", error=str(error))
       return
     finally:
@@ -1369,7 +1359,7 @@ class Supervisor:
           reach = reachability.classify(stage, type(error).__name__, f"{message} {error}")
           self.log("attempt_failed", stage=stage, error=message, kind=type(error).__name__, where=_where(error), reach=reach)
           if isinstance(error, SharedRadioStall):
-            reconnect_notice.write(reconnect_notice.shared_radio_text(error.network))
+            reconnect_notice.write(reconnect_notice.SHARED_RADIO_TEXT)
           if isinstance(error, StrayLinkError):
             self._clear_stray_link()
             car_first = True  # the car pages right back once its link drops; let it, rather than crossing it again
@@ -1414,8 +1404,7 @@ class Supervisor:
     if isinstance(error, AuthenticationRejected):
       return "The car rejected the Android Auto identity; it may have expired"
     if isinstance(error, SharedRadioStall):
-      joined = f"joined {error.network}" if error.network else "was switching networks"
-      return f"The car's Wi-Fi stalled while the comma's own Wi-Fi {joined}; reconnecting"
+      return "The car's Wi-Fi stalled while the comma's own Wi-Fi was switching networks; reconnecting"
     text = str(error) or type(error).__name__
     if stage == "authenticating" and "certificate" in text.lower():
       text += " (set verify_head_unit false in config.json to test without verifying the car)"
diff --git a/openpilot/starpilot/system/starport/tests/test_bootstrap_receivers.py b/openpilot/starpilot/system/starport/tests/test_bootstrap_receivers.py
index 4c41072a91..4622c9bcd2 100644
--- a/openpilot/starpilot/system/starport/tests/test_bootstrap_receivers.py
+++ b/openpilot/starpilot/system/starport/tests/test_bootstrap_receivers.py
@@ -185,16 +185,3 @@ def test_version_four_head_units_get_a_phone_shaped_version_reply():
 def test_older_head_units_and_the_first_try_keep_the_reply_that_works_today():
   for reply in (version_reply(FORD_V16), version_reply(KIA_V41, modern=False)):
     assert reply[4] == [0] and 5 not in reply and 6 not in reply
-
-
-def test_only_a_silent_v4_head_unit_asks_for_the_other_reply():
-  timeout = bs.BootstrapTimeout("wifi_start", "head unit did not answer in time")
-  boot, _ = scripted([])
-  boot.version_major = 4
-  assert boot.silent_after_modern_version(timeout)
-  boot.car_started = True
-  assert not boot.silent_after_modern_version(timeout)
-  boot.car_started, boot.version_major = False, 1
-  assert not boot.silent_after_modern_version(timeout)
-  boot.version_major = 4
-  assert not boot.silent_after_modern_version(bs.BootstrapTimeout("wifi_info", "head unit did not answer in time"))
diff --git a/openpilot/starpilot/system/starport/tests/test_car_adoption.py b/openpilot/starpilot/system/starport/tests/test_car_adoption.py
index 1c10590dc3..5c7364f364 100644
--- a/openpilot/starpilot/system/starport/tests/test_car_adoption.py
+++ b/openpilot/starpilot/system/starport/tests/test_car_adoption.py
@@ -109,3 +109,13 @@ def test_an_unreadable_bluetooth_service_is_reported_once(sup):
   for tick in range(4):
     sup._adopt_only_car(1000.0 + 25 * tick)
   assert names(sup).count("car_adopt_unavailable") == 1
+
+
+def test_a_bluetooth_error_while_choosing_the_car_is_reported_not_raised(sup):
+  sup._phone().paired_devices = [(CAR, "Civic", True)]
+
+  def rejected(address, name=""):
+    raise Exception("Bluetooth rejected")
+  sup.select_receiver = rejected
+  sup._adopt_only_car(1000.0)
+  assert "car_adopt_failed" in names(sup) and sup.config["receiver_address"] == ""
diff --git a/openpilot/starpilot/system/starport/tests/test_forget_car.py b/openpilot/starpilot/system/starport/tests/test_forget_car.py
index d20bf89df7..4bb28a128c 100644
--- a/openpilot/starpilot/system/starport/tests/test_forget_car.py
+++ b/openpilot/starpilot/system/starport/tests/test_forget_car.py
@@ -77,3 +77,11 @@ def test_the_version_reply_a_car_started_with_is_kept_and_forgotten_with_it(sup)
   assert saved()["modern_reply_cache"] == {ADAPTER: True}
   daemon.handle(sup, {"command": "forget_receiver", "address": ADAPTER})
   assert saved()["modern_reply_cache"] == {} and ADAPTER not in sup._modern_reply
+
+
+def test_a_car_known_only_to_the_setup_ladder_is_still_forgotten(sup):
+  sup._ladder.strategy(OTHER, False)
+  sup._ladder.failed(OTHER, sup._ladder.strategy(OTHER, False), ladder_failure=True, video_seen=False, version_major=4, adapter=False)
+  assert OTHER.upper() in sup._ladder.cars
+  daemon.handle(sup, {"command": "forget_receiver", "address": OTHER})
+  assert OTHER.upper() not in sup._ladder.cars
diff --git a/openpilot/starpilot/system/starport/tests/test_shared_radio_grace.py b/openpilot/starpilot/system/starport/tests/test_shared_radio_grace.py
index 33c02df4c6..ee3cbce44e 100644
--- a/openpilot/starpilot/system/starport/tests/test_shared_radio_grace.py
+++ b/openpilot/starpilot/system/starport/tests/test_shared_radio_grace.py
@@ -17,42 +17,41 @@ def identity(tmp_path_factory):
   return make_identity(tmp_path_factory.mktemp("identity"))
 
 
-def stalled(identity, network: str | None):
+def stalled(identity, changed: bool):
   hu = FakeHeadUnit(identity)
   session = streaming_session(hu, identity)
-  session.radio_change = lambda: network
+  session.radio_change = lambda: changed
   hu.hold_acks.set()
   return hu, session, sent_frame(hu, session)
 
 
 def test_no_radio_change_keeps_the_standard_limit(identity):
-  hu, session, sent = stalled(identity, None)
+  hu, session, sent = stalled(identity, False)
   with pytest.raises(TimeoutError, match="2.5 s") as raised:
     session.check_progress(now=sent + ProjectionSession.ACK_TIMEOUT + 0.05)
   assert not isinstance(raised.value, SharedRadioStall)
   end_session(session, hu)
 
 
-def test_radio_change_waits_up_to_the_grace_limit_then_names_the_network(identity):
-  hu, session, sent = stalled(identity, "Huckleberrys House")
+def test_radio_change_waits_up_to_the_grace_limit(identity):
+  hu, session, sent = stalled(identity, True)
   session.check_progress(now=sent + ProjectionSession.ACK_TIMEOUT + 0.05)
   session.check_progress(now=sent + ProjectionSession.ACK_GRACE_TIMEOUT - 0.1)
-  with pytest.raises(SharedRadioStall) as raised:
+  with pytest.raises(SharedRadioStall):
     session.check_progress(now=sent + ProjectionSession.ACK_GRACE_TIMEOUT + 0.05)
-  assert raised.value.network == "Huckleberrys House"
   end_session(session, hu)
 
 
 def test_grace_started_by_a_change_survives_the_change_ageing_out(identity):
-  hu, session, sent = stalled(identity, "Home")
+  hu, session, sent = stalled(identity, True)
   session.check_progress(now=sent + ProjectionSession.ACK_TIMEOUT + 0.05)
-  session.radio_change = lambda: None  # same stall: the decision was made when it began
+  session.radio_change = lambda: False  # same stall: the decision was made when it began
   session.check_progress(now=sent + ProjectionSession.ACK_GRACE_TIMEOUT - 0.1)
   end_session(session, hu)
 
 
 def test_acks_resuming_during_the_grace_keep_the_session_and_log_the_gap(identity):
-  hu, session, sent = stalled(identity, "Home")
+  hu, session, sent = stalled(identity, True)
   events = []
   session.event = lambda name, **fields: events.append((name, fields))
   session.check_progress(now=sent + ProjectionSession.ACK_TIMEOUT + 0.05)
@@ -66,7 +65,7 @@ def test_acks_resuming_during_the_grace_keep_the_session_and_log_the_gap(identit
 
 
 def test_car_taking_its_screen_back_during_the_grace_reconnects(identity):
-  hu, session, sent = stalled(identity, "Home")
+  hu, session, sent = stalled(identity, True)
   session.check_progress(now=sent + ProjectionSession.ACK_TIMEOUT + 0.05)
   hu.set_focus(False)
   pump_until(session, lambda: not session.focused)
@@ -84,64 +83,35 @@ def test_unfocus_outside_a_grace_is_the_normal_reverse_camera(identity):
   end_session(session, hu)
 
 
-def home(interface):
-  return "Huckleberrys House"
-
-
-def test_watch_reports_a_carrier_change_with_the_network_name(tmp_path, monkeypatch):
+def test_watch_reports_a_carrier_change_without_naming_the_network(tmp_path):
   counter = tmp_path / "carrier_changes"
   counter.write_text("4\n")
   logged = []
-  watch = SharedRadioWatch(lambda name, **fields: logged.append((name, fields)), interval=0.01, counter=counter, name=home).start()
+  watch = SharedRadioWatch(lambda name, **fields: logged.append((name, fields)), interval=0.01, counter=counter).start()
   try:
     time.sleep(0.05)
-    assert watch.recent() is None  # the starting value is not a change
+    assert not watch.recent()  # the starting value is not a change
     counter.write_text("5\n")
     deadline = time.monotonic() + 2
-    while watch.recent() != "Huckleberrys House":
+    while not watch.recent():
       assert time.monotonic() < deadline
       time.sleep(0.01)
-    assert logged == [("other_wifi_changed", {"interface": "wlan0", "network": "Huckleberrys House"})]
+    assert logged == [("other_wifi_changed", {"interface": "wlan0"})]
     assert watch.changed_at is not None
-    assert watch.recent(now=watch.changed_at + supervisor_module.RADIO_CHANGE_WINDOW + 0.1) is None
+    assert not watch.recent(now=watch.changed_at + supervisor_module.RADIO_CHANGE_WINDOW + 0.1)
   finally:
     watch.stop()
 
 
 def test_watch_without_the_counter_never_reports(tmp_path):
-  watch = SharedRadioWatch(lambda *a, **k: None, interval=0.01, counter=tmp_path / "missing", name=home).start()
+  watch = SharedRadioWatch(lambda *a, **k: None, interval=0.01, counter=tmp_path / "missing").start()
   try:
     time.sleep(0.05)
-    assert watch.recent() is None
+    assert not watch.recent()
   finally:
     watch.stop()
 
 
-def test_name_lookup_failure_still_counts_the_change(tmp_path):
-  def broken(interface):
-    raise RuntimeError("NetworkManager timed out")
-
-  counter = tmp_path / "carrier_changes"
-  counter.write_text("1")
-  watch = SharedRadioWatch(lambda *a, **k: None, interval=0.01, counter=counter, name=broken).start()
-  try:
-    counter.write_text("2")
-    deadline = time.monotonic() + 2
-    while watch.recent() is None:
-      assert time.monotonic() < deadline
-      time.sleep(0.01)
-    assert watch.recent() == ""
-  finally:
-    watch.stop()
-
-
-def test_notice_text_is_short_and_plain():
-  assert reconnect_notice.shared_radio_text("Huckleberrys House") == "Reconnected: comma Wi-Fi Joined Huckleberrys House"
-  assert reconnect_notice.shared_radio_text("") == "Reconnected: comma Wi-Fi Was Switching Networks"
-  long = reconnect_notice.shared_radio_text("A" * 60)
-  assert long.endswith("...") and len(long) <= len("Reconnected: comma Wi-Fi Joined ") + reconnect_notice.NAME_MAX
-
-
 def test_notice_is_shown_once_and_only_while_fresh(tmp_path):
   path = tmp_path / "notice.json"
   reconnect_notice.write("Reconnected", path, now=1000.0)
@@ -153,15 +123,7 @@ def test_notice_is_shown_once_and_only_while_fresh(tmp_path):
 
 
 def test_galaxy_status_says_what_happened():
-  text = Supervisor._describe_error("streaming", SharedRadioStall("stalled", "Huckleberrys House"))
-  assert text == "The car's Wi-Fi stalled while the comma's own Wi-Fi joined Huckleberrys House; reconnecting"
-  assert "switching networks" in Supervisor._describe_error("streaming", SharedRadioStall("stalled", ""))
+  text = Supervisor._describe_error("streaming", SharedRadioStall("stalled"))
+  assert text == "The car's Wi-Fi stalled while the comma's own Wi-Fi was switching networks; reconnecting"
   assert stream_loss_kind(text) == "shared_radio"  # bug reports file it apart from ordinary stalls
   assert stream_loss_kind("projecting: Video acknowledgement older than 2.5 s") == "stalled"
-
-
-
-def test_saved_profile_names_become_the_network_name():
-  from openpilot.starpilot.system.starport.network import profile_network_name
-  assert profile_network_name("openpilot connection Huckleberrys House") == "Huckleberrys House"
-  assert profile_network_name("iPhone") == "iPhone"

From 63b05a9294c5eeecacb7df19396ccd1d62daa85b Mon Sep 17 00:00:00 2001
From: Danny <dannyirwin31@yahoo.com>
Date: Mon, 2 Nov 2026 19:36:36 -0800
Subject: [PATCH 34/38] Fix test for AA wireless

---
 openpilot/starpilot/system/starport/tests/test_car_profiles.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/openpilot/starpilot/system/starport/tests/test_car_profiles.py b/openpilot/starpilot/system/starport/tests/test_car_profiles.py
index 68183cab20..853f7cbcaa 100644
--- a/openpilot/starpilot/system/starport/tests/test_car_profiles.py
+++ b/openpilot/starpilot/system/starport/tests/test_car_profiles.py
@@ -40,7 +40,7 @@ def test_aawireless_tuning_applies_only_when_chosen():
   chosen = config(car_profile_override="aawireless", receiver_name="AAWireless-4F2A")
   assert car_profiles.resolve(chosen) == ("aawireless", "override")
   assert car_profiles.tuning(chosen) == {"connect_delay_s": 0.0, "max_window": 30, "phone_services": True, "phone_frames": True,
-                                          "bootstrap_experiments": False}
+                                          "bootstrap_experiments": False, "stay_while_projecting": True}
   assert car_profiles.summary(chosen)["car_profile_label"] == "AAWireless"
   for other in (config(receiver_name="AAWireless-4F2A"), config(car_profile_override="default")):
     assert car_profiles.tuning(other) == car_profiles.DEFAULTS

From 7d7bf43fac8806892952a9260cbd77bfd10ce752 Mon Sep 17 00:00:00 2001
From: Danny <dannyirwin31@yahoo.com>
Date: Mon, 2 Nov 2026 19:46:18 -0800
Subject: [PATCH 35/38] Account for Starport on Dev Page

---
 .../starpilot/galaxy/tests/test_offroad_configuration_pages.py  | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/openpilot/starpilot/galaxy/tests/test_offroad_configuration_pages.py b/openpilot/starpilot/galaxy/tests/test_offroad_configuration_pages.py
index 675b9f05ca..ae1d399af0 100644
--- a/openpilot/starpilot/galaxy/tests/test_offroad_configuration_pages.py
+++ b/openpilot/starpilot/galaxy/tests/test_offroad_configuration_pages.py
@@ -57,6 +57,8 @@ class TestOffroadConfigurationPages(unittest.TestCase):
             current = self.editable_inventory(self.page(name))
             expected = saved[name]
             if name == 'developer':
+              # gated by Park, not by the vehicle
+              expected, current = ([row for row in rows if row[0] != 'StarPort: New pairing experience'] for rows in (expected, current))
               self.assertEqual([row[0] for row in expected], ['Use VOACC'])
               self.assertEqual([row[1] for row in expected], [False])
               self.assertEqual([row[1] for row in current], [True])

From 755d82a7e6c8fa63b46f0f705ee4ff8192249875 Mon Sep 17 00:00:00 2001
From: Danny <dannyirwin31@yahoo.com>
Date: Mon, 2 Nov 2026 19:55:13 -0800
Subject: [PATCH 36/38] UI Unification

---
 .../starpilot/galaxy/developer_settings.py    |  6 +++---
 .../tests/test_offroad_configuration_pages.py |  2 +-
 .../starpilot/galaxy/tests/test_settings.mjs  | 11 +++++++++++
 openpilot/starpilot/galaxy/web/js/settings.js | 19 ++++++++++++++-----
 4 files changed, 29 insertions(+), 9 deletions(-)

diff --git a/openpilot/starpilot/galaxy/developer_settings.py b/openpilot/starpilot/galaxy/developer_settings.py
index a04fa617db..b53004c5d4 100644
--- a/openpilot/starpilot/galaxy/developer_settings.py
+++ b/openpilot/starpilot/galaxy/developer_settings.py
@@ -55,15 +55,15 @@ class DeveloperSettingsOwner:
     new_setup_on = new_setup.enabled()
     held = "Park the vehicle to change this setting."
     rows = [FeatureRow(STARPORT_HEADING_KEY, "StarPort", "", available=False),
-            FeatureRow(STARPORT_NEW_SETUP_KEY, "StarPort: New pairing experience", "On" if new_setup_on else "Off",
+            FeatureRow(STARPORT_NEW_SETUP_KEY, "New pairing experience", "On" if new_setup_on else "Off",
                        b"1" if new_setup_on else b"0", ("Off", "On"), available=parked,
                        reason=STARPORT_NEW_SETUP_DESCRIPTION if parked else held, default_value="On")]
     status = self._starport_status()
     if status is not None:
       enabled, hevc = bool(status.get("dedicated_wifi_interface")), bool(status.get("allow_hevc"))
-      rows.append(FeatureRow(STARPORT_WIFI_KEY, "StarPort: Stay on Wi-Fi", "On" if enabled else "Off", b"1" if enabled else b"0",
+      rows.append(FeatureRow(STARPORT_WIFI_KEY, "Stay on Wi-Fi", "On" if enabled else "Off", b"1" if enabled else b"0",
                              ("Off", "On"), available=parked, reason=STARPORT_WIFI_DESCRIPTION if parked else held, default_value="On"))
-      rows.append(FeatureRow(STARPORT_HEVC_KEY, "StarPort: Allow H.265 video", "On" if hevc else "Off", b"1" if hevc else b"0",
+      rows.append(FeatureRow(STARPORT_HEVC_KEY, "Allow H.265 video", "On" if hevc else "Off", b"1" if hevc else b"0",
                              ("Off", "On"), available=parked, reason=STARPORT_HEVC_DESCRIPTION if parked else held, default_value="Off"))
     return tuple(rows)
 
diff --git a/openpilot/starpilot/galaxy/tests/test_offroad_configuration_pages.py b/openpilot/starpilot/galaxy/tests/test_offroad_configuration_pages.py
index ae1d399af0..ca748938c6 100644
--- a/openpilot/starpilot/galaxy/tests/test_offroad_configuration_pages.py
+++ b/openpilot/starpilot/galaxy/tests/test_offroad_configuration_pages.py
@@ -58,7 +58,7 @@ class TestOffroadConfigurationPages(unittest.TestCase):
             expected = saved[name]
             if name == 'developer':
               # gated by Park, not by the vehicle
-              expected, current = ([row for row in rows if row[0] != 'StarPort: New pairing experience'] for rows in (expected, current))
+              expected, current = ([row for row in rows if row[0] != 'New pairing experience'] for rows in (expected, current))
               self.assertEqual([row[0] for row in expected], ['Use VOACC'])
               self.assertEqual([row[1] for row in expected], [False])
               self.assertEqual([row[1] for row in current], [True])
diff --git a/openpilot/starpilot/galaxy/tests/test_settings.mjs b/openpilot/starpilot/galaxy/tests/test_settings.mjs
index c76112702c..889073a827 100644
--- a/openpilot/starpilot/galaxy/tests/test_settings.mjs
+++ b/openpilot/starpilot/galaxy/tests/test_settings.mjs
@@ -160,6 +160,17 @@ const filtered = SettingsPage.computed.visibleRows.call({ state: { query: "lane"
 ] } } })
 assert.deepEqual(filtered.map(({ index }) => index), [1]) // Filter keeps the original owner row index.
 
+const developerRows = [{ label: "Use VOACC", value: "Off", reason: "" }, { label: "StarPort", value: "", reason: "", heading: true },
+  { label: "Stay on Wi-Fi", value: "On", reason: "" }, { label: "Allow H.265 video", value: "Off", reason: "" }]
+const cardsFor = (query) => {
+  const view = { state: { query, data: { rows: developerRows } }, initialPage: "developer", activeSection: {} }
+  view.visibleRows = SettingsPage.computed.visibleRows.call(view)
+  return SettingsPage.computed.rowCards.call(view).map(({ title, entries }) => [title, entries.map(({ index }) => index)])
+}
+assert.deepEqual(cardsFor(""), [["", [0]], ["StarPort", [2, 3]]], "a heading row starts its own card")
+assert.deepEqual(cardsFor("h.265"), [["", []], ["StarPort", [3]]], "search keeps a row in its card when the heading is filtered out")
+assert.deepEqual(cardsFor("voacc"), [["", [0]]], "an emptied card is not shown")
+
 const conditional = fixture()
 conditional.feed.start()
 await conditional.reply(0, { ...lane, page: "hub", rows: [{ label: "Conditional driving modes", page: "conditional",
diff --git a/openpilot/starpilot/galaxy/web/js/settings.js b/openpilot/starpilot/galaxy/web/js/settings.js
index 1758a4189d..3c0577c9e7 100644
--- a/openpilot/starpilot/galaxy/web/js/settings.js
+++ b/openpilot/starpilot/galaxy/web/js/settings.js
@@ -304,6 +304,14 @@ export const SettingsPage = {
       }).filter(({ row }) =>
         !needle || `${row.label} ${row.value} ${row.reason}`.toLocaleLowerCase().includes(needle))
     },
+    // A heading row starts its own card; the rows after it belong to that card even when search hides the heading.
+    rowCards() {
+      const titles = []
+      const owner = (this.state.data?.rows || []).map((row) => (row.heading ? titles.push(row.label) : titles.length))
+      const cards = [{ title: "", entries: [] }, ...titles.map((title) => ({ title, entries: [] }))]
+      for (const entry of this.visibleRows) if (!entry.row.heading) cards[owner[entry.index] || 0].entries.push(entry)
+      return cards.filter((card, index) => !index || card.entries.length)
+    },
   },
   watch: {
     "state.pending"() { this.flushSoundChoices() },
@@ -449,15 +457,16 @@ export const SettingsPage = {
             <div v-if="state.data.page === 'pip'" class="gx-settings__actions gx-actions">
               <button type="button" class="gx-btn gx-btn--tonal" @click="openCropEditor"><i class="bi bi-crop" aria-hidden="true"></i> Crop editor</button>
             </div>
-            <section class="gx-card gx-settings__section">
-              <div class="gx-section__header"><i class="bi" :class="activeSection.icon" aria-hidden="true"></i><span class="gx-section__title">{{ state.data.page === 'hub' ? activeSection.label : state.data.title }}</span>
+            <section v-for="(card, cardIndex) in rowCards" :key="card.title || 'main'" class="gx-card gx-settings__section">
+              <div v-if="cardIndex" class="gx-section__header"><i class="bi bi-car-front" aria-hidden="true"></i><span class="gx-section__title">{{ card.title }}</span></div>
+              <div v-else class="gx-section__header"><i class="bi" :class="activeSection.icon" aria-hidden="true"></i><span class="gx-section__title">{{ state.data.page === 'hub' ? activeSection.label : state.data.title }}</span>
                 <button v-if="state.data.page !== 'hub' && state.data.rows.length" type="button" class="gx-icon-btn" :aria-label="state.searchOpen ? 'Close page search' : 'Search within this page'" :aria-pressed="state.searchOpen" @click="togglePageSearch"><i class="bi" :class="state.searchOpen ? 'bi-x-lg' : 'bi-search'" aria-hidden="true"></i></button>
                 </div>
-              <div v-if="state.searchOpen" class="gx-settings__search"><input ref="pageSearch" v-model="state.query" class="gx-field" type="search" aria-label="Search within this page" placeholder="Search within…"></div>
-              <GalaxySettingRow v-for="{ row, index } in visibleRows" :key="rowKey(row, index)" :row="row" :index="index"
+              <div v-if="state.searchOpen && !cardIndex" class="gx-settings__search"><input ref="pageSearch" v-model="state.query" class="gx-field" type="search" aria-label="Search within this page" placeholder="Search within…"></div>
+              <GalaxySettingRow v-for="{ row, index } in card.entries" :key="rowKey(row, index)" :row="row" :index="index"
                 :busy="busy" :disabled="!!state.error || !row.available" :save-value="(index, value) => feed.previewValue(index, value)"
                 @open="open" @review="(index, direction) => feed.preview(index, direction)" @reset-default="index => feed.resetDefault(index)" />
-              <div v-if="!visibleRows.length" class="gx-empty">No matching settings.</div>
+              <div v-if="!cardIndex && !visibleRows.length" class="gx-empty">No matching settings.</div>
             </section>
             <SoundPacks v-if="state.data.page === 'sounds'" :unauthorized="unauthorized" :busy="busy" @installed="refreshSoundChoices" />
           </div>

From f14877078800502f6f47c2f2ae40eade57eed3ff Mon Sep 17 00:00:00 2001
From: Danny <dannyirwin31@yahoo.com>
Date: Tue, 3 Nov 2026 05:39:55 -0800
Subject: [PATCH 37/38] Build

---
 prebuilt.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/prebuilt.json b/prebuilt.json
index cce9326842..8fa6dda812 100644
--- a/prebuilt.json
+++ b/prebuilt.json
@@ -1 +1 @@
-{"protected_inventory_sha256": "9653f67cf25c7e37488533864943c5949cca94b4c7dadbe1ad1af400eb36d88d", "schema_version": 1}
+{"protected_inventory_sha256": "961bf9ce9ca0fde2fd0166cfe5379af2f29fd8b93a50102a1f66793e345b55cb", "schema_version": 1}

From 123e3c20a0c85b3c6dfc390e9bf9e123d542b8f8 Mon Sep 17 00:00:00 2001
From: Prabhaav Pillai <prabhaav@msu.edu>
Date: Tue, 3 Nov 2026 10:57:52 -0500
Subject: [PATCH 38/38] StarPort setup, reconnect handling, and UI consistency

---
 openpilot/starpilot/galaxy/README.md          |   2 +
 .../starpilot/galaxy/developer_settings.py    |  33 +---
 openpilot/starpilot/galaxy/starport_send.py   |  13 +-
 .../starpilot/galaxy/tests/test_starport.mjs  |   2 +
 .../galaxy/tests/test_starport_send.mjs       |  30 ++-
 .../galaxy/tests/test_starport_send.py        |   2 +
 openpilot/starpilot/galaxy/web/css/galaxy.css | 179 ++++--------------
 .../galaxy/web/js/starport-guided.js          |  35 ++--
 .../starpilot/galaxy/web/js/starport-logs.js  |  29 ++-
 openpilot/starpilot/galaxy/web/js/starport.js |   8 +-
 .../starpilot/system/starport/identity.py     |   8 +
 .../starpilot/system/starport/network.py      |   9 +-
 .../starpilot/system/starport/new_setup.py    |   6 +-
 .../starpilot/system/starport/protocol.py     |  12 +-
 .../starpilot/system/starport/reachability.py |   9 +-
 .../system/starport/reconnect_notice.py       |   5 +-
 .../starpilot/system/starport/setup_ladder.py |  24 +--
 .../starpilot/system/starport/supervisor.py   |  12 +-
 .../tests/test_companion_bluetooth.py         |   3 +
 .../system/starport/tests/test_forget_car.py  |  17 ++
 .../starport/tests/test_setup_ladder.py       |  28 +++
 .../starport/tests/test_shared_radio_grace.py |   8 +
 .../system/starport/tests/test_stray_link.py  |  18 ++
 23 files changed, 234 insertions(+), 258 deletions(-)

diff --git a/openpilot/starpilot/galaxy/README.md b/openpilot/starpilot/galaxy/README.md
index d7f4a9e17d..6ed226e277 100644
--- a/openpilot/starpilot/galaxy/README.md
+++ b/openpilot/starpilot/galaxy/README.md
@@ -31,6 +31,8 @@ Browser JavaScript tests use Node 24; set `STARPILOT_NODE` to an existing Node
 24 executable when needed. A static preview can serve `web/` over loopback;
 it labels its sample System Monitor data and cannot edit a device.
 
+StarPort log uploads use the built-in developer Discord webhook.
+
 ## Pages and owners
 
 | Page | Current source and operations |
diff --git a/openpilot/starpilot/galaxy/developer_settings.py b/openpilot/starpilot/galaxy/developer_settings.py
index b53004c5d4..4a72605247 100644
--- a/openpilot/starpilot/galaxy/developer_settings.py
+++ b/openpilot/starpilot/galaxy/developer_settings.py
@@ -42,14 +42,6 @@ class DeveloperSettingsOwner:
     except (OSError, RuntimeError, ValueError, KeyError, TypeError):
       return None  # the service is off; there is nothing to configure
 
-  def _starport_enabled(self):
-    status = self._starport_status()
-    return None if status is None else bool(status.get("dedicated_wifi_interface"))
-
-  def _starport_hevc(self):
-    status = self._starport_status()
-    return None if status is None else bool(status.get("allow_hevc"))
-
   def _starport_rows(self, parked):
     """The StarPort section. The switch back to classic setup is always listed; the daemon's settings only while it runs."""
     new_setup_on = new_setup.enabled()
@@ -125,9 +117,9 @@ class DeveloperSettingsOwner:
     if request.key == "IgnoreIgnitionLine":
       return self.panda_wake is not None and self.panda_wake.apply(request)
     if request.key == STARPORT_WIFI_KEY:
-      return self._apply_starport(request)
+      return self._apply_starport(request, "dedicated_wifi_interface", "set_dedicated_wifi")
     if request.key == STARPORT_HEVC_KEY:
-      return self._apply_hevc(request)
+      return self._apply_starport(request, "allow_hevc", "set_allow_hevc")
     if request.key == STARPORT_NEW_SETUP_KEY:
       return self._apply_new_setup(request)
     if request.key != KEY or request.value not in ("Off", "On") or request.expected not in (None, b"0", b"1"):
@@ -136,27 +128,18 @@ class DeveloperSettingsOwner:
                           expected=request.expected, authorized=self.authorized, temp_prefix=".voacc-")
     return result.committed and result.verified
 
-  def _apply_starport(self, request):
-    enabled, client = self._starport_enabled(), self.starport
+  def _apply_starport(self, request, field, command):
+    status, client = self._starport_status(), self.starport
+    enabled = None if status is None else bool(status.get(field))
     if (enabled is None or client is None or request.value not in ("Off", "On") or request.expected != (b"1" if enabled else b"0") or
         not self.authorized()):
       return False
     try:
-      client().call("set_dedicated_wifi", enabled=request.value == "On")
+      client().call(command, enabled=request.value == "On")
     except (OSError, RuntimeError, ValueError):
       return False
-    return self._starport_enabled() == (request.value == "On")
-
-  def _apply_hevc(self, request):
-    enabled, client = self._starport_hevc(), self.starport
-    if (enabled is None or client is None or request.value not in ("Off", "On") or request.expected != (b"1" if enabled else b"0") or
-        not self.authorized()):
-      return False
-    try:
-      client().call("set_allow_hevc", enabled=request.value == "On")
-    except (OSError, RuntimeError, ValueError):
-      return False
-    return self._starport_hevc() == (request.value == "On")
+    status = self._starport_status()
+    return status is not None and bool(status.get(field)) == (request.value == "On")
 
   def _apply_new_setup(self, request):
     current = new_setup.enabled()
diff --git a/openpilot/starpilot/galaxy/starport_send.py b/openpilot/starpilot/galaxy/starport_send.py
index 91e668a32c..e0e3989584 100644
--- a/openpilot/starpilot/galaxy/starport_send.py
+++ b/openpilot/starpilot/galaxy/starport_send.py
@@ -1,10 +1,4 @@
-"""Send StarPort Logs: post the "Download all logs" zip to the developer's Discord, from Logs & Diagnostics.
-
-Only sent when the user presses Send; there are no automatic reports. Each device gets its own forum
-thread, titled with its car and a short hashed device tag, and later sends from the same device go to
-that thread. The webhook URL is built in, encoded so repository scanners don't pick it up; a URL in
-WEBHOOK_OVERRIDE_PATH on the device replaces it without a code change.
-"""
+"""Upload logs on request to Discord, reusing a thread per device."""
 
 from __future__ import annotations
 
@@ -24,8 +18,7 @@ from openpilot.starpilot.system.starport import identity as identity_store
 MESSAGE_LIMIT = 60
 WEBHOOK_OVERRIDE_PATH = identity_store.DATA_DIR / "webhook_url"
 THREAD_DIR = identity_store.DATA_DIR / "discord_threads"
-# The Discord webhook URL that receives StarPort logs, XORed with _WEBHOOK_KEY and base64-encoded so it is not
-# stored in plain text ("" = sending not set up). Obfuscation only: the device has to be able to decode it.
+# Obfuscation only; device-local configuration overrides this built-in webhook.
 _WEBHOOK_KEY = b"starport-logs"
 _WEBHOOK_DATA = "".join(("GwAVAgNVXVtJBRwEHAEQTxEfAl0VXQVAEBYRHA4dGxxdRRhaWlJLREBYRkZcS0UcXl1QQVwAEEIzAydBSA",
                          "4KIjQjDShfJj0ZRkA6OjEbMi4JRzE6Rh1sOxo/HCVCDRMlCzRBHyIhUgQFTDAfChwdAGkpWR0HES0ZJw=="))
@@ -45,7 +38,7 @@ class SendBusy(Exception):
 def webhook_url(override_path: Path = WEBHOOK_OVERRIDE_PATH) -> str:
   try:
     override = override_path.read_text().strip()
-  except OSError:
+  except (OSError, UnicodeError):
     override = ""
   if override:
     return override
diff --git a/openpilot/starpilot/galaxy/tests/test_starport.mjs b/openpilot/starpilot/galaxy/tests/test_starport.mjs
index a29a6b9c7b..3158856246 100644
--- a/openpilot/starpilot/galaxy/tests/test_starport.mjs
+++ b/openpilot/starpilot/galaxy/tests/test_starport.mjs
@@ -19,6 +19,8 @@ assert.equal(validPromptInput({ kind: "passkey" }, "1234567"), false)
 assert.equal(validPromptInput(prompt, ""), true)
 assert.match(StarPortPage.template, /Check that this code matches your/)
 assert.match(StarPortPage.template, /Cancel Search \/ Pairing/)
+assert.equal(StarPortPage.computed.deviceChosen.call({ pairing: { ...pairing, state: "pairing" } }), true)
+assert.equal(StarPortPage.computed.deviceChosen.call({ pairing: { ...pairing, state: "failed" } }), false)
 assert.doesNotMatch(StarPortPage.template, /:row="wiredRow"/)
 assert.match(StarPortPage.template, /Read the Android Auto troubleshooting guide/)
 assert.doesNotMatch(StarPortPage.template, /v-html|autoaccept/i)
diff --git a/openpilot/starpilot/galaxy/tests/test_starport_send.mjs b/openpilot/starpilot/galaxy/tests/test_starport_send.mjs
index 91175e7446..022fd70f34 100644
--- a/openpilot/starpilot/galaxy/tests/test_starport_send.mjs
+++ b/openpilot/starpilot/galaxy/tests/test_starport_send.mjs
@@ -6,7 +6,7 @@ function fixture() {
   const requests = [], states = [], timers = []
   let unauthorized = 0
   const client = new StarPortLogSend({ publish: (state) => states.push(state), unauthorized: () => { unauthorized++ },
-    fetcher: (url, options) => new Promise((resolve) => requests.push({ url, options, resolve })),
+    fetcher: (url, options) => new Promise((resolve, reject) => requests.push({ url, options, resolve, reject })),
     schedule: (fn) => { timers.push(fn); return timers.length }, cancel: () => {} })
   const reply = async (index, body, status = 200) => {
     requests[index].resolve({ ok: status >= 200 && status < 300, status, json: async () => body })
@@ -60,3 +60,31 @@ const unset = fixture()
 unset.client.start()
 await unset.reply(0, { state: "idle", available: false })
 assert.equal(unset.states.at(-1).available, false)
+
+// A lost Bluetooth response retries the status read without repeating the upload.
+const interrupted = fixture()
+interrupted.client.start()
+await interrupted.reply(0, { state: "sending" })
+interrupted.timers[0]()
+interrupted.requests[1].reject(new TypeError("Connection lost"))
+await flush()
+assert.equal(interrupted.timers.length, 2)
+interrupted.timers[1]()
+await interrupted.reply(2, { state: "sent", message: "Logs sent" })
+assert.equal(interrupted.states.at(-1).state, "sent")
+assert.ok(interrupted.requests.every(({ options }) => options.method !== "POST"))
+
+// An older status read cannot replace a send's newer status, even across navigation.
+const stale = fixture()
+stale.client.start()
+const pendingSend = stale.client.send("hello")
+await stale.reply(1, { state: "sending" }, 202)
+assert.equal(await pendingSend, true)
+await stale.reply(0, { state: "idle" })
+assert.equal(stale.states.at(-1).state, "sending")
+stale.client.start()
+stale.client.start()
+await stale.reply(2, {}, 401)
+assert.equal(stale.unauthorized, 0)
+await stale.reply(3, { state: "sent" })
+assert.equal(stale.states.at(-1).state, "sent")
diff --git a/openpilot/starpilot/galaxy/tests/test_starport_send.py b/openpilot/starpilot/galaxy/tests/test_starport_send.py
index 59e086efee..05ff97987f 100644
--- a/openpilot/starpilot/galaxy/tests/test_starport_send.py
+++ b/openpilot/starpilot/galaxy/tests/test_starport_send.py
@@ -106,6 +106,8 @@ class SendTest(unittest.TestCase):
     override = self.threads / "webhook_url"
     override.write_text(f"{URL}\n")
     self.assertEqual(starport_send.webhook_url(override), URL)
+    override.write_text("")
+    self.assertEqual(starport_send.webhook_url(override), starport_send.webhook_url(self.threads / "absent"))
 
 
 class SenderJobTest(unittest.TestCase):
diff --git a/openpilot/starpilot/galaxy/web/css/galaxy.css b/openpilot/starpilot/galaxy/web/css/galaxy.css
index a995d57cdd..015b696191 100644
--- a/openpilot/starpilot/galaxy/web/css/galaxy.css
+++ b/openpilot/starpilot/galaxy/web/css/galaxy.css
@@ -1712,7 +1712,7 @@ input[type="checkbox"]:disabled { opacity: .4; cursor: not-allowed; }
 .gx-text-danger { color: var(--error); }
 .gx-row.gx-row--borderless { border-top: 0; }
 /* A section title inside a settings page: a label only, never dimmed like an unavailable control. */
-.gx-row.gx-row--heading, .gx-row.gx-row--heading.disabled { opacity: 1; padding-top: 1.25rem; }
+.gx-row.gx-row--heading, .gx-row.gx-row--heading.disabled { opacity: 1; padding-top: var(--sp-5); }
 .gx-row--heading .gx-row__label { font-weight: 700; letter-spacing: .04em; text-transform: uppercase; opacity: .75; }
 .gx-row--wrap { flex-wrap: wrap; }
 .gx-row__info.gx-row__info--wide { flex: 1 1 180px; }
@@ -2002,152 +2002,51 @@ progress { max-width: 100%; accent-color: var(--primary); }
   .gx-tuner__diagnostics dd { margin-bottom: 12px; }
 }
 
-/* Guided StarPort setup. Apple-style geometry and type on Galaxy's own colors, spacing, radii and motion tokens, so light and dark
-   both follow the theme. Rows, lists, pills, the disclosure and the prompt are the page's existing .gx-starport-* components,
-   restyled here; only the step track, icon tiles, radio rows, segmented control and checklist marks are new. */
-.gx-card.gx-guided {
-  --g-ink: var(--on-surface);
-  --g-muted: var(--on-surface-variant);
-  --g-fill: color-mix(in srgb, var(--on-surface) 7%, transparent);
-  --g-fill-hover: color-mix(in srgb, var(--on-surface) 11%, transparent);
-  --g-line: color-mix(in srgb, var(--on-surface) 11%, transparent);
-  --g-track: color-mix(in srgb, var(--on-surface) 16%, var(--background));  /* opaque, so overlapping segments never show a seam */
-  --g-accent: var(--primary);
-  --g-done: var(--success);
-  display: grid; gap: var(--sp-5); padding: 28px 28px var(--sp-5); border-radius: var(--radius-lg); margin-block: var(--sp-4);
-  font-family: var(--font-body);
-  font-size: 16px; line-height: 1.4; color: var(--g-ink); -webkit-font-smoothing: antialiased;
-  background-image: radial-gradient(120% 38% at 50% 0, var(--primary-container), transparent 72%);   /* a soft purple wash behind the steps */
-}
-
-/* The step track: three numbered nodes on a line that fills as the setup moves along. */
+/* Guided setup layout and emphasis; shared rows, buttons, fields and notices keep Galaxy defaults. */
+.gx-card.gx-guided { display: grid; gap: var(--sp-5); padding: var(--panel-padding); background-image: radial-gradient(120% 38% at 50% 0, var(--primary-container), transparent 72%); }
 .gx-guided__steps { list-style: none; margin: 0; padding: 0; display: grid; grid-template-columns: repeat(3, 1fr); }
 .gx-guided__step { position: relative; display: grid; justify-items: center; gap: var(--sp-2); text-align: center; }
-.gx-guided__step::before, .gx-guided__step::after { content: ""; position: absolute; top: 15px; height: 2px; width: calc(50% - 8px); background: var(--g-track); }
+.gx-guided__step::before, .gx-guided__step::after { content: ""; position: absolute; top: 15px; height: 2px; width: calc(50% - 8px); background: var(--outline); }
 .gx-guided__step::before { left: 0; }
 .gx-guided__step::after { right: 0; }
 .gx-guided__step:first-child::before, .gx-guided__step:last-child::after { display: none; }
 .gx-guided__step.is-done::before, .gx-guided__step.is-done::after, .gx-guided__step.is-current::before,
-.gx-guided__step.is-done + .gx-guided__step::before { background: var(--g-done); }
-.gx-guided__node {
-  position: relative; z-index: 1; display: grid; place-items: center; width: 32px; height: 32px; border-radius: var(--radius-full);
-  font-size: 15px; font-weight: var(--fw-bold); font-variant-numeric: tabular-nums; background: var(--g-fill); color: var(--g-muted);
-  transition: background var(--motion-base), color var(--motion-base), box-shadow var(--motion-base);
-}
-.gx-guided__step.is-current .gx-guided__node { background: var(--g-accent); color: var(--on-primary); box-shadow: 0 0 0 5px color-mix(in srgb, var(--g-accent) 28%, transparent), 0 4px 16px var(--primary-glow); }
-.gx-guided__step.is-done .gx-guided__node { background: var(--g-done); color: var(--background); animation: gx-guided-pop var(--motion-slow); }
-.gx-guided__step-label { font-size: 13px; font-weight: var(--fw-bold); color: var(--g-muted); }
-.gx-guided__step.is-current .gx-guided__step-label { color: var(--g-ink); }
-@keyframes gx-guided-pop { 0% { transform: scale(.7); } 60% { transform: scale(1.12); } 100% { transform: scale(1); } }
-
-.gx-guided__header { display: grid; gap: 6px; max-width: 34rem; }
-.gx-guided__title { margin: 0; font-size: 30px; line-height: 1.12; font-weight: var(--fw-bold); letter-spacing: -.02em; text-wrap: balance; }
-.gx-guided__lede { margin: 0; font-size: 17px; line-height: 1.45; color: var(--g-muted); text-wrap: pretty; }
-.gx-guided__section { display: grid; gap: 10px; }
-.gx-guided__subhead { margin: 0 0 0 var(--sp-1); font-size: 15px; font-weight: var(--fw-bold); color: var(--g-muted); }
-.gx-guided__hint { margin: 0 var(--sp-1); font-size: 14px; color: var(--g-muted); }
-
-/* Inset grouped lists, as in iOS Settings: the page's .gx-starport-list and .gx-starport-row, restyled once, here, for the pairing
-   content and the card's own lists alike. --g-inset is where the hairline between rows starts (after the icon). */
-.gx-guided .gx-starport-list { --g-inset: 54px; background: var(--g-fill); border: 0; border-radius: var(--radius-md); box-shadow: none; }
-.gx-guided .gx-starport-list > li { position: relative; }
-.gx-guided .gx-starport-list > li + li::before { content: ""; position: absolute; top: 0; left: var(--g-inset); right: 0; height: 1px; background: var(--g-line); }
-.gx-guided .gx-starport-list > .gx-starport-row + .gx-starport-row { border-top: 0; }
-.gx-guided .gx-starport-list .gx-starport-row { background: none; box-shadow: none; }
-.gx-guided .gx-starport-row { min-height: 56px; padding: 10px var(--sp-4); gap: 14px; border: 0; border-radius: 0; flex-wrap: nowrap; }
-.gx-guided .gx-starport-row__text { flex: 1 1 0; }
-.gx-guided .gx-starport-row__text strong { font-size: 16px; font-weight: var(--fw-bold); letter-spacing: -.01em; }
-.gx-guided .gx-starport-row__text small { font-size: 14px; line-height: 1.3; color: var(--g-muted); }
-.gx-guided .gx-starport-row > i { color: var(--g-muted); font-size: 20px; }
-.gx-guided .gx-starport-ok { color: var(--g-done); }
-.gx-guided .gx-starport-pill { border: 0; background: var(--g-fill-hover); color: var(--g-muted); font-size: 13px; font-weight: var(--fw-bold); }
-.gx-guided .gx-starport-pill--ready { background: color-mix(in srgb, var(--g-done) 20%, transparent); color: var(--g-done); }
-
-/* Connection options: a radio row with a colored icon tile, as in iOS Settings. */
-.gx-guided__options { --g-inset: 70px; }
-.gx-guided__options > li { display: block; }
-.gx-guided__option {
-  display: flex; align-items: center; gap: 14px; width: 100%; min-height: 60px; padding: 10px var(--sp-4); box-sizing: border-box;
-  background: none; border: 0; color: inherit; font: inherit; text-align: left; cursor: pointer; transition: background var(--motion-fast);
-}
-.gx-guided__option:hover:not(:disabled) { background: var(--g-fill-hover); }
-.gx-guided__option:active:not(:disabled) { background: var(--g-line); }
-.gx-guided__option:disabled { cursor: default; opacity: .6; }
-.gx-guided__option:focus-visible, .gx-guided__segmented button:focus-visible, .gx-guided__link:focus-visible {
-  outline: 3px solid color-mix(in srgb, var(--g-accent) 70%, transparent); outline-offset: -3px; border-radius: var(--radius-sm);
-}
-.gx-guided__tile { flex: none; display: grid; place-items: center; width: 40px; height: 40px; border-radius: 10px; background: var(--primary-container); color: var(--primary); font-size: 20px; }
-.gx-guided__cars { --g-inset: 70px; }
-.gx-guided__radio {
-  flex: none; display: grid; place-items: center; width: 24px; height: 24px; border-radius: var(--radius-full); font-size: 14px; color: transparent;
-  border: 1.5px solid color-mix(in srgb, var(--on-surface) 28%, transparent); transition: background var(--motion-base), border-color var(--motion-base);
-}
-.gx-guided__option[aria-checked="true"] { background: var(--primary-container); }
-.gx-guided__option[aria-checked="true"] .gx-guided__tile { background: var(--g-accent); color: var(--on-primary); box-shadow: 0 2px 10px var(--primary-glow); }
-.gx-guided__option[aria-checked="true"] .gx-guided__radio { background: var(--g-accent); border-color: var(--g-accent); color: var(--on-primary); }
-
-/* Segmented control for the adapter and app choices (Galaxy has none). */
-.gx-guided__segmented { display: flex; gap: 2px; padding: 3px; background: var(--g-fill); border-radius: var(--radius-sm); }
-.gx-guided__segmented button {
-  flex: 1; min-height: 44px; padding: 6px 8px; border: 0; border-radius: calc(var(--radius-sm) - 3px); background: none; color: var(--g-muted);
-  font: inherit; font-size: 15px; font-weight: var(--fw-medium); line-height: 1.2; text-wrap: balance; cursor: pointer;
-  transition: background var(--motion-base), color var(--motion-base), box-shadow var(--motion-base);
-}
-.gx-guided__segmented button.is-selected { background: var(--g-accent); color: var(--on-primary); box-shadow: 0 2px 12px var(--primary-glow); }
-.gx-guided__segmented button:not(.is-selected):hover:not(:disabled) { color: var(--g-ink); }
-.gx-guided__segmented button:disabled { opacity: .6; cursor: default; }
-
-/* Live checklist: the same rows, with a state mark where the icon goes. */
-.gx-guided__checklist { --g-inset: 58px; }
-.gx-guided__mark { flex: none; display: grid; place-items: center; width: 28px; font-size: 22px; color: color-mix(in srgb, var(--on-surface) 30%, transparent); }
-.gx-guided__spinner { width: 20px; height: 20px; }
-.gx-guided__checklist > li.is-done .gx-guided__mark, .gx-guided__checklist > li.is-worked .gx-guided__mark { color: var(--g-done); animation: gx-guided-pop var(--motion-slow); }
-.gx-guided__checklist > li.is-active .gx-guided__mark, .gx-guided__checklist > li.is-current .gx-guided__mark, .gx-guided__checklist > li.is-retry .gx-guided__mark { color: var(--g-accent); }
-.gx-guided__checklist > li.is-failed .gx-guided__mark { color: var(--error); }
-.gx-guided__checklist > li.is-waiting strong, .gx-guided__checklist > li.is-skipped strong { color: var(--g-muted); font-weight: 500; }
-
-.gx-guided__callout {
-  display: flex; align-items: center; justify-content: space-between; gap: 14px; flex-wrap: wrap; margin: 0; padding: 14px var(--sp-4);
-  border-radius: var(--radius-sm); background: color-mix(in srgb, var(--g-accent) 14%, transparent); font-size: 15px; line-height: 1.4;
-}
-.gx-guided__callout--quiet { background: var(--g-fill); color: var(--g-muted); display: block; }
-
-/* The page's own pairing, cable and app content arrives through the car slot; it takes the same look here. */
-.gx-guided__body { display: grid; gap: 14px; }
+.gx-guided__step.is-done + .gx-guided__step::before { background: var(--success); }
+.gx-guided__node { position: relative; display: grid; place-items: center; width: 32px; height: 32px; border-radius: var(--radius-full); background: var(--surface-container-high); color: var(--on-surface-variant); font-weight: var(--fw-bold); }
+.gx-guided__step.is-current .gx-guided__node { background: var(--primary); color: var(--on-primary); box-shadow: 0 0 0 var(--sp-1) var(--primary-container), 0 var(--sp-1) var(--sp-4) var(--primary-glow); }
+.gx-guided__step.is-done .gx-guided__node { background: var(--success); color: var(--background); }
+.gx-guided__step-label, .gx-guided__hint { font-size: var(--fs-sm); color: var(--on-surface-variant); }
+.gx-guided__header, .gx-guided__section, .gx-guided__body { display: grid; gap: var(--sp-3); min-width: 0; }
+.gx-guided__header > *, .gx-guided__subhead, .gx-guided__hint { margin: 0; }
+.gx-guided__header { max-width: 34rem; gap: var(--sp-2); }
+.gx-guided__title { font-size: clamp(1.625rem, 2.5vw, 1.875rem); line-height: 1.15; letter-spacing: -.02em; text-wrap: balance; }
+.gx-guided__lede { color: var(--on-surface-variant); font-size: var(--fs-base); line-height: 1.5; }
+.gx-guided__subhead { font-size: var(--fs-base); color: var(--on-surface-variant); }
 .gx-guided__body:empty { display: none; }
-.gx-guided .gx-note, .gx-guided .gx-notice, .gx-guided .gx-starport-guide { margin: 0; padding: 14px var(--sp-4); border: 0; border-radius: var(--radius-sm); background: var(--g-fill); font-size: 15px; line-height: 1.45; }
-.gx-guided .gx-starport-prompt { padding: 18px; border-radius: var(--radius-md); background: var(--g-fill); }
-.gx-guided .gx-starport-prompt__code { font-size: 34px; font-weight: var(--fw-bold); }
-.gx-guided .gx-starport-wiki { background: var(--g-fill); border: 0; border-radius: var(--radius-sm); padding: 0; overflow: hidden; color: var(--g-muted); }
-.gx-guided .gx-starport-wiki > summary { padding: 14px var(--sp-4); font-size: 15px; font-weight: var(--fw-medium); color: var(--g-ink); }
-.gx-guided .gx-starport-wiki > :not(summary) { margin-inline: var(--sp-4); font-size: 14px; line-height: 1.5; }
-.gx-guided .gx-starport-wiki > :last-child { margin-bottom: var(--sp-4); }
-.gx-guided .gx-starport-wiki > .gx-starport-list { margin-inline: 0; margin-top: 0; border-radius: 0; background: none; border-top: 1px solid var(--g-line); }
-.gx-guided .gx-field { min-height: 44px; border-radius: var(--radius-sm); }
-.gx-guided .gx-actions, .gx-guided .gx-driving__actions { display: flex; gap: 10px; flex-wrap: wrap; margin: 0; }
-.gx-guided .gx-row { background: var(--g-fill); border: 0; border-radius: var(--radius-md); padding: var(--sp-3) var(--sp-4); }
-
-/* Buttons: soft tonal, and a large primary. */
-.gx-guided .gx-btn { min-height: 44px; border-radius: var(--radius-sm); font-size: 16px; font-weight: var(--fw-bold); letter-spacing: -.01em; padding-inline: 18px; box-shadow: none; }
-.gx-guided .gx-btn--tonal { background: var(--g-fill-hover); color: var(--g-ink); border: 0; }
-.gx-guided .gx-btn--tonal:hover:not(:disabled) { background: var(--g-line); }
-.gx-guided .gx-starport-cta { width: 100%; min-height: 54px; border-radius: var(--radius-md); font-size: 17px; box-shadow: 0 6px 22px var(--primary-glow); }
-.gx-guided__footer { display: grid; gap: var(--sp-3); justify-items: stretch; }
+.gx-guided__option { display: flex; align-items: center; gap: var(--sp-3); min-height: var(--touch-target); padding: var(--sp-3) var(--sp-4); cursor: pointer; }
+.gx-guided__option:hover:not(:has(:disabled)) { background: var(--glass-bg-hover); }
+.gx-guided__option:has(:checked) { background: var(--primary-container); color: var(--on-primary-container); }
+.gx-guided__option:has(:disabled), .gx-guided__choice:has(:disabled) { opacity: .6; cursor: default; }
+.gx-guided__option:focus-within, .gx-guided__choice:focus-within { outline: 2px solid var(--primary); outline-offset: -2px; }
+.gx-guided__options { background: var(--surface-container); }
+.gx-guided__options > li + li { border-top: 1px solid var(--outline); }
+.gx-guided__option input { flex: none; order: 1; width: var(--sp-5); height: var(--sp-5); margin: 0; accent-color: var(--primary); }
+.gx-guided__option:has(:checked) .gx-guided__tile { background: var(--primary); color: var(--on-primary); }
+.gx-guided__segmented { display: flex; flex-wrap: wrap; gap: var(--sp-1); padding: var(--sp-1); border-radius: var(--radius-sm); background: var(--surface-container-high); }
+.gx-guided__choice { flex: 1 1 7rem; min-width: 0; min-height: var(--touch-target); padding: var(--sp-2); border-radius: calc(var(--radius-sm) - var(--sp-1)); text-align: center; text-wrap: balance; box-shadow: none; background: transparent; color: var(--on-surface-variant); }
+.gx-guided__choice:has(:checked) { background: var(--primary); color: var(--on-primary); }
+.gx-guided__choice:has(:checked):hover { background: var(--primary-hover); }
+.gx-guided__tile { flex: none; display: grid; place-items: center; width: 40px; height: 40px; border-radius: var(--radius-sm); background: var(--primary-container); color: var(--primary); font-size: var(--fs-lg); }
+.gx-guided__mark { flex: none; display: grid; place-items: center; width: 28px; font-size: var(--fs-lg); color: var(--on-surface-variant); }
+.gx-guided__checklist > li.is-done .gx-guided__mark, .gx-guided__checklist > li.is-worked .gx-guided__mark { color: var(--success); }
+.gx-guided__checklist > li.is-active .gx-guided__mark, .gx-guided__checklist > li.is-current .gx-guided__mark, .gx-guided__checklist > li.is-retry .gx-guided__mark { color: var(--primary); }
+.gx-guided__checklist > li.is-failed .gx-guided__mark { color: var(--error); }
+.gx-guided__callout { display: flex; align-items: center; justify-content: space-between; gap: var(--sp-3); flex-wrap: wrap; margin: 0; padding: var(--sp-4); border-radius: var(--radius-sm); background: var(--primary-container); }
+.gx-guided__callout--quiet { background: var(--surface-container); color: var(--on-surface-variant); }
+.gx-guided__footer { display: grid; gap: var(--sp-3); }
+.gx-guided .gx-starport-cta { min-height: calc(var(--touch-target) + var(--sp-2)); border-radius: var(--radius-md); font-size: var(--fs-base); }
 .gx-guided__footer .gx-guided__hint { text-align: center; }
-.gx-guided__link { justify-self: center; padding: var(--sp-2) var(--sp-3); border: 0; background: none; color: var(--g-accent); font: inherit; font-size: 15px; font-weight: var(--fw-medium); cursor: pointer; }
+.gx-guided__link { justify-self: center; padding: var(--sp-2) var(--sp-3); border: 0; border-radius: var(--radius-sm); background: none; color: var(--primary); font: inherit; cursor: pointer; }
 .gx-guided__link:hover:not(:disabled) { text-decoration: underline; }
+.gx-guided__link:focus-visible { outline: 2px solid var(--primary); outline-offset: 2px; }
 .gx-guided__link:disabled { opacity: .5; cursor: default; }
-
-@media (max-width: 640px) {
-  .gx-card.gx-guided { padding: 22px var(--sp-4) 18px; gap: 20px; }
-  .gx-guided__title { font-size: 26px; }
-  .gx-guided__lede { font-size: 16px; }
-  .gx-guided__segmented button { font-size: 14px; }
-  .gx-guided__options, .gx-guided__cars { --g-inset: 66px; }
-  .gx-guided__checklist { --g-inset: 54px; }
-  .gx-guided .gx-starport-cta { min-height: 56px; }
-}
-@media (prefers-reduced-motion: reduce) {
-  .gx-guided__node, .gx-guided__option, .gx-guided__radio, .gx-guided__segmented button { transition: none; }
-  .gx-guided__step.is-done .gx-guided__node, .gx-guided__checklist > li.is-done .gx-guided__mark, .gx-guided__checklist > li.is-worked .gx-guided__mark { animation: none; }
-}
diff --git a/openpilot/starpilot/galaxy/web/js/starport-guided.js b/openpilot/starpilot/galaxy/web/js/starport-guided.js
index ade56ed1e6..1fc16433ef 100644
--- a/openpilot/starpilot/galaxy/web/js/starport-guided.js
+++ b/openpilot/starpilot/galaxy/web/js/starport-guided.js
@@ -1,12 +1,9 @@
-// The guided StarPort setup. Three steps (support, car, connect), one choice about how the car connects, and a live checklist of
-// what is being tried while connecting. It reads the daemon status the page already has and drives the page's existing actions,
-// so it adds no state of its own. The pairing, cable and app instructions are the page's own and arrive through the `car` slot;
-// the Connect button arrives through the `connect` slot. Turned off, the classic screens come back ("Use classic setup").
+// Guided setup shares the page’s pairing actions and slots.
 
 export const FIRST_RUN_NOTICE = "The first connection can take a few minutes, and sometimes more than one drive, while we find what your car accepts. Keep the car on and its screen awake. Later connections are much faster because we remember what worked."
 export const EXHAUSTED_NOTICE = "We tried every option we have this drive. We keep what works best and will try again the next time the car starts."
 
-// The adapter flow refuses to continue until the car itself is connected in Galaxy Bluetooth (27 Bugsink reports, 7 devices).
+// Adapter setup may require connecting the companion car first.
 export const BLUETOOTH_FIRST = /connect your paired car in galaxy bluetooth first/i
 export const BLUETOOTH_HINT = { text: "Connect your car in Bluetooth first, then come back and tap Connect.", href: "#/bluetooth", label: "Open Bluetooth" }
 
@@ -126,7 +123,8 @@ export function guidedState({ setup = null, runtime = null, selected = null, rec
 }
 
 export const StarPortGuidedSetup = {
-  props: { state: { type: Object, required: true }, busy: { type: Boolean, default: false } },
+  props: { state: { type: Object, required: true }, busy: { type: Boolean, default: false },
+    choicesDisabled: { type: Boolean, default: false } },
   emits: ["choose-type", "choose-adapter", "choose-app", "use-car", "classic", "done"],
   template: `
     <section class="gx-card gx-guided" :data-phase="state.phase" aria-label="Guided StarPort setup">
@@ -145,13 +143,12 @@ export const StarPortGuidedSetup = {
 
       <div v-if="state.choices.length" class="gx-guided__section">
         <ul class="gx-starport-list gx-guided__options" role="radiogroup" aria-label="How your car connects">
-          <li v-for="choice in state.choices" :key="choice.key">
-            <button type="button" class="gx-guided__option" role="radio" :aria-checked="choice.selected ? 'true' : 'false'"
-                :disabled="busy" @click="$emit('choose-type', choice.key)">
+          <li v-for="choice in state.choices" :key="choice.key" role="none">
+            <label class="gx-guided__option">
+              <input type="radio" name="starport-connection" :checked="choice.selected" :disabled="busy || choicesDisabled" @change="$emit('choose-type', choice.key)">
               <span class="gx-guided__tile" aria-hidden="true"><i :class="'bi bi-' + choice.icon"></i></span>
               <span class="gx-starport-row__text"><strong>{{ choice.title }}</strong><small>{{ choice.detail }}</small></span>
-              <span class="gx-guided__radio" aria-hidden="true"><i v-if="choice.selected" class="bi bi-check-lg"></i></span>
-            </button>
+            </label>
           </li>
         </ul>
       </div>
@@ -159,8 +156,9 @@ export const StarPortGuidedSetup = {
       <div v-if="state.adapter" class="gx-guided__section">
         <h3 class="gx-guided__subhead">Which adapter?</h3>
         <div class="gx-guided__segmented" role="radiogroup" aria-label="Adapter model">
-          <button v-for="option in state.adapter.options" :key="option.key" type="button" role="radio" :aria-checked="option.selected ? 'true' : 'false'"
-              :class="{ 'is-selected': option.selected }" :disabled="busy" @click="$emit('choose-adapter', option.key)">{{ option.label }}</button>
+          <label v-for="option in state.adapter.options" :key="option.key" class="gx-btn gx-btn--tonal gx-guided__choice">
+            <input class="gx-sr-only" type="radio" name="starport-adapter" :checked="option.selected" :disabled="busy || choicesDisabled" @change="$emit('choose-adapter', option.key)">{{ option.label }}
+          </label>
         </div>
         <p v-if="state.adapter.needsChoice" class="gx-guided__hint">Choose your adapter to continue.</p>
       </div>
@@ -168,8 +166,9 @@ export const StarPortGuidedSetup = {
       <div v-if="state.apps" class="gx-guided__section">
         <h3 class="gx-guided__subhead">Which app?</h3>
         <div class="gx-guided__segmented" role="radiogroup" aria-label="Tablet app">
-          <button v-for="option in state.apps.options" :key="option.key" type="button" role="radio" :aria-checked="option.selected ? 'true' : 'false'"
-              :class="{ 'is-selected': option.selected }" :disabled="busy" @click="$emit('choose-app', option.key)">{{ option.label }}</button>
+          <label v-for="option in state.apps.options" :key="option.key" class="gx-btn gx-btn--tonal gx-guided__choice">
+            <input class="gx-sr-only" type="radio" name="starport-apps" :checked="option.selected" :disabled="busy || choicesDisabled" @change="$emit('choose-app', option.key)">{{ option.label }}
+          </label>
         </div>
         <p v-if="state.apps.needsChoice" class="gx-guided__hint">Choose your app to continue.</p>
       </div>
@@ -180,7 +179,7 @@ export const StarPortGuidedSetup = {
           <li v-for="car in state.candidates" :key="car.address" class="gx-starport-row">
             <span class="gx-guided__tile" aria-hidden="true"><i class="bi bi-car-front"></i></span>
             <span class="gx-starport-row__text"><strong>{{ car.name }}</strong><small>Paired and offers Android Auto</small></span>
-            <button type="button" class="gx-btn gx-btn--tonal" :disabled="busy" @click="$emit('use-car', car.address)">Use</button>
+            <button type="button" class="gx-btn gx-btn--tonal" :disabled="busy || choicesDisabled" @click="$emit('use-car', car.address)">Use</button>
           </li>
         </ul>
       </div>
@@ -195,7 +194,7 @@ export const StarPortGuidedSetup = {
           <li v-for="step in state.progress" :key="step.id" class="gx-starport-row" :class="'is-' + step.state" :aria-current="step.state === 'active' || step.state === 'retry' ? 'step' : undefined">
             <span class="gx-guided__mark" aria-hidden="true">
               <i v-if="step.state === 'done'" class="bi bi-check-circle-fill"></i>
-              <span v-else-if="step.state === 'active'" class="gx-spinner gx-guided__spinner"></span>
+              <span v-else-if="step.state === 'active'" class="gx-spinner"></span>
               <i v-else-if="step.state === 'retry'" class="bi bi-arrow-repeat"></i>
               <i v-else class="bi bi-circle"></i>
             </span>
@@ -212,7 +211,7 @@ export const StarPortGuidedSetup = {
               <i v-if="step.state === 'worked'" class="bi bi-check-circle-fill"></i>
               <i v-else-if="step.state === 'failed'" class="bi bi-x-circle"></i>
               <i v-else-if="step.state === 'skipped'" class="bi bi-dash-circle"></i>
-              <span v-else-if="step.state === 'current'" class="gx-spinner gx-guided__spinner"></span>
+              <span v-else-if="step.state === 'current'" class="gx-spinner"></span>
               <i v-else class="bi bi-circle"></i>
             </span>
             <span class="gx-starport-row__text"><strong>{{ step.label }}</strong></span>
diff --git a/openpilot/starpilot/galaxy/web/js/starport-logs.js b/openpilot/starpilot/galaxy/web/js/starport-logs.js
index 6c2e7de660..7d520cb25c 100644
--- a/openpilot/starpilot/galaxy/web/js/starport-logs.js
+++ b/openpilot/starpilot/galaxy/web/js/starport-logs.js
@@ -81,9 +81,11 @@ export class StarPortLogSend {
     Object.assign(this, { publish, unauthorized, fetcher, schedule, cancel })
     this.active = false
     this.timer = null
+    this.generation = 0
   }
 
   stop() {
+    this.generation++
     this.active = false
     if (this.timer !== null) this.cancel(this.timer)
     this.timer = null
@@ -95,14 +97,16 @@ export class StarPortLogSend {
     return this.poll()
   }
 
-  async call(options) {
+  async call(options, generation) {
     const response = await this.fetcher(SEND_URL, { cache: "no-store", credentials: "same-origin", ...options })
+    if (!this.active || generation !== this.generation) return null
     if (response.status === 401) {
       this.stop()
       this.unauthorized()
       return null
     }
     const body = await response.json().catch(() => null)
+    if (!this.active || generation !== this.generation) return null
     if (!response.ok) throw new Error(body?.error || "Sending StarPort logs is unavailable")
     return body
   }
@@ -110,16 +114,24 @@ export class StarPortLogSend {
   apply(body) {
     if (!this.active || !body) return
     this.publish({ state: body.state, message: body.message || "", available: body.available !== false, error: "" })
+    this.queuePoll(body.state === "sending")
+  }
+
+  queuePoll(pending = true) {
     if (this.timer !== null) this.cancel(this.timer)
-    this.timer = body.state === "sending" ? this.schedule(() => { this.timer = null; this.poll() }, POLL_MS) : null
+    this.timer = this.active && pending ? this.schedule(() => { this.timer = null; this.poll() }, POLL_MS) : null
   }
 
   async poll() {
     if (!this.active) return
+    const generation = this.generation
     try {
-      this.apply(await this.call({}))
+      this.apply(await this.call({}, generation))
     } catch (error) {
-      if (this.active) this.publish({ error: error?.message || "Sending StarPort logs is unavailable" })
+      if (this.active && generation === this.generation) {
+        this.publish({ error: error?.message || "Sending StarPort logs is unavailable" })
+        this.queuePoll()
+      }
     }
   }
 
@@ -130,14 +142,19 @@ export class StarPortLogSend {
       this.publish({ error: `Keep the message to ${MESSAGE_LIMIT} characters.` })
       return false
     }
+    const generation = ++this.generation
+    this.queuePoll(false)
     this.publish({ state: "sending", message: "Starting", error: "" })
     try {
-      const body = await this.call({ method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ message: text }) })
+      const body = await this.call({ method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ message: text }) }, generation)
       if (body === null) return false
       this.apply(body)
       return true
     } catch (error) {
-      if (this.active) this.publish({ state: "idle", error: error?.message || "Sending StarPort logs is unavailable" })
+      if (this.active && generation === this.generation) {
+        this.publish({ state: "idle", error: error?.message || "Sending StarPort logs is unavailable" })
+        this.queuePoll()
+      }
       return false
     }
   }
diff --git a/openpilot/starpilot/galaxy/web/js/starport.js b/openpilot/starpilot/galaxy/web/js/starport.js
index 0afbac9db6..ef3646ba20 100644
--- a/openpilot/starpilot/galaxy/web/js/starport.js
+++ b/openpilot/starpilot/galaxy/web/js/starport.js
@@ -767,7 +767,7 @@ export const StarPortPage = {
     // Once a device is picked the list only gets in the way of the code; it returns if pairing fails.
     deviceChosen() {
       const p = this.pairing
-      return !!(p?.receiver || p?.prompt || p?.approved || ["pairing", "connecting", "paired", "connected"].includes(p?.state))
+      return p?.state !== "failed" && !!(p?.receiver || p?.prompt || p?.approved || ["pairing", "connecting", "paired", "connected"].includes(p?.state))
     },
     deviceSelectionBlocked() {
       return !!this.pairingReason || !this.pairing?.active ||
@@ -966,7 +966,7 @@ export const StarPortPage = {
             </details>
           </div>
         </section>
-      <StarPortGuidedSetup v-if="setup && newSetup && guided.show" :state="guided" :busy="busy"
+      <StarPortGuidedSetup v-if="setup && newSetup && guided.show" id="gx-starport-guided" :state="guided" :busy="busy" :choices-disabled="appDisabled"
         @choose-type="chooseType" @choose-adapter="chooseAdapter" @choose-app="chooseApp" @use-car="useCar" @classic="useClassic" @done="showSteps = false">
         <template #car>
           <GxNotice v-if="wiredUnavailable" tone="warn">Wired AA is unavailable: {{ runtime.wired_blocked }}.</GxNotice>
@@ -1026,7 +1026,7 @@ export const StarPortPage = {
         </li>
 
       </ol>
-      <section v-if="setup && setupDone && !showSteps" class="gx-card gx-starport-step gx-starport-home" aria-labelledby="gx-starport-home-title">
+      <section v-if="setup && setupDone && !showSteps && (!newSetup || !guided.show)" class="gx-card gx-starport-step gx-starport-home" aria-labelledby="gx-starport-home-title">
         <div class="gx-starport-step__head">
           <span class="gx-starport-step__num" :class="{ 'gx-starport-home__icon--live': projecting }" aria-hidden="true"><i class="bi bi-car-front"></i></span>
           <div><h3 id="gx-starport-home-title">{{ homeTitle }}</h3>
@@ -1057,7 +1057,7 @@ export const StarPortPage = {
           ${CONNECT}
           <div class="gx-actions">
             <a class="gx-btn gx-btn--tonal" href="#/theme_maker/starport"><i class="bi bi-layout-text-window" aria-hidden="true"></i> Customize Layout</a>
-            <button type="button" class="gx-btn gx-btn--tonal" :aria-expanded="showSteps" aria-controls="gx-starport-steps" @click="showSteps = !showSteps">
+            <button type="button" class="gx-btn gx-btn--tonal" :aria-expanded="showSteps" :aria-controls="newSetup ? 'gx-starport-guided' : 'gx-starport-steps'" @click="showSteps = !showSteps">
               <i :class="showSteps ? 'bi bi-chevron-up' : 'bi bi-gear'" aria-hidden="true"></i> {{ showSteps ? 'Hide Setup' : newSetup ? 'Change how your car connects' : 'Setup and Pairing' }}</button>
           </div>
         </div>
diff --git a/openpilot/starpilot/system/starport/identity.py b/openpilot/starpilot/system/starport/identity.py
index bdec5e601f..ecddea8e78 100644
--- a/openpilot/starpilot/system/starport/identity.py
+++ b/openpilot/starpilot/system/starport/identity.py
@@ -20,6 +20,14 @@ from datetime import UTC, datetime
 from pathlib import Path
 from typing import Any
 
+
+def boot_id() -> str:
+  try:
+    return Path("/proc/sys/kernel/random/boot_id").read_text().strip()
+  except OSError:
+    return ""
+
+
 def _data_dir() -> Path:
   if override := os.environ.get("STARPORT_DIR"):
     return Path(override)
diff --git a/openpilot/starpilot/system/starport/network.py b/openpilot/starpilot/system/starport/network.py
index 1611016419..4bd4357166 100644
--- a/openpilot/starpilot/system/starport/network.py
+++ b/openpilot/starpilot/system/starport/network.py
@@ -26,7 +26,7 @@ from jeepney.low_level import MessageType
 from jeepney.wrappers import Properties
 
 from openpilot.starpilot.system.starport.bootstrap import WifiCredentials
-from openpilot.starpilot.system.starport.identity import DATA_DIR
+from openpilot.starpilot.system.starport.identity import DATA_DIR, boot_id as _boot_id
 
 NM = "org.freedesktop.NetworkManager"
 NM_PATH = "/org/freedesktop/NetworkManager"
@@ -70,13 +70,6 @@ class JoinTimeout(NetworkError):
   """The car's network never came up in time."""
 
 
-def _boot_id() -> str:
-  try:
-    return Path("/proc/sys/kernel/random/boot_id").read_text().strip()
-  except OSError:
-    return ""
-
-
 def _paused_interface(marker: Path) -> str:
   """The interface a session paused this boot and never restored, or ""; NetworkManager resets autoconnect on reboot."""
   try:
diff --git a/openpilot/starpilot/system/starport/new_setup.py b/openpilot/starpilot/system/starport/new_setup.py
index 6cca56c184..00a359d49b 100644
--- a/openpilot/starpilot/system/starport/new_setup.py
+++ b/openpilot/starpilot/system/starport/new_setup.py
@@ -1,8 +1,4 @@
-"""The "New pairing experience" switch (Galaxy Developer > StarPort), on unless the owner turned it off.
-
-A plain file beside the other StarPort data, not a Params key: it is the way back to the classic screens, so it must
-read and change with the StarPort service down or broken, and it needs no device rebuild.
-"""
+"""Persist the setup UI choice independently of the StarPort daemon."""
 from pathlib import Path
 
 from openpilot.common.utils import atomic_write
diff --git a/openpilot/starpilot/system/starport/protocol.py b/openpilot/starpilot/system/starport/protocol.py
index e75333ad2e..46b60c07b9 100644
--- a/openpilot/starpilot/system/starport/protocol.py
+++ b/openpilot/starpilot/system/starport/protocol.py
@@ -81,17 +81,21 @@ def forget_car(address: str, client: StarPortClient | None = None) -> bool:
   client = client or StarPortClient()
   if client.available:
     return bool(client.call("forget_receiver", address=address).get("cleared"))
-  from openpilot.starpilot.system.starport import identity
+  from openpilot.starpilot.system.starport import identity, setup_ladder
   address = address.strip().upper()
   config = identity.load_config()
   chosen = config["receiver_address"].upper() == address
   companion = config["companion_address"].upper() == address
   cache = dict(config["rfcomm_cache"])
-  if cache.pop(address, None) is None and not (chosen or companion):
+  replies = dict(config["modern_reply_cache"])
+  cached = cache.pop(address, None) is not None
+  cached = replies.pop(address, None) is not None or cached
+  learned = setup_ladder.SetupLadder(identity.CONFIG_PATH.with_name("setup_state.json")).forget(address)
+  if not (chosen or companion or cached or learned):
     return False
-  config["rfcomm_cache"] = cache
+  config.update(rfcomm_cache=cache, modern_reply_cache=replies)
   if chosen:
-    config.update(receiver_address="", receiver_name="", companion_address="", companion_name="")
+    config.update(receiver_address="", receiver_name="", companion_address="", companion_name="", car_fingerprint={})
   elif companion:
     config.update(companion_address="", companion_name="")
   identity.save_config(config)
diff --git a/openpilot/starpilot/system/starport/reachability.py b/openpilot/starpilot/system/starport/reachability.py
index 6d38a6ff9a..e28e2767d9 100644
--- a/openpilot/starpilot/system/starport/reachability.py
+++ b/openpilot/starpilot/system/starport/reachability.py
@@ -1,11 +1,4 @@
-"""Why a connection attempt could not reach the car, so each cause is waited out differently.
-
-Bugsink showed most failed drives never got as far as video, and nearly all of those stopped at Bluetooth: "Host is
-down" and page timeouts (the car's radio is off or busy), connection refused or reset (the radio answered but the
-Android Auto service was not up yet), and the comma's own Bluetooth stack being busy. One fixed backoff treated them alike.
-
-The class is derived from strings so the supervisor (live exceptions) and the report (logged text) agree.
-"""
+"""Classify live and logged connection failures to select retry delays."""
 
 ASLEEP = "asleep"          # the car did not answer a page at all: off, or still waking
 NOT_READY = "not_ready"    # the car answered, but its Android Auto service or Wi-Fi handshake is not up yet
diff --git a/openpilot/starpilot/system/starport/reconnect_notice.py b/openpilot/starpilot/system/starport/reconnect_notice.py
index 0cf7a42792..f4e7f982cb 100644
--- a/openpilot/starpilot/system/starport/reconnect_notice.py
+++ b/openpilot/starpilot/system/starport/reconnect_notice.py
@@ -18,7 +18,7 @@ def write(text: str, path: Path = NOTICE_PATH, now: float | None = None) -> None
   try:
     path.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
     with atomic_write(str(path), overwrite=True) as handle:
-      json.dump({"text": text, "written": time.monotonic() if now is None else now}, handle)
+      json.dump({"text": text, "written": time.monotonic() if now is None else now, "boot": identity_store.boot_id()}, handle)
   except OSError:
     pass  # the notice is a courtesy; projection never depends on it
 
@@ -34,7 +34,8 @@ def take(path: Path = NOTICE_PATH, now: float | None = None) -> str:
   except OSError:
     pass
   now = time.monotonic() if now is None else now
-  if not isinstance(record, dict) or not isinstance(record.get("text"), str):
+  boot = identity_store.boot_id()
+  if not isinstance(record, dict) or not isinstance(record.get("text"), str) or not boot or record.get("boot") != boot:
     return ""
   written = record.get("written")
   if not isinstance(written, (int, float)) or not 0 <= now - written <= NOTICE_FRESH_S:
diff --git a/openpilot/starpilot/system/starport/setup_ladder.py b/openpilot/starpilot/system/starport/setup_ladder.py
index 40b5187b2c..a69dfff7ca 100644
--- a/openpilot/starpilot/system/starport/setup_ladder.py
+++ b/openpilot/starpilot/system/starport/setup_ladder.py
@@ -1,16 +1,7 @@
-"""Which wireless handshake to try for a car, in what order, and which one last worked.
+"""Try wireless handshakes in order and remember a strategy after sustained video.
 
-The ladder is the one place that decides this. It owns the flip between the standard and phone-style version reply that
-the dongle work added, and it is also the "learned profile": the rung that last worked is simply the strategy used first
-the next time.
-
-One rule decides everything: **a failure advances the ladder only when the car answered the version exchange and no video
-was acknowledged yet in this session.** A sleeping car, this comma's own Bluetooth trouble, a car that shuts off after the
-drive has streamed, anything that is not the handshake being refused: none of these say anything about which strategy the
-car prefers, so none of them move it. Without that rule every ignition with an asleep car would walk the whole ladder and
-a car that works fine would end up running the dongle experiments.
-
-The first pass for a car is exactly what ran before (rung ``standard``); the later rungs are knobs that already existed.
+Only bootstrap timeouts after a version exchange advance the ladder; failures
+before the car answers or after acknowledged video leave its strategy unchanged.
 """
 from __future__ import annotations
 
@@ -21,7 +12,7 @@ from pathlib import Path
 
 from openpilot.common.utils import atomic_write
 from openpilot.starpilot.system.starport.bootstrap import CHANNEL_24GHZ, CHANNEL_DUAL, MODERN_MAJOR, REFUSAL_PATIENCE
-from openpilot.starpilot.system.starport.identity import DATA_DIR
+from openpilot.starpilot.system.starport.identity import DATA_DIR, boot_id as _boot_id
 
 STATE_PATH = DATA_DIR / "setup_state.json"
 STATE_VERSION = 1
@@ -83,13 +74,6 @@ def applicable(rung: str, version_major: int, adapter: bool) -> bool:
   return True
 
 
-def _boot_id() -> str:
-  try:
-    return Path("/proc/sys/kernel/random/boot_id").read_text().strip()
-  except OSError:
-    return ""
-
-
 def _valid_strategy(value) -> Strategy | None:
   if not isinstance(value, dict) or value.get("rung") not in RUNGS:
     return None
diff --git a/openpilot/starpilot/system/starport/supervisor.py b/openpilot/starpilot/system/starport/supervisor.py
index 2ba3b6da0b..6d92bd9688 100644
--- a/openpilot/starpilot/system/starport/supervisor.py
+++ b/openpilot/starpilot/system/starport/supervisor.py
@@ -1126,10 +1126,7 @@ class Supervisor:
     except Exception as error:
       self.log("forget_car_error", error=repr(error)[:300])
       result = self._forgotten_snapshot(owner, address, session, error)
-    try:
-      self.forget_receiver(address)
-    except Exception as error:
-      self.log("forget_receiver_error", error=repr(error)[:300])
+    self.forget_receiver(address)
     return result
 
   def _forgotten_snapshot(self, owner, address: str, session: tuple, error: Exception):
@@ -1317,7 +1314,7 @@ class Supervisor:
     connection = self.config["connection"]
     wireless = connection == "wireless"
     receiver = {"wired": "usb", "headunitpad": "headunitpad", "openheadunit": "openheadunit"}.get(connection, self.config["receiver_name"])
-    self._video_seen, self._strategy, self._run_started = False, None, time.monotonic()
+    self._video_seen, self._strategy = False, None
     if trigger == "onroad" and wireless:   # a new drive: the ladder's passes are per ignition, and the comma can stay on between drives
       self._ladder.begin_cycle(self.config["receiver_address"])
     from openpilot.starpilot.system.starport.bugsink_transport import device_metadata
@@ -1335,6 +1332,7 @@ class Supervisor:
     try:
       while not self._stop.is_set():
         started = time.monotonic()
+        self._run_started = started
         peer_stopped = False
         reach = reachability.OTHER  # set by a failed attempt; a clean end or a car-ended session keeps the standard wait
         self.log("attempt_start")
@@ -1491,8 +1489,6 @@ class Supervisor:
       raise
     if source == "sdp":
       self._remember_channel(address, channel)
-    if boot.version_major >= MODERN_MAJOR:
-      self._remember_reply(address, boot.modern_reply)
     self._set(head_unit=result.head_unit)
     self._remember_fingerprint(result.head_unit)
     bluez.restore_class()  # the car has accepted the comma; stop looking like a phone to everything else
@@ -1502,6 +1498,8 @@ class Supervisor:
       self._project(result, lease, ident)
     finally:
       keepalive_stop.set()
+      if boot.version_major >= MODERN_MAJOR and self._ladder.snapshot(address, adapter)["learned"]:
+        self._remember_reply(address, boot.modern_reply)
 
   def _connect_rfcomm(self, address: str, channel: int):
     from openpilot.starpilot.system.starport import bt_sockets
diff --git a/openpilot/starpilot/system/starport/tests/test_companion_bluetooth.py b/openpilot/starpilot/system/starport/tests/test_companion_bluetooth.py
index c82c7d528b..fffb63dd18 100644
--- a/openpilot/starpilot/system/starport/tests/test_companion_bluetooth.py
+++ b/openpilot/starpilot/system/starport/tests/test_companion_bluetooth.py
@@ -295,6 +295,9 @@ class CompanionTests(unittest.TestCase):
     host.stop.assert_called_once_with()
     self.owner.request.assert_called_once_with('forget', address=ADAPTER.lower())
     host.forget_receiver.assert_called_once_with(ADAPTER.lower())
+    host.forget_receiver.side_effect = OSError('Cannot save config')
+    with self.assertRaisesRegex(OSError, 'Cannot save config'):
+      host.companion_bluetooth_action('forget', ADAPTER, SESSION)
 
   def test_forgetting_the_selected_car_waits_out_pairing_and_expired_sessions(self):
     from openpilot.starpilot.system.starport.supervisor import Supervisor
diff --git a/openpilot/starpilot/system/starport/tests/test_forget_car.py b/openpilot/starpilot/system/starport/tests/test_forget_car.py
index 4bb28a128c..59b0d83334 100644
--- a/openpilot/starpilot/system/starport/tests/test_forget_car.py
+++ b/openpilot/starpilot/system/starport/tests/test_forget_car.py
@@ -85,3 +85,20 @@ def test_a_car_known_only_to_the_setup_ladder_is_still_forgotten(sup):
   assert OTHER.upper() in sup._ladder.cars
   daemon.handle(sup, {"command": "forget_receiver", "address": OTHER})
   assert OTHER.upper() not in sup._ladder.cars
+
+
+def test_offline_forget_clears_reply_strategy_and_fingerprint(sup):
+  sup._remember_reply(ADAPTER, True)
+  sup._remember_reply(OTHER, True)
+  sup._ladder.worked(ADAPTER, sup._ladder.strategy(ADAPTER, True))
+  sup._ladder.worked(OTHER, sup._ladder.strategy(OTHER, True))
+  sup.config["car_fingerprint"] = {"head_unit_make": "Old car"}
+  identity_store.save_config(sup.config)
+  client = protocol.StarPortClient(socket_path=str(identity_store.CONFIG_PATH.with_name("missing.sock")))
+  assert protocol.forget_car(ADAPTER, client) is True
+  assert saved()["modern_reply_cache"] == {OTHER: True} and saved()["car_fingerprint"] == {}
+  from openpilot.starpilot.system.starport.setup_ladder import SetupLadder
+  ladder = SetupLadder(sup._ladder.path)
+  assert ADAPTER not in ladder.cars and OTHER in ladder.cars
+  assert protocol.forget_car(OTHER, client) is False
+  assert saved()["modern_reply_cache"] == {} and not SetupLadder(sup._ladder.path).cars
diff --git a/openpilot/starpilot/system/starport/tests/test_setup_ladder.py b/openpilot/starpilot/system/starport/tests/test_setup_ladder.py
index 38ceec6f85..98a00c8862 100644
--- a/openpilot/starpilot/system/starport/tests/test_setup_ladder.py
+++ b/openpilot/starpilot/system/starport/tests/test_setup_ladder.py
@@ -242,3 +242,31 @@ def test_the_passes_come_back_with_each_ignition_even_without_a_reboot(ladder):
   assert refuse(ladder, ladder.strategy(CAR, False)) == "advanced"
   ladder.begin_cycle("AA:00:00:00:00:99")        # an unknown car is a no-op
   assert "AA:00:00:00:00:99" not in ladder.cars
+
+
+def test_short_sessions_keep_the_same_other_reply_until_it_is_learned(sup, monkeypatch):
+  from openpilot.starpilot.system.starport import supervisor as module
+  sup._ladder.failed(RECEIVER, sup._ladder.strategy(RECEIVER, False), ladder_failure=True,
+                    video_seen=False, version_major=4, adapter=False)
+  replies = []
+
+  def bootstrap(*args, **kwargs):
+    replies.append(kwargs["modern_reply"])
+    return SimpleNamespace(version_major=4, modern_reply=kwargs["modern_reply"], join_is_cancelled=lambda: False,
+                           run=lambda *a, **k: SimpleNamespace(head_unit={}), keepalive=lambda stop: None)
+
+  monkeypatch.setattr(module, "WirelessBootstrap", bootstrap)
+  monkeypatch.setattr(sup, "_wait", lambda delay: None)
+  monkeypatch.setattr(sup, "_connect_rfcomm", lambda *args: None)
+
+  def short_session(*args):
+    raise RuntimeError("TCP disconnected before sustained video")
+
+  monkeypatch.setattr(sup, "_project", short_session)
+  for _ in range(2):
+    with pytest.raises(RuntimeError, match="TCP disconnected"):
+      sup._attempt(SimpleNamespace())
+  assert replies == [True, True] and not sup.config["modern_reply_cache"]
+  monkeypatch.setattr(sup, "_project", lambda *args: sup._ladder.worked(RECEIVER, sup._strategy))
+  sup._attempt(SimpleNamespace())
+  assert sup.config["modern_reply_cache"] == {RECEIVER: True}
diff --git a/openpilot/starpilot/system/starport/tests/test_shared_radio_grace.py b/openpilot/starpilot/system/starport/tests/test_shared_radio_grace.py
index ee3cbce44e..25554ee61c 100644
--- a/openpilot/starpilot/system/starport/tests/test_shared_radio_grace.py
+++ b/openpilot/starpilot/system/starport/tests/test_shared_radio_grace.py
@@ -122,6 +122,14 @@ def test_notice_is_shown_once_and_only_while_fresh(tmp_path):
   assert not path.exists()
 
 
+def test_notice_from_another_boot_is_discarded(tmp_path, monkeypatch):
+  monkeypatch.setattr(reconnect_notice.identity_store, "boot_id", lambda: "previous")
+  path = tmp_path / "notice.json"
+  reconnect_notice.write("Reconnected", path, now=20.0)
+  monkeypatch.setattr(reconnect_notice.identity_store, "boot_id", lambda: "current")
+  assert reconnect_notice.take(path, now=30.0) == "" and not path.exists()
+
+
 def test_galaxy_status_says_what_happened():
   text = Supervisor._describe_error("streaming", SharedRadioStall("stalled"))
   assert text == "The car's Wi-Fi stalled while the comma's own Wi-Fi was switching networks; reconnecting"
diff --git a/openpilot/starpilot/system/starport/tests/test_stray_link.py b/openpilot/starpilot/system/starport/tests/test_stray_link.py
index 5ddd77e52d..a323c0d3cd 100644
--- a/openpilot/starpilot/system/starport/tests/test_stray_link.py
+++ b/openpilot/starpilot/system/starport/tests/test_stray_link.py
@@ -266,3 +266,21 @@ def test_unusable_sdp_record_is_logged_with_what_the_car_sent(identity, tmp_path
   with pytest.raises(RuntimeError):
     sup._discover_channel(CAR)
   assert _events(sup, "sdp_retry")[0]["record_hex"] == "350319111f"
+
+
+def test_readiness_time_starts_over_after_a_failed_attempt(identity, tmp_path, monkeypatch):
+  sup, _ = make_supervisor(identity, tmp_path, monkeypatch, lambda *a, **k: None)
+  now = _virtual_time(sup, monkeypatch)
+  elapsed = []
+
+  def attempt(lease):
+    elapsed.append(now[0] - sup._run_started)
+    now[0] += 90.0
+    if len(elapsed) == 1:
+      raise RuntimeError("Car not ready")
+    sup._stop.set()
+
+  monkeypatch.setattr(sup, "_attempt", attempt)
+  monkeypatch.setattr(sup, "_wait_backoff", lambda delay, **kwargs: sup._wait(delay))
+  sup._run(1, trigger="manual")
+  assert elapsed == [0.0, 0.0]