diff --git a/openpilot/starpilot/galaxy/server.py b/openpilot/starpilot/galaxy/server.py
index 68e174f2f6..c8baed2459 100644
--- a/openpilot/starpilot/galaxy/server.py
+++ b/openpilot/starpilot/galaxy/server.py
@@ -2273,6 +2273,21 @@ def make_server(*, port=8082, host='127.0.0.1', monitor=None, owner=None, crashe
             self.json(403, {'error': 'Park before changing the connection type'})
             return
           command, arguments = 'set_connection', {'connection': payload['connection']}
+        elif (action == 'car_type' and set(payload) == {'action', 'carType'} and
+              payload['carType'] in ('builtin', 'adapter', 'usb', 'app')):
+          if not configuration_allowed():
+            self.json(403, {'error': 'Park before changing the setup type'})
+            return
+          command, arguments = 'set_car_type', {'car_type': payload['carType']}
+        elif action == 'car_profile' and set(payload) == {'action', 'profile'} and isinstance(payload['profile'], str):
+          from openpilot.starpilot.system.android_auto.car_profiles import valid_override
+          if not valid_override(payload['profile']):
+            self.json(400, {'error': 'Invalid car profile'})
+            return
+          if not configuration_allowed():
+            self.json(403, {'error': 'Park before changing car settings'})
+            return
+          command, arguments = 'set_car_profile', {'profile': payload['profile']}
         elif action == 'select_receiver' and set(payload) == {'action', 'address'} and isinstance(payload['address'], str):
           if not configuration_allowed():
             self.json(403, {'error': 'Park before changing the car'})
diff --git a/openpilot/starpilot/galaxy/test_android_auto_http.py b/openpilot/starpilot/galaxy/test_android_auto_http.py
index a32896d7b1..94be2511e9 100644
--- a/openpilot/starpilot/galaxy/test_android_auto_http.py
+++ b/openpilot/starpilot/galaxy/test_android_auto_http.py
@@ -73,6 +73,8 @@ def api(tmp_path):
       self.running = False
       self.auto_connect = False
       self.connection = 'wireless'
+      self.car_type = 'builtin'
+      self.profile = ''
       self.available = True
       self.stop_error = False
       self.stop_completes = True
@@ -82,7 +84,7 @@ def api(tmp_path):
       if command == 'status':
         return {'status': {'receiver_address': self.receiver, 'receiver_name': 'My car', 'state': 'streaming' if self.running else 'idle',
                            'running': self.running, 'auto_connect': self.auto_connect, 'pairing_ready': False,
-                           'connection': self.connection}}
+                           'connection': self.connection, 'car_type': self.car_type}}
       if command == 'devices':
         return {'devices': [{'address': 'AA:BB:CC:DD:EE:FF', 'name': 'Saved car', 'paired': True, 'android_auto': True}]}
       if command == 'select_receiver':
@@ -91,6 +93,10 @@ def api(tmp_path):
         self.auto_connect = kwargs['enabled']
       if command == 'set_connection':
         self.connection = kwargs['connection']
+      if command == 'set_car_type':
+        self.car_type = kwargs['car_type']
+      if command == 'set_car_profile':
+        self.profile = kwargs['profile']
       if command == 'start':
         self.running = True
       if command == 'stop':
@@ -427,6 +433,29 @@ def test_wired_connection_requires_park_but_not_a_paired_receiver(api, connectio
   assert code == 409 and result['error'] == 'Verify your Android Auto package first'
 
 
+def test_setup_type_and_car_profile_need_park_and_valid_values(api):
+  request, _, state, client = api
+  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]
+
+  def post(body):
+    return request('POST', '/api/android-auto/control', json.dumps(body), cookie=cookie, content_type='application/json')
+
+  state['parked'] = False
+  assert post({'action': 'car_type', 'carType': 'adapter'})[0] == 403
+  assert post({'action': 'car_profile', 'profile': 'default'})[0] == 403
+  state['parked'] = True
+  code, result, _ = post({'action': 'car_type', 'carType': 'adapter'})
+  assert code == 200 and result['status']['car_type'] == 'adapter'
+  assert post({'action': 'car_type', 'carType': 'hovercraft'})[0] == 400
+  assert post({'action': 'car_type', 'carType': 'usb', 'extra': 1})[0] == 400
+  assert post({'action': 'car_profile', 'profile': 'default'})[0] == 200 and client.profile == 'default'
+  assert post({'action': 'car_profile', 'profile': ''})[0] == 200 and client.profile == ''
+  assert post({'action': 'car_profile', 'profile': 'not-a-profile'})[0] == 400
+
+
 def test_local_enable_then_upload_bundle_preserves_binary_bytes(api):
   import io
   import zipfile
diff --git a/openpilot/starpilot/galaxy/tests/browser/android-auto-setup.cjs b/openpilot/starpilot/galaxy/tests/browser/android-auto-setup.cjs
new file mode 100644
index 0000000000..a0eccd882a
--- /dev/null
+++ b/openpilot/starpilot/galaxy/tests/browser/android-auto-setup.cjs
@@ -0,0 +1,40 @@
+const {chromium}=require(process.env.PLAYWRIGHT_MODULE || 'playwright');
+const assert=require('node:assert/strict');
+(async()=>{
+const browser=await chromium.launch({headless:true,executablePath:process.env.CHROMIUM_PATH || undefined}); const page=await browser.newPage();const errors=[];page.on('pageerror',e=>errors.push(e.message));
+await page.route('**/js/boot.js',r=>r.fulfill({body:''}));
+await page.goto(process.env.GALAXY_URL || 'http://127.0.0.1:8765/');
+await page.evaluate(async()=>{
+const {createApp,reactive}=await import('./vendor/vue/vue.esm-browser.js');const {AndroidAutoPage}=await import('./js/android-auto.js');
+document.querySelector('#galaxy-boot').remove();
+window.fixture=reactive({...AndroidAutoPage.data(),setup:{enabled:true,bluetoothEnabled:true,parked:true,installReady:true,serviceReady:true,identity:{installed:true,message:'Support ready'},import:{state:'idle'},maxUploadBytes:200000000},runtime:{connection:'wireless',car_type:'builtin',state:'wifi_info',running:true},selected:{name:'IONIQ 6',address:'AA:BB:CC:DD:EE:FF'}});
+createApp({...AndroidAutoPage,data:()=>window.fixture,mounted(){},beforeUnmount(){},watch:{}},{mode:'local',localAccess:true,unauthorized(){}}).mount('#galaxy-app');
+document.querySelector('#galaxy-app').className='gx-content';
+});
+for (const width of [390,1280]) {
+await page.setViewportSize({width,height:1100});
+for(const [car_type,connection] of [['builtin','wireless'],['adapter','wireless'],['usb','wired'],['app','headunitpad'],['app','openheadunit']]){
+await page.evaluate(({car_type,connection})=>{Object.assign(fixture.runtime,{car_type,connection,car_profile:'aawireless',car_profile_source:'override',state:connection==='wired'?'waiting_for_usb':connection==='headunitpad'?'waiting_for_ipad':connection==='openheadunit'?'waiting_for_tablet':'wifi_info'});}, {car_type,connection});
+assert.equal(await page.locator('.gx-aa-progress:visible').count(),1);
+assert.equal(await page.getByRole('button',{name:'Disconnect',exact:true}).count(),1);
+assert.equal(await page.evaluate(()=>document.documentElement.scrollWidth>innerWidth),false,`${width} ${connection} overflow`);
+await page.evaluate(()=>{fixture.showSteps=true;});
+assert.equal(await page.locator('.gx-aa-progress:visible').count(),1,'expanded setup has one progress panel');
+assert.equal(await page.getByRole('button',{name:'Disconnect',exact:true}).filter({visible:true}).count(),1);
+await page.evaluate(()=>{fixture.showSteps=false;});
+}
+}
+await page.evaluate(()=>{Object.assign(fixture.runtime,{car_type:'builtin',connection:'wireless',running:false,state:'idle'});fixture.pairing={active:true,state:'pairing',approved:false,receiver:{name:'IONIQ 6'},prompt:{kind:'confirmation',value:'123456',id:'a'.repeat(32)},devices:[]};});
+assert.equal(await page.getByRole('button',{name:'Confirm',exact:true}).isEnabled(),true);
+assert.equal(await page.locator('.gx-aa-row--active').count(),1);
+
+await page.evaluate(()=>{fixture.pairing.state='failed';fixture.pairing.error='Pairing timed out';});
+assert.equal(await page.locator('.gx-aa-row--active').count(),0);
+await page.evaluate(()=>{fixture.pairing=null;fixture.selected=null;fixture.runtime.state='idle';fixture.runtime.running=false;});
+assert.equal(await page.locator('button').filter({hasText: /^\s*Find car\s*$/}).isEnabled(),true);
+assert.equal(await page.getByRole('button',{name:'Connect to car',exact:true}).isEnabled(),false);
+await page.evaluate(()=>{fixture.runtime.state='wifi_info';fixture.runtime.running=true;});
+await page.emulateMedia({reducedMotion:'reduce'});
+assert.equal(await page.locator('.gx-aa-orbit:visible').evaluate(el=>getComputedStyle(el).animationName),'none');
+assert.deepEqual(errors,[]);await browser.close();console.log('All five device options at phone/desktop sizes, confirmation, failure and single progress/action layout passed.');
+})().catch(e=>{console.error(e);process.exit(1)});
diff --git a/openpilot/starpilot/galaxy/tests/test_android_auto.mjs b/openpilot/starpilot/galaxy/tests/test_android_auto.mjs
index 6a44cac104..77df038725 100644
--- a/openpilot/starpilot/galaxy/tests/test_android_auto.mjs
+++ b/openpilot/starpilot/galaxy/tests/test_android_auto.mjs
@@ -1,3 +1,4 @@
+import { settingControl } from "../web/js/galaxy-setting-row.js"
 import assert from "node:assert/strict"
 import { readFileSync } from "node:fs"
 import { AndroidAutoFeed, AndroidAutoPage, validPairingStatus, validPromptInput, uploadPackage, uploadTimeout,
@@ -18,7 +19,7 @@ assert.equal(validPromptInput({ kind: "passkey" }, "1234567"), false)
 assert.equal(validPromptInput(prompt, ""), true)
 assert.match(AndroidAutoPage.template, /Check that this code matches your car/)
 assert.match(AndroidAutoPage.template, /Cancel Search \/ Pairing/)
-assert.match(AndroidAutoPage.template, /:row="wiredRow"[^>]*:disabled="wiredDisabled"/)
+assert.doesNotMatch(AndroidAutoPage.template, /:row="wiredRow"/)
 assert.match(AndroidAutoPage.template, /Read the Android Auto troubleshooting guide/)
 assert.doesNotMatch(AndroidAutoPage.template, /v-html|autoaccept/i)
 const app = readFileSync(new URL("../web/js/app.js", import.meta.url), "utf8")
@@ -160,23 +161,24 @@ function page(selectedSetup = setup) {
   for (const [key, method] of Object.entries(AndroidAutoPage.methods)) vm[key] = method.bind(vm)
   return vm
 }
-// Wired setup is available, while the existing parked/session/ownership gates remain enforced.
 const wiredSetup = page()
-wiredSetup.runtime = { connection: "wireless", running: false }
-assert.equal(wiredSetup.wiredDisabled, false)
-for (const field of ["enabled", "parked"]) {
-  const blocked = page({ ...setup, [field]: false })
-  assert.equal(blocked.wiredDisabled, true, field)
-}
-wiredSetup.pairing = { active: true }
-assert.equal(wiredSetup.wiredDisabled, true, "pairing owns the connection")
-wiredSetup.pairing = null
-wiredSetup.runtime.running = true
-assert.equal(wiredSetup.wiredDisabled, true, "a running session cannot change connection")
-wiredSetup.runtime = { connection: "wireless", running: false, wired_blocked: "USB is busy" }
-assert.equal(wiredSetup.wiredDisabled, true, "another USB owner blocks enabling wired mode")
-wiredSetup.runtime.connection = "wired"
-assert.equal(wiredSetup.wiredDisabled, false, "the existing wired connection can still be disabled")
+wiredSetup.runtime = { connection: "wired", running: false, wired_busy: "Turn off Jetlink to use wired Android Auto" }
+assert.equal(wiredSetup.wiredJetlinkBusy, true)
+assert.equal(wiredSetup.wiredStatus.tone, "expired")
+assert.equal(wiredSetup.wiredStatus.label, "Wired Android Auto not enabled")
+assert.match(wiredSetup.connectReason, /Jetlink/)
+assert.match(AndroidAutoPage.template, /class="gx-link" href="#\/manage_models"/)
+assert.match(AndroidAutoPage.template, /bi-arrow-right/)
+wiredSetup.runtime.wired_busy = ""
+assert.equal(wiredSetup.wiredStatus.tone, "ready")
+assert.equal(wiredSetup.wiredStatus.label, "Wired Android Auto enabled")
+assert.equal(wiredSetup.connectReason, "")
+wiredSetup.runtime.wired_blocked = "USB is unavailable"
+assert.equal(wiredSetup.wiredStatus.tone, "expired")
+assert.equal(wiredSetup.connectReason, "USB is unavailable")
+wiredSetup.runtime.wired_blocked = ""
+wiredSetup.setup.enabled = false
+assert.equal(wiredSetup.wiredStatus.tone, "expired")
 
 const uploadPage = page({ ...setup, enabled: false })
 const uploadCalls = []
@@ -473,3 +475,79 @@ const audioTool = catalog.tools.find(tool => tool.path === "/android-auto").chil
 assert.equal(audioTool.name, "Spotify and Phone Audio")
 assert.match(AndroidAutoPage.template, /href="#\/android-auto\/audio"/)
 assert.ok(app.includes(`SpotifyPage v-else-if="['/android-auto/audio', '/spotify'].includes(route.path)"`))
+// Setup type: what is in the car decides which pairing steps appear.
+const typed = page(setup)
+assert.equal(typed.carType, 'builtin', 'built-in wireless is the default')
+typed.runtime = { car_type: 'adapter' }
+assert.equal(typed.adapterSetup, true)
+assert.equal(typed.pairsHere, true)
+assert.equal(typed.findLabel, 'adapter')
+typed.runtime = { car_type: 'usb' }
+assert.equal(typed.pairsHere, false, 'a USB cable needs no Bluetooth pairing')
+typed.runtime = { running: false, connection: 'wired' }
+assert.equal(typed.carType, 'usb', 'older daemons without car_type still follow the connection')
+typed.runtime = { connection: 'headunitpad' }
+assert.equal(typed.carType, 'app')
+const typedCalls = []
+typed.control = (action, extra) => typedCalls.push([action, extra])
+typed.saveCarType(0, 'Wireless adapter')
+typed.saveCarType(0, 'Not a type')
+assert.deepEqual(typedCalls, [['car_type', { carType: 'adapter' }]])
+assert.deepEqual(new Set(page(setup).carTypeRow.choices), new Set(['Built-in wireless', 'Wireless adapter', 'Wired AA', 'App']))
+// A blocked wired port explains itself instead of silently refusing the pick.
+const blocked = page(setup)
+blocked.feed = { error: '', emit() {} }
+blocked.runtime = { car_type: 'builtin', wired_blocked: 'Turn off Jetlink to use wired Android Auto' }
+assert.equal(blocked.wiredUnavailable, true)
+const blockedCalls = []
+blocked.control = (action, extra) => blockedCalls.push([action, extra])
+assert.equal(blocked.saveCarType(0, 'Wired AA'), false)
+assert.deepEqual(blockedCalls, [])
+assert.match(blocked.feed.error, /Turn off Jetlink/)
+blocked.runtime = { car_type: 'usb', connection: 'wired', wired_blocked: 'Turn off Jetlink to use wired Android Auto' }
+assert.equal(blocked.wiredUnavailable, false, 'already wired: the pick is not blocked')
+// The line names the chosen tablet app.
+const named = page(setup)
+named.runtime = { car_type: 'app', connection: 'openheadunit' }
+assert.equal(named.carTypeRow.value, 'App (Open Headunit)')
+assert.ok(named.carTypeRow.choices.includes('App (Open Headunit)'))
+const namedCalls = []
+named.control = (action, extra) => namedCalls.push([action, extra])
+named.saveCarType(0, 'Wireless adapter')
+assert.deepEqual(namedCalls, [['car_type', { carType: 'adapter' }]])
+// The adapter model picks the AAWireless tuning; any other adapter keeps the regular pairing.
+const dongle = page(setup)
+dongle.runtime = { car_type: 'adapter', car_profile: 'default', car_profile_source: 'standard' }
+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'])
+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, 'AAWireless')
+assert.deepEqual(dongleCalls, [['car_profile', { profile: 'default' }], ['car_profile', { profile: 'aawireless' }]])
+assert.match(AndroidAutoPage.template, /adapterSetup" :row="adapterRow"/)
+assert.match(AndroidAutoPage.template, /What’s in your car\?|carTypeRow/)
+assert.match(AndroidAutoPage.template, /runtime\?\.pairing_note/)
+assert.match(AndroidAutoPage.template, /'Find ' \+ findLabel/)
+// A session that is only waiting or retrying never locks the pickers or Find; it is stopped first.
+const idle = page(setup)
+idle.runtime = { car_type: 'builtin', running: true, state: 'backoff' }
+assert.equal(idle.appDisabled, false)
+assert.equal(idle.pairingReason, '')
+idle.runtime = { car_type: 'builtin', running: true, state: 'streaming' }
+assert.equal(idle.appDisabled, true)
+assert.match(idle.pairingReason, /Disconnect/)
+// The home card offers the setup type; the app picker belongs to App only.
+assert.match(AndroidAutoPage.template, /v-if="app" :row="appRow"/)
+assert.equal(page(setup).homeTitle, 'car')
+const wiredHome = page(setup); wiredHome.runtime = { car_type: 'usb', connection: 'wired' }
+assert.equal(wiredHome.homeTitle, 'Wired Android Auto')
+const appHome = page(setup); appHome.runtime = { car_type: 'app', connection: 'headunitpad' }
+assert.equal(appHome.homeTitle, 'Headunit Emulator')
+console.log('Android Auto page: setup type, adapter checklist and adapter model passed')
diff --git a/openpilot/starpilot/galaxy/tests/test_android_auto_outgoing.mjs b/openpilot/starpilot/galaxy/tests/test_android_auto_outgoing.mjs
index 3243552e13..2e3bc226e3 100644
--- a/openpilot/starpilot/galaxy/tests/test_android_auto_outgoing.mjs
+++ b/openpilot/starpilot/galaxy/tests/test_android_auto_outgoing.mjs
@@ -24,6 +24,6 @@ test("select uses outgoing API without changing the selected AA receiver", async
   assert.equal(await feed.selectDevice(car.address), false);
 });
 test("search remains blocked during projection and code verification stays available", () => {
-  const page = {pairingReason: "", runtime: {running: true}, feed: {action() {throw Error("unexpected request");}}};
+  const page = {pairingReason: "Disconnect from your car before pairing.", runtime: {running: true, state: "streaming"}, feed: {action() {throw Error("unexpected request");}}};
   assert.equal(AndroidAutoPage.methods.startPairing.call(page), false);
 });
diff --git a/openpilot/starpilot/galaxy/tests/test_android_auto_progress.mjs b/openpilot/starpilot/galaxy/tests/test_android_auto_progress.mjs
new file mode 100644
index 0000000000..13e69979d3
--- /dev/null
+++ b/openpilot/starpilot/galaxy/tests/test_android_auto_progress.mjs
@@ -0,0 +1,34 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import { AndroidAutoPage, connectionProgress } from '../web/js/android-auto.js'
+
+test('each transport exposes its actual active connection stage', () => {
+  for (const [state, options, title] of [
+    ['wifi_info', {}, 'Getting car Wi-Fi details'],
+    ['joining_wifi', {}, 'Joining car Wi-Fi'],
+    ['waiting_for_usb', { wired: true }, 'Waiting for your USB cable'],
+    ['waiting_for_ipad', { app: 'HeadunitPad' }, 'Open HeadunitPad on your iPad'],
+    ['waiting_for_tablet', { app: 'Open Headunit' }, 'Open Open Headunit on your tablet'],
+  ]) {
+    const result = connectionProgress({ state, running: true }, options)
+    assert.equal(result.title, title)
+    assert.equal(result.active, true)
+  }
+})
+test('connection success, suspension and errors do not masquerade as work in progress', () => {
+  for (const state of ['idle', 'streaming', 'suspended', 'error']) {
+    assert.equal(connectionProgress({ state, running: state !== 'idle' }).active, false)
+  }
+  assert.equal(connectionProgress({ state: 'backoff', running: true, error: 'Car unavailable' }).detail, 'Car unavailable')
+  assert.equal(connectionProgress({ state: 'backoff', running: false }).active, false)
+  assert.equal(connectionProgress({ state: 'streaming' }).tone, 'success')
+})
+test('pairing approval advances to finishing and failures stop the spinner', () => {
+  const steps = pairing => AndroidAutoPage.computed.pairSteps.call({ pairing, adapterSetup: false })
+  const confirming = steps({ active: true, state: 'pairing', receiver: {}, prompt: {} })
+  assert.equal(confirming.find(step => step.status === 'active').label, 'Confirm the code on both screens')
+  const approved = steps({ active: true, state: 'pairing', receiver: {}, approved: true })
+  assert.equal(approved.find(step => step.status === 'active').label, 'Finish Bluetooth pairing')
+  assert.equal(steps({ active: true, state: 'failed', error: 'Timed out' }).some(step => step.status === 'active'), false)
+  assert(steps({ active: false, state: 'paired' }).every(step => step.status === 'done'))
+})
diff --git a/openpilot/starpilot/galaxy/tests/test_bluetooth_notices.mjs b/openpilot/starpilot/galaxy/tests/test_bluetooth_notices.mjs
index 39585156d5..391e1161a6 100644
--- a/openpilot/starpilot/galaxy/tests/test_bluetooth_notices.mjs
+++ b/openpilot/starpilot/galaxy/tests/test_bluetooth_notices.mjs
@@ -110,4 +110,11 @@ assert.equal(requests, 0)
 
 window.StarPilotApp.bluetooth = () => false
 assert.equal(bluetoothConnection(), false)
+{
+  const { readFileSync } = await import('node:fs')
+  const lines = readFileSync(new URL('../web/js/bluetooth.js', import.meta.url), 'utf8').split('\n')
+  const chained = lines.findIndex((line) => line.trim() === '<template v-else-if="status">')
+  assert.ok(chained > 0)
+  assert.doesNotMatch(lines[chained - 1], /v-if="status"/, 'a notice before the device cards would swallow their v-else-if')
+}
 console.log('Bluetooth limits: blue notices, connection action, no blocked requests, supported settings and real errors verified')
diff --git a/openpilot/starpilot/galaxy/web/css/galaxy.css b/openpilot/starpilot/galaxy/web/css/galaxy.css
index 943f86705b..7ba8ca3a19 100644
--- a/openpilot/starpilot/galaxy/web/css/galaxy.css
+++ b/openpilot/starpilot/galaxy/web/css/galaxy.css
@@ -1454,6 +1454,7 @@ input[type="checkbox"]:disabled { opacity: .4; cursor: not-allowed; }
 .gx-aa-step__head { display: flex; align-items: flex-start; gap: var(--sp-4); min-width: 0; }
 .gx-aa-step__head h3 { margin: 2px 0 var(--sp-1); font-size: var(--fs-lg); }
 .gx-aa-step__head p { margin: 0; color: var(--text-muted); line-height: 1.45; }
+.gx-aa-step__head > .gx-btn { margin-left: auto; flex: none; }
 .gx-aa-step__num { flex: 0 0 auto; display: grid; place-items: center; width: 36px; height: 36px; border-radius: var(--radius-full);
   background: var(--primary-container); color: var(--on-primary-container); font-weight: var(--fw-bold); }
 .gx-aa-step--done .gx-aa-step__num { background: var(--success); color: var(--background); }
@@ -1804,3 +1805,34 @@ progress { max-width: 100%; accent-color: var(--primary); }
 @media (max-width: 380px) {
   .gx-flm__table td { grid-template-columns: minmax(0, 1fr); gap: 2px; }
 }
+
+.gx-aa-progress { display: grid; gap: var(--sp-3); padding: var(--sp-4); border: 1px solid color-mix(in srgb, var(--primary) 35%, var(--outline)); border-radius: var(--radius-md); background: linear-gradient(120deg, color-mix(in srgb, var(--primary) 12%, var(--surface-container)), var(--surface-container)); min-width: 0; }
+.gx-aa-progress__heading { display: flex; align-items: center; gap: var(--sp-3); }
+.gx-aa-progress__heading > div { display: grid; gap: var(--sp-1); min-width: 0; }
+.gx-aa-progress__heading small { color: var(--primary); font-size: var(--fs-xs); font-weight: 700; letter-spacing: .08em; }
+.gx-aa-progress__heading strong { font-size: var(--fs-lg); line-height: 1.35; overflow-wrap: anywhere; }
+.gx-aa-progress__heading > i { color: var(--primary); font-size: 1.8rem; }
+.gx-aa-progress p { margin: 0; color: var(--on-surface-variant); line-height: 1.5; overflow-wrap: anywhere; }
+.gx-aa-progress--success { border-color: var(--success); }
+.gx-aa-progress--success .gx-aa-progress__heading > i, .gx-aa-progress--success small { color: var(--success); }
+.gx-aa-progress--warning { border-color: var(--warning); }
+.gx-aa-progress--warning small, .gx-aa-progress--warning .gx-aa-progress__heading > i { color: var(--warning); }
+.gx-aa-orbit { width: 34px; height: 34px; border-width: 3px; border-color: color-mix(in srgb, var(--primary) 20%, transparent); border-top-color: var(--primary); border-right-color: var(--secondary, var(--primary)); }
+.gx-aa-orbit--small { width: 22px; height: 22px; }
+.gx-aa-progress__track { height: 4px; overflow: hidden; border-radius: var(--radius-full); background: color-mix(in srgb, var(--primary) 15%, transparent); }
+.gx-aa-progress__track > span { display: block; width: 40%; height: 100%; border-radius: inherit; background: linear-gradient(90deg, var(--primary), var(--secondary, var(--primary))); animation: gx-aa-travel 1.8s ease-in-out infinite alternate; }
+@keyframes gx-aa-travel { from { transform: translateX(-100%); } to { transform: translateX(250%); } }
+.gx-aa-list .gx-aa-row--active { background: color-mix(in srgb, var(--primary) 12%, var(--surface-container)); box-shadow: inset 3px 0 var(--primary); }
+.gx-aa-row--active strong { color: var(--primary); }
+.gx-aa-list .gx-aa-row--done > i { color: var(--success); }
+.gx-aa-row--failed strong { color: var(--error); }
+.gx-aa-guide { padding: var(--sp-4); border-radius: var(--radius-md); background: var(--surface-container); border: 1px solid var(--outline); line-height: 1.5; }
+.gx-aa-guide > strong { color: var(--primary); }
+.gx-aa-guide ol { display: grid; gap: var(--sp-3); padding-left: 1.5em; margin-bottom: 0; }
+.gx-aa-guide li::marker { color: var(--primary); font-weight: 700; }
+@media (prefers-reduced-motion: reduce) {
+  .gx-aa-progress__track > span { animation: none; }
+  .gx-aa-progress__track > span { width: 100%; opacity: .6; }
+}
+.gx-aa-checks .gx-aa-check--active { padding: var(--sp-3); border-radius: var(--radius-sm); color: var(--primary); background: color-mix(in srgb, var(--primary) 12%, transparent); font-weight: var(--fw-bold); }
+.gx-aa-checks .gx-aa-check--active::before { border-right-color: var(--secondary, var(--primary)); }
diff --git a/openpilot/starpilot/galaxy/web/js/android-auto.js b/openpilot/starpilot/galaxy/web/js/android-auto.js
index 5cb9df075f..bd3bb2f3cf 100644
--- a/openpilot/starpilot/galaxy/web/js/android-auto.js
+++ b/openpilot/starpilot/galaxy/web/js/android-auto.js
@@ -44,10 +44,33 @@ 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 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">
+  <div class="gx-aa-status">
+    <span class="gx-aa-pill" :class="'gx-aa-pill--' + wiredStatus.tone" role="status">{{ wiredStatus.label }}</span>
+    <a v-if="wiredJetlinkBusy" class="gx-link" href="#/manage_models">Turn off JetLink <i class="bi bi-arrow-right" aria-hidden="true"></i></a>
+  </div>
+  <p>{{ wiredStatus.detail }}</p>
+</div>`
+const CONNECT = `<button v-if="!runtime?.running" class="gx-btn gx-aa-cta" :disabled="!!connectReason" @click="connect">{{ selected && pairsHere ? 'Connect to ' + selected.name : app ? 'Connect to ' + app : adapterSetup ? 'Connect to adapter' : 'Connect to car' }}</button>
+  <button v-else class="gx-btn gx-btn--tonal gx-aa-cta" @click="control('stop')">Disconnect</button>`
+const CONNECTION_PROGRESS = `
+  <div v-if="!showPairSteps" class="gx-aa-progress" :class="'gx-aa-progress--' + connectionProgress.tone" role="status" aria-live="polite" aria-atomic="true">
+    <div class="gx-aa-progress__heading">
+      <span v-if="connectionProgress.active" class="gx-spinner gx-aa-orbit" aria-hidden="true"></span>
+      <i v-else :class="'bi bi-' + connectionProgress.icon" aria-hidden="true"></i>
+      <div><small>{{ connectionProgress.eyebrow }}</small><strong>{{ connectionProgress.title }}</strong></div>
+    </div>
+    <p>{{ connectionProgress.detail }}</p>
+    <div v-if="connectionProgress.active" class="gx-aa-progress__track" aria-hidden="true"><span></span></div>
+  </div>`
+const AUTO_CONNECT = `<GalaxySettingRow :row="switchRow('Automatic Connection', runtime?.auto_connect, 'Connect to your car whenever you start driving.')"
+    :index="0" :busy="busy" :disabled="!setup.enabled || !setup.parked || !!pairing?.active"
+    :save-value="(index, value) => control('auto_connect', { enabled: value === 'On' })" />`
 const APP_SETUP = `
-  <div v-if="app === 'HeadunitPad'" class="gx-note" role="note">
+  <div v-if="app === 'HeadunitPad'" class="gx-aa-guide" role="note">
     <strong>HeadunitPad setup (iPad)</strong>
     <ol>
       <li>Install <a class="gx-link" href="https://github.com/andyching168/HeadunitPad" target="_blank" rel="noopener noreferrer">HeadunitPad from GitHub</a> on the iPad.</li>
@@ -56,7 +79,7 @@ const APP_SETUP = `
       <li>Tap Connect here, then open HeadunitPad.</li>
     </ol>
   </div>
-  <div v-else-if="app === 'Open Headunit'" class="gx-note" role="note">
+  <div v-else-if="app === 'Open Headunit'" class="gx-aa-guide" role="note">
     <strong>Open Headunit setup (Android tablet)</strong>
     <ol>
       <li>Install <a class="gx-link" href="https://github.com/andreknieriem/open-headunit/releases" target="_blank" rel="noopener noreferrer">Open Headunit from GitHub</a> on the tablet.</li>
@@ -66,6 +89,9 @@ const APP_SETUP = `
       <li>Tap Connect here, then tap the WiFi button in Open Headunit.</li>
     </ol>
   </div>`
+export const CAR_TYPES = {
+  builtin: "Built-in wireless", adapter: "Wireless adapter", usb: "Wired AA", app: "App"
+}
 const PROMPT = new Set(["pin", "passkey", "confirmation", "authorization", "display_pin", "display_passkey"])
 
 export function validPromptInput(prompt, value) {
@@ -283,7 +309,7 @@ export class AndroidAutoFeed {
 
   async control(action, extra = {}) {
     if (!this.active || this.busy || !this.setup?.enabled || this.pairing?.active ||
-      !["start", "stop", "select_receiver", "auto_connect", "connection"].includes(action)) return false
+      !["start", "stop", "select_receiver", "auto_connect", "connection", "car_type", "car_profile"].includes(action)) return false
     const result = await this.request("./api/android-auto/control", {
       method: "POST",
       headers: { "Content-Type": "application/json" }, body: JSON.stringify({ action, ...extra })
@@ -441,6 +467,19 @@ export function installChecks(job, locale = undefined) {
   })
 }
 
+export function connectionProgress(runtime, { wired = false, app = "", selected = null } = {}) {
+  const state = runtime?.state || "idle"
+  const base = { active: false, tone: "ready", icon: "arrow-right-circle", eyebrow: "NEXT · CONNECT" }
+  if (state === "streaming") return { ...base, tone: "success", icon: "check-circle-fill", eyebrow: "CONNECTED", title: "Your dashboard is live", detail: "StarPilot is showing on your screen. You’re ready to drive." }
+  if (state === "suspended") return { ...base, title: "Connected · car screen in use", detail: "Open Android Auto on your car’s screen to return to StarPilot." }
+  if (state === "error" || state === "backoff") return { ...base, active: state === "backoff" && !!runtime?.running, tone: "warning", icon: "exclamation-circle", eyebrow: state === "backoff" ? "RECONNECTING" : "NEEDS ATTENTION", title: state === "backoff" ? "Trying your connection again" : "Connection needs attention", detail: runtime.error || runtime.detail || "Check your device, then try connecting again." }
+  if (runtime?.running && state !== "idle") {
+    const titles = { wifi_info: "Getting car Wi-Fi details", joining_wifi: "Joining car Wi-Fi", connecting_bluetooth: "Connecting over Bluetooth", discovering: "Finding Android Auto", rfcomm: "Starting wireless setup", wifi_start: "Waiting for car Wi-Fi", connecting_tcp: "Opening the connection", authenticating: "Securing your connection", negotiating: "Preparing your dashboard", waiting_for_usb: "Waiting for your USB cable", usb_accessory: "Starting USB connection", waiting_for_ipad: "Open HeadunitPad on your iPad", waiting_for_tablet: "Open Open Headunit on your tablet", stopping: "Disconnecting" }
+    return { ...base, active: true, tone: "active", eyebrow: "CONNECTION IN PROGRESS", title: titles[state] || runtime.label || "Connecting to your device", detail: runtime.detail || (wired ? "Keep the data cable connected and the car’s screen on." : app ? "Keep the app open and both devices on the same Wi-Fi." : "Keep your car’s screen on. We’ll move to the next step automatically.") }
+  }
+  return { ...base, title: wired ? "Connect your USB cable" : app ? `Ready for ${app}` : selected ? `Ready for ${selected.name}` : "Pair your device first", detail: wired ? "Use the car’s Android Auto data port, then tap Connect below." : app ? "Complete the app setup above, then tap Connect below." : selected ? "Tap Connect to bring StarPilot to your dashboard." : "Follow the pairing steps above, then connect to your dashboard." }
+}
+
 export const AndroidAutoPage = {
   components: { GxState, GxIconButton, GxNotice, BluetoothNotice, GxDialog, GalaxySettingRow },
   props: {
@@ -452,7 +491,7 @@ export const AndroidAutoPage = {
     setup: null, pairing: null, selected: null, runtime: null, receivers: [], endReason: "", busy: false, error: "",
     pairValue: "", packageFile: null, uploadProgress: null, installOpen: false, removeOpen: false, installAttempted: false, installBaseline: null,
     downloadStarted: false, packageMagicError: "", packageChecking: false, packageSelection: 0,
-    installFileName: "", pairWhenReady: false, enableOpen: false, showSteps: false
+    installFileName: "", pairWhenReady: false, enableOpen: false, showSteps: false, starting: false, supportOpen: false
   }),
   mounted() {
     this.feed = new AndroidAutoFeed({ publish: (value) => Object.assign(this, value), unauthorized: this.unauthorized })
@@ -475,6 +514,7 @@ export const AndroidAutoPage = {
     'setup.enabled'(enabled) { if (!enabled) this.pairWhenReady = false },
   },
   computed: {
+    connectionProgress() { return connectionProgress(this.runtime, { wired: this.wired, app: this.app, selected: this.selected }) },
     canRespond() { return validPromptInput(this.pairing?.prompt, this.pairValue) },
     expiry() { return expiryInfo(this.setup?.identity) },
     projecting() { return this.runtime?.state === "streaming" },
@@ -486,23 +526,52 @@ export const AndroidAutoPage = {
     // Returning drivers see a status card; the setup steps fold away below it.
     wired() { return this.runtime?.connection === "wired" },
     app() { return HEAD_UNIT_APPS[this.runtime?.connection] || "" },
+    homeTitle() {
+      if (this.wired) return "Wired Android Auto"
+      if (this.app) return "Headunit Emulator"
+      return this.projecting ? "Connected to " + this.connectionName : this.runtime?.running ? "Connecting to " + this.connectionName : this.connectionName
+    },
+    wirelessHome() { return !this.wired && !this.app },
     connectionName() { return this.app === "HeadunitPad" ? "iPad" : this.app ? "tablet" : this.wired ? "car" : this.selected?.name || "car" },
-    setupDone() { return !!(this.supportReady && (this.selected || this.wired || this.app) && !this.pairing?.active) },
-    wiredRow() {
-      const detail = "Project over a USB cable from the car to the comma’s USB-C port instead of Bluetooth and Wi-Fi."
-      return switchRow("Wired USB Connection", this.wired, detail + (this.runtime?.wired_blocked ? ` ${this.runtime.wired_blocked}.` : ""))
+    // Waiting or retrying is not a connection: only a live link blocks changes, and those stop the wait first.
+    linked() { return ["streaming", "suspended"].includes(this.runtime?.state) },
+    waiting() { return !!this.runtime?.running && !this.linked },
+    supportCollapsed() { return this.supportReady && this.setup.installReady && !this.supportOpen },
+    setupDone() {
+      return !!(this.supportReady && (this.selected || this.wired || this.app) && !this.pairing?.active &&
+        !(this.adapterSetup && this.runtime?.car_profile_source !== "override"))
+    },
+    wiredStatus() {
+      if (this.runtime?.wired_blocked) return { tone: "expired", label: "Wired Android Auto not enabled", detail: this.runtime.wired_blocked }
+      if (this.wiredJetlinkBusy) return { tone: "expired", label: "Wired Android Auto not enabled", detail: "JetLink is using the USB-C port. Turn off JetLink, then return here." }
+      if (!this.setup?.enabled) return { tone: "expired", label: "Wired Android Auto not enabled", detail: "Turn on Android Auto Support in step 1." }
+      return { tone: "ready", label: "Wired Android Auto enabled", detail: "Connect the car’s Android Auto USB data port to the comma’s USB-C port with a data-capable cable." }
     },
     appRow() {
       return { label: "App", value: this.app || "Off", choices: ["Off", ...Object.values(HEAD_UNIT_APPS)], available: true, action: true,
         reason: "Project to a tablet app on the same Wi-Fi as the comma or the Galaxy Wi-Fi Hotspot instead of the car." }
     },
+    carType() { return this.runtime?.car_type || (this.wired ? "usb" : this.app ? "app" : "builtin") },
+    adapterSetup() { return this.carType === "adapter" },
+    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 } },
+    wiredUnavailable() { return !this.wired && !!this.runtime?.wired_blocked },
+    carTypeRow() {
+      const labels = this.carTypeLabels
+      return { label: "What’s your device?", value: labels[this.carType], choices: Object.values(labels), available: true, action: true,
+        reason: this.wired ? "Use a data cable from the car to your comma." : this.app ? "Use a tablet on the same Wi-Fi as your comma." : this.adapterSetup ? "Pair the USB adapter, such as AAWireless or Motorola MA1." : "Pair directly with your car’s wireless Android Auto." }
+    },
+    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,
+        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." }
+    },
     appDisabled() {
-      return !this.setup?.enabled || !this.setup.parked || !!this.pairing?.active || !!this.runtime?.running
-    },
-    wiredDisabled() {
-      return !this.setup?.enabled || !this.setup.parked || !!this.pairing?.active || !!this.runtime?.running ||
-        (!!this.runtime?.wired_blocked && !this.wired)
+      return !this.setup?.enabled || !this.setup.parked || !!this.pairing?.active || this.linked
     },
+    wiredJetlinkBusy() { return this.wired && !!this.runtime?.wired_busy },
     download() { return downloadLink(this.setup?.download, this.setup?.downloadPending === true) },
     uploadPercent() {
       const { loaded, total } = this.uploadProgress || {}
@@ -558,31 +627,73 @@ export const AndroidAutoPage = {
       if (!this.setup.installReady) return "This build is missing the Android Auto display or encoder."
       if (this.setup.enabled && !this.setup.serviceReady) return "Waiting for the Android Auto service to start."
       if (!this.setup.bluetoothEnabled && this.setup.enabled) return "Turn on Bluetooth on the Bluetooth page."
+      if (this.adapterSetup && this.runtime?.car_profile_source !== "override") return "Choose your adapter model first."
       if (!this.setup.parked) return "Use offroad mode or Park before starting pairing."
-      if (this.runtime?.running) return "Disconnect from your car before pairing."
+      if (this.linked) return "Disconnect from your car before pairing."
       return ""
     },
     connectReason() {
-      if (!this.selected && !this.wired && !this.app) return "Pair your car in step 2 first."
+      if (!this.selected && !this.wired && !this.app) return this.adapterSetup ? "Pair your adapter in step 2 first." : "Pair your car in step 2 first."
       if (!this.setup?.enabled) return "Turn on Android Auto Support in step 1."
       if (!this.setup.serviceReady) return "Waiting for the Android Auto service to start."
       if (this.pairing?.active) return "Finish or cancel pairing first."
+      if (this.adapterSetup && this.runtime?.car_profile_source !== "override") return "Choose your adapter model in step 2 first."
+      if (this.wired && this.runtime?.wired_blocked) return this.runtime.wired_blocked
+      if (this.wiredJetlinkBusy) return "Turn off Jetlink first."
       return ""
     },
+    pairSteps() {
+      const state = this.pairing?.state, active = !!this.pairing?.active
+      const paired = ["paired", "connected"].includes(state)
+      const picked = !!(this.pairing?.receiver || this.pairing?.approved || ["pairing", "connecting"].includes(state) || paired)
+      const what = this.adapterSetup ? "adapter" : "car"
+      const failed = state === "failed" || !!this.pairing?.error
+      const rank = paired ? 5 : state === "connecting" ? 4 : this.pairing?.approved ? 3 : this.pairing?.prompt ? 2 : picked ? 2 : active ? 1 : 0
+      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",
+        "Finish Bluetooth pairing",
+        "Finish connecting to your device"
+      ]
+      return steps.map((label, index) => ({ label, status: index < rank ? "done" : index === rank ? (failed ? "failed" : "active") : "pending" }))
+    },
+    showPairSteps() { return this.starting || !!this.pairing?.active },
     waitingForCar() {
       return this.pairing?.active && !this.pairing?.receiver && !this.pairing?.prompt && !this.pairing?.approved &&
         !["pairing", "connecting", "paired", "connected", "failed"].includes(this.pairing?.state)
     },
     deviceSelectionBlocked() {
       return !!this.pairingReason || !this.pairing?.active ||
-        !!this.pairing?.prompt || ["pairing", "connecting"].includes(this.pairing?.state) || !!this.runtime?.running
+        !!this.pairing?.prompt || ["pairing", "connecting"].includes(this.pairing?.state) || !!this.linked
     },
   },
   methods: {
     switchRow,
+    stopWaiting() { return this.waiting ? this.control("stop") : null },
+    afterWaiting(next) {
+      const stopping = this.stopWaiting()
+      return stopping ? stopping.then((stopped) => stopped && next()) : next()
+    },
+    useCar(address) { return this.afterWaiting(() => this.control("select_receiver", { address })) },
+    saveCarType(index, value) {
+      const labels = this.carTypeLabels
+      const carType = Object.keys(labels).find(key => labels[key] === value)
+      if (carType === "usb" && this.wiredUnavailable) {
+        this.feed.error = `Wired AA is unavailable: ${this.runtime.wired_blocked}.`
+        this.feed.emit()
+        return false
+      }
+      if (carType === this.carType) return false
+      return carType ? this.afterWaiting(() => this.control("car_type", { carType })) : false
+    },
+    saveAdapter(index, value) {
+      const profile = Object.keys(ADAPTER_MODELS).find(key => ADAPTER_MODELS[key] === value)
+      return profile ? this.afterWaiting(() => this.control("car_profile", { profile })) : false
+    },
     saveApp(index, value) {
       const connection = Object.keys(HEAD_UNIT_APPS).find(key => HEAD_UNIT_APPS[key] === value) || "wireless"
-      return this.control("connection", { connection })
+      return this.afterWaiting(() => this.control("connection", { connection }))
     },
     async begin() {
       await this.feed.start()
@@ -613,8 +724,14 @@ export const AndroidAutoPage = {
       this.finishEnable(enabled)
       return enabled
     },
+    async beginPairing() {
+      this.starting = true
+      try { return await this.startPairing() } finally { this.starting = false }
+    },
     startPairing() {
-      if (this.pairingReason || this.runtime?.running) return false
+      if (this.pairingReason) return false
+      const stopping = this.stopWaiting()
+      if (stopping) return stopping.then((stopped) => stopped && this.startPairing())
       if (!this.setup.enabled) return this.setEnabled(true).then((enabled) => {
         this.pairWhenReady = enabled
         return this.resumePairing()
@@ -690,42 +807,18 @@ export const AndroidAutoPage = {
     <section class="gx-driving" aria-label="Android Auto setup" :inert="busy" :aria-busy="busy || undefined">
       <header class="gx-page-header">
         <h2>Android Auto</h2>
-        <p>Show the StarPilot driving view on your car’s screen. Set up support, {{ wired ? 'plug in your car' : 'pair your car' }}, then connect.</p>
+        <p>Show the StarPilot driving view on your car’s screen. Choose your device, follow the setup steps, then connect.</p>
       </header>
-      <GxNotice tone="warn" v-if="!wired && !app">Android Auto uses the comma’s Wi-Fi to project to your car and disconnects it from your current Wi-Fi network. Use the Galaxy hotspot for local access during projection. Remote Galaxy access requires Internet on the comma.</GxNotice>
+      <GxNotice tone="warn" v-if="!wired && !app && runtime?.dedicated_wifi_interface === false">Android Auto uses the comma’s Wi-Fi to project to your car and disconnects it from your current Wi-Fi network. Use the Galaxy hotspot for local access during projection. Remote Galaxy access requires Internet on the comma.</GxNotice>
       <GxNotice tone="danger" v-if="error && setup">{{ error }}</GxNotice>
       <GxNotice v-if="!setup" :busy="!error" :tone="error ? 'danger' : 'info'">{{ error || "Checking Android Auto setup… Reconnecting automatically…" }}</GxNotice>
-      <section v-if="setup && setupDone" class="gx-card gx-aa-step gx-aa-home" aria-labelledby="gx-aa-home-title">
-        <div class="gx-aa-step__head">
-          <span class="gx-aa-step__num" :class="{ 'gx-aa-home__icon--live': projecting }" aria-hidden="true"><i class="bi bi-car-front"></i></span>
-          <div><h3 id="gx-aa-home-title">{{ projecting ? 'Connected to ' + connectionName : runtime?.running ? 'Connecting to ' + connectionName : connectionName }}</h3>
-            <p role="status">{{ runtime?.running && runtime.state !== 'streaming' && runtime.label ? runtime.label : runtime?.running ? 'Showing StarPilot on your car’s screen.' : runtime?.auto_connect ? 'Connects automatically when you start driving.' : 'Ready to connect.' }}</p></div>
-        </div>
-        <div class="gx-aa-step__body">
-          <p v-if="expiry.level === 'soon'" class="gx-aa-pill gx-aa-pill--soon" role="status">{{ expiry.label }}</p>
-          <button v-if="!runtime?.running" class="gx-btn gx-aa-cta" :disabled="!!connectReason" @click="connect">Connect</button>
-          <button v-else class="gx-btn gx-btn--tonal gx-aa-cta" @click="control('stop')">Disconnect</button>
-          <GalaxySettingRow :row="switchRow('Automatic Connection', runtime?.auto_connect, 'Connect to your car whenever you start driving.')"
-            :index="0" :busy="busy" :disabled="!setup.enabled || !setup.parked || !!pairing?.active"
-            :save-value="(index, value) => control('auto_connect', { enabled: value === 'On' })" />
-          <GalaxySettingRow :row="wiredRow" :index="0" :busy="busy" :disabled="wiredDisabled"
-            :save-value="(index, value) => control('connection', { connection: value === 'On' ? 'wired' : 'wireless' })" />
-          <GalaxySettingRow :row="appRow" :index="0" :busy="busy" :disabled="appDisabled" :save-value="saveApp" />
-          ${APP_SETUP}
-          <div class="gx-actions">
-            <a class="gx-btn gx-btn--tonal" href="#/theme_maker/android_auto"><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-aa-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>
-          </div>
-        </div>
-      </section>
-      <ol v-if="setup" v-show="!setupDone || showSteps" id="gx-aa-steps" class="gx-aa__steps">
-        <li class="gx-card gx-aa-step" :class="{ 'gx-aa-step--done': supportReady }">
+        <section v-if="setup" class="gx-card gx-aa-step" :class="{ 'gx-aa-step--done': supportReady }">
           <div class="gx-aa-step__head">
             <span class="gx-aa-step__num" aria-hidden="true"><i v-if="supportReady" class="bi bi-check-lg"></i><template v-else>1</template></span>
-            <div><h3>Android Auto Support</h3><p>Turn on Android Auto and install support. Wireless pairing also needs Bluetooth on; Galaxy will offer to enable it.</p></div>
+            <div><h3>Android Auto Support</h3><p v-if="supportCollapsed" role="status">{{ expiry.label }}</p><p v-else>Turn on Android Auto and install support. Wireless pairing also needs Bluetooth on; Galaxy will offer to enable it.</p></div>
+            <button v-if="supportReady && setup.installReady" type="button" class="gx-btn gx-btn--tonal" :aria-expanded="!supportCollapsed" aria-controls="gx-aa-support" @click="supportOpen = !supportOpen">{{ supportCollapsed ? 'Manage' : 'Hide' }}</button>
           </div>
-          <div class="gx-aa-step__body">
+          <div id="gx-aa-support" v-show="!supportCollapsed" class="gx-aa-step__body">
             <p v-if="!setup.installReady" class="gx-aa-pill gx-aa-pill--expired" role="status">Not available on this build — the Android Auto display and encoder are missing.</p>
             <template v-else>
               <div class="gx-aa-status">
@@ -758,25 +851,54 @@ export const AndroidAutoPage = {
               </ul>
             </details>
           </div>
-        </li>
-
-        <li class="gx-card gx-aa-step" :class="{ 'gx-aa-step--done': !!selected && !pairing?.active }">
+        </section>
+      <ol v-if="setup" id="gx-aa-steps" class="gx-aa__steps">
+        <li v-show="!setupDone || showSteps" class="gx-card gx-aa-step" :class="{ 'gx-aa-step--done': !!selected && !pairing?.active }">
           <div class="gx-aa-step__head">
             <span class="gx-aa-step__num" aria-hidden="true"><i v-if="selected && !pairing?.active" class="bi bi-check-lg"></i><template v-else>2</template></span>
-            <div><h3>Pair Your Car</h3><p>Open your car’s phone pairing screen, then tap Find car. You can do this before step 1 is finished.</p></div>
+            <div><h3>{{ carType === 'usb' ? 'Set Up Wired AA' : carType === 'app' ? 'Set Up Your App' : adapterSetup ? 'Pair Your Adapter' : 'Pair Your Car' }}</h3><p>{{ adapterSetup ? 'Put the adapter in pairing mode, then tap Find adapter. Your car doesn’t need to be paired.' : pairsHere ? 'Open your car’s phone pairing screen, then tap Find car. You can do this before step 1 is finished.' : 'No Bluetooth pairing is needed for this setup.' }}</p></div>
           </div>
           <div class="gx-aa-step__body">
+            <button v-if="setupDone && showSteps" class="gx-btn gx-btn--tonal" @click="showSteps = false">Hide Setup</button>
+            <GalaxySettingRow :row="carTypeRow" :index="0" :busy="busy" :disabled="appDisabled" :save-value="saveCarType" />
+            <GxNotice v-if="wiredUnavailable" tone="warn">Wired AA is unavailable: {{ runtime.wired_blocked }}.</GxNotice>
+            <GalaxySettingRow v-if="carType === 'app'" :row="appRow" :index="0" :busy="busy" :disabled="appDisabled" :save-value="saveApp" />
+            <GalaxySettingRow v-if="adapterSetup" :row="adapterRow" :index="0" :busy="busy" :disabled="appDisabled" :save-value="saveAdapter" />
+            ${AUTO_CONNECT}
+            <template v-if="carType === 'usb'">
+              ${WIRED_STATUS}
+            </template>
+            <template v-else-if="carType === 'app'">
+              ${APP_SETUP}
+            </template>
+            <template v-if="pairsHere">
+            <ol v-if="adapterSetup" class="gx-aa-list" aria-label="Adapter pairing">
+              <li class="gx-aa-row">
+                <i class="bi bi-usb-symbol" aria-hidden="true"></i>
+                <span class="gx-aa-row__text"><strong>Adapter</strong><small>{{ selected ? selected.name : 'Put it in pairing mode, then tap Find adapter.' }}</small></span>
+                <span class="gx-aa-pill" :class="selected ? 'gx-aa-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-aa-list" aria-label="Paired cars">
               <li v-for="car in receivers" :key="car.address" class="gx-aa-row">
                 <i class="bi bi-car-front" aria-hidden="true"></i>
                 <span class="gx-aa-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-aa-pill gx-aa-pill--ready"><i class="bi bi-check-lg"></i> Selected</span>
-                <button v-else class="gx-btn gx-btn--tonal" :disabled="!setup.parked || runtime?.running" @click="control('select_receiver', { address: car.address })">Use</button>
+                <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-aa-row"><i class="bi bi-car-front" aria-hidden="true"></i><span class="gx-aa-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-aa-list" aria-label="Pairing progress">
+              <li v-for="step in pairSteps" :key="step.label" class="gx-aa-row" :class="'gx-aa-row--' + step.status" :aria-current="step.status === 'active' ? 'step' : undefined">
+                <i v-if="step.status === 'done'" class="bi bi-check-circle-fill gx-aa-ok" aria-hidden="true"></i>
+                <span v-else-if="step.status === 'active'" class="gx-spinner gx-aa-orbit gx-aa-orbit--small" aria-hidden="true"></span>
+                <i v-else class="bi bi-circle" aria-hidden="true"></i>
+                <span class="gx-aa-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>
@@ -806,14 +928,14 @@ export const AndroidAutoPage = {
             <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="startPairing"><i class="bi bi-search"></i> {{ selected ? 'Pair another' : 'Find car' }}</button>
+              <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-aa-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, Motorola MA1, Carlinkit…): pair your car in Bluetooth under Tools first so calls keep working, then put the adapter in pairing mode and pair it here. Adapter names often look like AndroidAuto-XXXX.</li>
+                <li><strong>Wireless adapter</strong> (AAWireless, Motorola MA1, Carlinkit…): 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>
@@ -824,44 +946,62 @@ export const AndroidAutoPage = {
               </ol>
               <a class="gx-btn gx-btn--tonal" href="#/bluetooth">Open Bluetooth</a>
             </details>
-          </div>
-        </li>
-
-        <li class="gx-card gx-aa-step" :class="{ 'gx-aa-step--done': projecting }">
-          <div class="gx-aa-step__head">
-            <span class="gx-aa-step__num" aria-hidden="true"><i v-if="projecting" class="bi bi-check-lg"></i><template v-else>3</template></span>
-            <div><h3>Connect &amp; Drive</h3><p>Start streaming to your dashboard.</p></div>
-          </div>
-          <div class="gx-aa-step__body">
-            <p v-if="projecting" class="gx-aa-pill gx-aa-pill--ready" role="status">Connected<span v-if="runtime.state"> · {{ runtime.label || runtime.state }}</span><span v-if="runtime.detail"> — {{ runtime.detail }}</span></p>
-            <p v-else-if="runtime?.state && runtime.state !== 'idle'" class="gx-note" role="status">Projection: {{ runtime.label || runtime.state }}<span v-if="runtime.detail"> — {{ runtime.detail }}</span>.</p>
-            <button v-if="!runtime?.running" class="gx-btn gx-aa-cta" :disabled="!!connectReason" @click="connect">{{ selected ? 'Connect to ' + selected.name : 'Connect to car' }}</button>
-            <button v-else class="gx-btn gx-btn--tonal gx-aa-cta" @click="control('stop')">Disconnect</button>
+            </template>
+            ${CONNECTION_PROGRESS}
+            ${CONNECT}
             <p v-if="connectReason" class="gx-note" role="status">{{ connectReason }}</p>
             <p v-else-if="!setup.identity.installed" class="gx-note">Finish step 1 first — Connect will walk you through it.</p>
-            <GalaxySettingRow :row="switchRow('Automatic Connection', runtime?.auto_connect, 'Connect to your car whenever you start driving.')"
-              :index="0" :busy="busy" :disabled="!setup.enabled || !setup.parked || !!pairing?.active"
-              :save-value="(index, value) => control('auto_connect', { enabled: value === 'On' })" />
-            <GalaxySettingRow :row="wiredRow" :index="0" :busy="busy" :disabled="wiredDisabled"
-              :save-value="(index, value) => control('connection', { connection: value === 'On' ? 'wired' : 'wireless' })" />
-            <GalaxySettingRow :row="appRow" :index="0" :busy="busy" :disabled="appDisabled" :save-value="saveApp" />
-            ${APP_SETUP}
-            <p v-if="runtime?.companion_name" class="gx-note">Car: {{ runtime.companion_name }}</p>
             <details class="gx-aa-wiki"><summary>Stuck connecting? Wi-Fi and screen troubleshooting</summary>
               <ul>
                 <li v-if="!wired && !app"><strong>How it connects:</strong> after Bluetooth, the car (or adapter) creates its own hidden 5 GHz Wi-Fi network and tells the comma how to join. The picture streams over that Wi-Fi.</li>
                 <li><strong>First connection:</strong> stay in Park or offroad mode, and keep the car’s screen on.</li>
                 <li><strong>Black or frozen screen:</strong> tap Disconnect, wait a few seconds, then connect again. If it keeps happening, turn the car off and on.</li>
                 <li><strong>Car says the phone isn’t compatible:</strong> make sure wireless Android Auto (sometimes called “smartphone connection”) is turned on in the car’s settings, and that step 1 shows Ready.</li>
-                <li><strong>Wired USB:</strong> turn on Wired USB Connection, plug the car’s data USB port into the comma’s USB-C port with a data-capable cable, and drive. Bluetooth pairing is not needed.</li>
+                <li><strong>Wired AA:</strong> turn on Wired AA in step 2, plug the car’s data USB port into the comma’s USB-C port with a data-capable cable, and drive. Bluetooth pairing is not needed.</li>
               </ul>
             </details>
           </div>
         </li>
 
-        <li class="gx-card gx-aa-step">
+      </ol>
+      <section v-if="setup && setupDone && !showSteps" class="gx-card gx-aa-step gx-aa-home" aria-labelledby="gx-aa-home-title">
+        <div class="gx-aa-step__head">
+          <span class="gx-aa-step__num" :class="{ 'gx-aa-home__icon--live': projecting }" aria-hidden="true"><i class="bi bi-car-front"></i></span>
+          <div><h3 id="gx-aa-home-title">{{ homeTitle }}</h3>
+            <p role="status">{{ runtime?.running && runtime.state !== 'streaming' ? connectionProgress.title : projecting ? 'Showing StarPilot on your car’s screen.' : wired ? wiredStatus.label : runtime?.auto_connect ? 'Connects automatically when you start driving.' : 'Ready to connect.' }}</p></div>
+        </div>
+        <div class="gx-aa-step__body">
+          <p v-if="expiry.level === 'soon'" class="gx-aa-pill gx-aa-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" />
+          ${AUTO_CONNECT}
+          <ul v-if="wirelessHome" class="gx-aa-list" aria-label="Setup steps">
+            <li class="gx-aa-row"><i class="bi bi-shield-check" aria-hidden="true"></i>
+              <span class="gx-aa-row__text"><strong>1. Android Auto support</strong><small>{{ expiry.label }}</small></span>
+              <span class="gx-aa-pill" :class="supportReady ? 'gx-aa-pill--ready' : ''">{{ supportReady ? 'Ready' : 'Not ready' }}</span></li>
+            <li class="gx-aa-row"><i class="bi bi-bluetooth" aria-hidden="true"></i>
+              <span class="gx-aa-row__text"><strong>2. {{ adapterSetup ? 'Adapter paired' : 'Car paired' }}</strong><small>{{ selected ? selected.name : 'Not paired yet.' }}</small></span>
+              <span class="gx-aa-pill" :class="selected ? 'gx-aa-pill--ready' : ''">{{ selected ? 'Paired' : 'Not paired' }}</span></li>
+            <li class="gx-aa-row"><i class="bi bi-car-front" aria-hidden="true"></i>
+              <span class="gx-aa-row__text"><strong>3. Connect</strong><small>{{ projecting ? 'Showing on your car’s screen.' : runtime?.running ? connectionProgress.title : 'Tap Connect below.' }}</small></span>
+              <span class="gx-aa-pill" :class="projecting ? 'gx-aa-pill--ready' : ''">{{ projecting ? 'Connected' : runtime?.running ? 'In progress' : 'Waiting' }}</span></li>
+          </ul>
+          ${WIRED_STATUS}
+          ${APP_SETUP}
+          ${CONNECTION_PROGRESS}
+          ${CONNECT}
+          <div class="gx-actions">
+            <a class="gx-btn gx-btn--tonal" href="#/theme_maker/android_auto"><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-aa-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>
+          </div>
+        </div>
+      </section>
+      <ol v-if="setup" class="gx-aa__steps">
+        <li v-show="!setupDone || showSteps" class="gx-card gx-aa-step">
           <div class="gx-aa-step__head">
-            <span class="gx-aa-step__num" aria-hidden="true">4</span>
+            <span class="gx-aa-step__num" aria-hidden="true">3</span>
             <div><h3>Customize Your Dashboard</h3><p>Once connected, customize your dashboard setup.</p></div>
           </div>
           <div class="gx-aa-step__body">
diff --git a/openpilot/starpilot/galaxy/web/js/bluetooth.js b/openpilot/starpilot/galaxy/web/js/bluetooth.js
index 94904608fd..89f30c9967 100644
--- a/openpilot/starpilot/galaxy/web/js/bluetooth.js
+++ b/openpilot/starpilot/galaxy/web/js/bluetooth.js
@@ -218,6 +218,7 @@ export const BluetoothPage = {
         <GxNotice tone="danger" v-if="error">{{ error }}</GxNotice>
         <GxState v-if="!status && !error" loading>Checking Bluetooth…</GxState>
         <template v-else-if="status">
+          <GxNotice tone="info">Using a wireless Android Auto adapter? Pair the adapter on the <a class="gx-link" href="#/android-auto">Android Auto page</a>, then pair and connect your car here.</GxNotice>
           <section class="gx-card"><div class="gx-section__header"><i class="bi bi-bluetooth" aria-hidden="true"></i><span class="gx-section__title">Adapter</span></div>
             <div class="gx-panel gx-stack">
               <GxNotice v-if="status.errorCode" tone="danger">{{ bluetoothError(status.errorCode) }}</GxNotice>
diff --git a/openpilot/starpilot/system/android_auto/bluetooth_bridge.py b/openpilot/starpilot/system/android_auto/bluetooth_bridge.py
index 2b40dbf7ac..3849120545 100644
--- a/openpilot/starpilot/system/android_auto/bluetooth_bridge.py
+++ b/openpilot/starpilot/system/android_auto/bluetooth_bridge.py
@@ -228,6 +228,27 @@ class SharedBluetoothOwner(BluetoothOwner):
   def _admission_busy(self) -> bool:
     return self.phone_lease is not None or super()._admission_busy()
 
+  @staticmethod
+  def _start_scan(client) -> bool:
+    """BlueZ can hold a stale discovery request; reset it once, and still open the window (the car can pair to us) if it stays stuck."""
+    try:
+      client.operation('scan')
+      return True
+    except BluetoothRejected as error:
+      if 'InProgress' not in str(error):
+        raise
+    try:
+      client.operation('stop_scan')
+    except BluetoothRejected:
+      pass
+    try:
+      client.operation('scan')
+      return True
+    except BluetoothRejected as error:
+      if 'InProgress' not in str(error):
+        raise
+      return False
+
   def acquire_phone_role(self, session: tuple, phone: PhoneProfile, *, seconds: float = 180.0) -> PhoneRoleLease:
     if not session or not 0 < seconds <= 180:
       raise ValueError('Invalid phone-role session or duration')
@@ -290,8 +311,7 @@ class SharedBluetoothOwner(BluetoothOwner):
       self.phone_lease = lease
       self.admission_file = process_lock
       try:
-        client.operation('scan')
-        lease.discovering = True
+        lease.discovering = self._start_scan(client)
       except BaseException:
         self.release_phone_role(lease)
         raise
diff --git a/openpilot/starpilot/system/android_auto/bt_sockets.py b/openpilot/starpilot/system/android_auto/bt_sockets.py
index deb078b8cb..760ba2983a 100644
--- a/openpilot/starpilot/system/android_auto/bt_sockets.py
+++ b/openpilot/starpilot/system/android_auto/bt_sockets.py
@@ -21,6 +21,8 @@ import time
 AF_BLUETOOTH = 31
 BTPROTO_L2CAP = 0
 BTPROTO_RFCOMM = 3
+ENOSYS_RETRIES = 2  # some kernels report ENOSYS on a connect that succeeds moments later
+ENOSYS_RETRY_S = 0.5
 ADDRESS_RE = re.compile(r"^(?:[0-9A-F]{2}:){5}[0-9A-F]{2}$")
 
 
@@ -88,11 +90,14 @@ def _libc_connect(proto: int, kind: int, address: str, port: int, timeout: float
 def _connect(proto: int, kind: int, address: str, port: int, timeout: float) -> socket.socket:
   address = normalize_address(address)
   if hasattr(socket, "AF_BLUETOOTH") and hasattr(socket, "BTPROTO_RFCOMM"):
-    try:
-      return _native(proto, kind, address, port, timeout)
-    except OSError as exc:
-      if exc.errno != errno.ENOSYS:
-        raise
+    for attempt in range(ENOSYS_RETRIES + 1):
+      try:
+        return _native(proto, kind, address, port, timeout)
+      except OSError as exc:
+        if exc.errno != errno.ENOSYS:
+          raise
+        if attempt < ENOSYS_RETRIES:
+          time.sleep(ENOSYS_RETRY_S)
   return _libc_connect(proto, kind, address, port, timeout)
 
 
diff --git a/openpilot/starpilot/system/android_auto/bugsink_report.py b/openpilot/starpilot/system/android_auto/bugsink_report.py
index dc63aecdc4..ad4f718d31 100644
--- a/openpilot/starpilot/system/android_auto/bugsink_report.py
+++ b/openpilot/starpilot/system/android_auto/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.android_auto import identity as identity_store
+from openpilot.starpilot.system.android_auto import identity as identity_store, system_slice
 from openpilot.starpilot.system.android_auto.bugsink_diagnosis import attempt_records, diagnosis, elapsed, sanitize
 from openpilot.starpilot.system.android_auto.bugsink_summary import batch_summary, failure_summary, pairing_summary, session_timeline, software_tags
 
@@ -25,6 +25,16 @@ LOG_SETTLE_S = 120         # a log written this recently may still be a live ses
 MAX_SESSIONS = 20          # per drive report; the rest go in the next one
 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
+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",
+               "temp_max_c", "cpu0_mhz", "cpu4_mhz", "frames_sent", "focused")
+SERIES_MAX = 240
+EXTRA_TAIL_LINES = 80
 FINISHED_EVENT = '"event": "session_stop"'
 OUTCOME_RANK = ("streamed", "recovered", "stopped", "dropped", "failed")
 
@@ -59,6 +69,21 @@ def stage_timings(events: list[dict]) -> list[dict]:
   return [{"stage": stage, "at_s": at} for stage, at in seen.items()]
 
 
+def stats_series(events: list[dict]) -> dict:
+  """Every 30 s stats sample as columns (seconds since the start, then one list per reading), thinned to SERIES_MAX."""
+  stats = [event for event in events if event["event"] == "stats"]
+  stride = -(-len(stats) // SERIES_MAX) if stats else 1
+  stats = stats[::stride]
+  if not stats:
+    return {}
+  columns = {"at_s": [elapsed(events[0], event) for event in stats]}
+  for key in SERIES_KEYS:
+    values = [event.get(key) if isinstance(event.get(key), (int, float, bool)) else None for event in stats]
+    if any(value is not None for value in values):
+      columns[key] = values
+  return columns
+
+
 def video_summary(events: list[dict]) -> dict:
   """The video mode and the frame rate delivered while the car showed StarPilot, from the 30 s stats lines."""
   ready = next((event for event in reversed(events) if event["event"] == "projection_ready"), {})
@@ -88,10 +113,51 @@ def video_summary(events: list[dict]) -> dict:
     "wifi_dbm_min": min(wifi) if wifi else None,
     "encoder_recoveries": max((int(event.get("encoder_recoveries") or 0) for event in stats), default=0),
     "frames_sent": max((int(event.get("frames_sent") or 0) for event in stats), default=0),
+    "unfocused_samples": sum(1 for event in events if event["event"] == "stats" and event.get("focused") is False),
   }
   return {key: value for key, value in summary.items() if value is not None}
 
 
+def _trim(value):
+  if isinstance(value, str):
+    return value[:300]
+  if isinstance(value, (dict, list)) and len(json.dumps(value, default=str)) > 600:
+    return json.dumps(value, default=str)[:600]
+  return value
+
+
+def trace_events(events: list[dict]) -> list[dict]:
+  """The session log without routine media and navigation chatter, each event stamped with seconds since the start."""
+  trace = []
+  for event in events:
+    if event["event"] in TRACE_QUIET:
+      continue
+    values = {key: _trim(value) for key, value in event.items() if key not in ("t", "mono_s", "event")}
+    trace.append({"at_s": elapsed(events[0], event), "event": event["event"], **values})
+  return trace
+
+
+def quiet_counts(events: list[dict]) -> dict:
+  """How often each routine event the trace leaves out happened, so nav and media activity stays visible."""
+  counts: dict[str, int] = {}
+  for event in events:
+    if event["event"] in TRACE_QUIET:
+      counts[event["event"]] = counts.get(event["event"], 0) + 1
+  return counts
+
+
+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)}
+
+
 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.android_auto import compat_report
@@ -115,7 +181,7 @@ 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")
-  return {
+  record = {
     "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),
@@ -143,9 +209,37 @@ def session_record(path: Path) -> dict:
     "tls": report["tls"].get("version") or None,
     "head_unit": {key: car[key] for key in ("head_unit_make", "head_unit_model", "head_unit_software_version",
                                             "car_make", "car_model", "car_year") if car.get(key)},
+    "series": stats_series(events),
+    "quiet_events": quiet_counts(events),
     "_report": report,
+    "_trace": trace_events(events),
+    "_system": system_slice.read_sidecar(path),
+    "_dir": path.parent,
     "_names": [car.get("bluetooth_name", ""), car.get("display_name", "")],
   }
+  record["attention"] = attention_reasons(record)
+  return record
+
+
+def attention_reasons(session: dict) -> list[str]:
+  """Why a session needs its full trace and device slice; empty for one that streamed cleanly."""
+  video, reasons = session["video"], []
+  if session["outcome"] != "streamed":
+    reasons.append(session["outcome"])
+  if session["stalls"]:
+    reasons.append("stalls")
+  if session["focus_lost"]:
+    reasons.append("focus_lost")
+  if video.get("encoder_recoveries"):
+    reasons.append("encoder_recoveries")
+  target = video.get("target_fps") or video.get("car_fps")
+  if target and video.get("fps_p10") is not None and video["fps_p10"] < 0.5 * target:
+    reasons.append("low_fps")
+  if video.get("unfocused_samples"):
+    reasons.append("unfocused")
+  if video.get("wifi_dbm_min") is not None and video["wifi_dbm_min"] <= -75:
+    reasons.append("weak_wifi")
+  return reasons
 
 
 def _finished(path: Path) -> bool:
@@ -309,7 +403,16 @@ def drive_event(sessions: list[dict]) -> dict:
     message += "".join(f"\n\n--- Session {session['seq']} ---\n" + sanitize(session_timeline(session), session.get("_names", ()))
                        for session in failed)
   latest = failures[0] if failures else {}
-  return {
+  watched = [session for session in sessions if session["attention"]][-MAX_ATTENTION:]
+  per_trace = min(TRACE_SESSION_BYTES, TRACE_TOTAL_BYTES // max(1, len(watched)))
+  traces = {f"android_auto_trace_session_{session['seq']}": sanitize(
+    {**bounded_trace(session.get("_trace", []), per_trace), "routine_events": session.get("quiet_events", {})},
+    session.get("_names", ())) for session in watched}
+  slices = {f"android_auto_system_session_{session['seq']}": slice_context(session["_system"], session.get("_names", ()))
+            for session in watched[-3:] if session.get("_system")}
+  extra = extra_logs(watched[-1]) if watched else {}
+  reasons = sorted({reason for session in watched for reason in session["attention"]})
+  event = {
     "message": message,
     "level": {"streamed": "info", "recovered": "info", "failed": "error"}.get(summary["outcome"], "warning"),
     "fingerprint": ["android-auto-drive", summary["transport"] or "unknown", label] + (["failures"] if failures else []),
@@ -318,14 +421,76 @@ 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)),
+             **({"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)},
     "contexts": {"android_auto_drive": summary, "android_auto_head_unit": head_unit,
                  **{f"android_auto_session_{index + 1}": _public(session) for index, session in enumerate(sessions)},
                  **{f"android_auto_failure_{index + 1}": {key: value for key, value in failure.items() if key != "summary"}
                     for index, failure in enumerate(failures)},
-                 **{f"android_auto_compat_report_session_{session['seq']}": {"text": compat_text(session)} for session in failed}},
+                 **{f"android_auto_compat_report_session_{session['seq']}": {"text": compat_text(session)} for session in watched},
+                 **traces, **slices, **extra},
   }
+  return fit_event(event)
+
+
+def slice_context(system: dict, names=()) -> dict:
+  """A saved device slice with every line scrubbed of names and SSIDs."""
+  sources = system.get("sources", {})
+  return {"window": system.get("window", {}),
+          **{name: ({"lines": [system_slice.scrub_line(line, names) for line in source["lines"]]} if "lines" in source
+                    else {"error": scrub(source.get("error", ""))}) for name, source in sources.items() if isinstance(source, dict)}}
+
+
+def extra_logs(session: dict) -> dict:
+  """The newest lines of the renderer profile and the car UI log, which sit beside the session logs."""
+  from openpilot.starpilot.system.android_auto import compat_report
+  contexts = {}
+  for name, key in (("render_profile.txt", "android_auto_render_profile"), ("car_ui.log", "android_auto_car_ui")):
+    data = compat_report._tail(session["_dir"] / name, 32 << 10)
+    if data:
+      lines = system_slice.system_snapshot.redact(data).decode(errors="replace").splitlines()[-EXTRA_TAIL_LINES:]
+      contexts[key] = {"lines": [system_slice.scrub_line(line, session.get("_names", ())) for line in lines]}
+  return contexts
+
+
+def event_size(event: dict) -> int:
+  return len(json.dumps(sanitize(event), default=str, allow_nan=False))
+
+
+def shed_order(contexts: dict) -> list[str]:
+  """Context keys from the least to the most valuable, so an oversized report loses detail before it loses the story."""
+  def numbered(prefix):
+    return sorted((key for key in contexts if key.startswith(prefix)), key=lambda key: int(key.rsplit("_", 1)[-1]))
+  return [*(key for key in ("android_auto_render_profile", "android_auto_car_ui") if key in contexts),
+          *numbered("android_auto_system_session_"), *numbered("android_auto_compat_report_session_"),
+          *numbered("android_auto_trace_session_")]
+
+
+def fit_event(event: dict, budget: int = EVENT_BUDGET) -> dict:
+  """Drop optional detail, least valuable first, until the report fits; sessions then lose their series and attempts."""
+  shed = []
+  contexts = event["contexts"]
+  for key in shed_order(contexts):
+    if event_size(event) <= budget:
+      break
+    contexts.pop(key)
+    shed.append(key)
+  for key in [key for key in contexts if key.startswith("android_auto_session_")]:
+    if event_size(event) <= budget:
+      break
+    contexts[key] = {name: value for name, value in contexts[key].items() if name not in ("series", "attempts", "stages", "settings")}
+    shed.append(f"{key}:detail")
+  if shed:
+    event["tags"]["aa.truncated"] = "yes"
+    contexts["android_auto_shed"] = {"dropped": shed}
+  if event_size(event) > budget:
+    event["breadcrumbs"] = {"values": event["breadcrumbs"]["values"][-20:]}
+  if event_size(event) > budget:
+    keep = ("android_auto_drive", "android_auto_head_unit", "android_auto_shed")
+    event["contexts"] = {key: value for key, value in contexts.items() if key in keep or key.startswith("android_auto_failure_")}
+    event["contexts"]["android_auto_shed"] = {"dropped": ["everything but the totals and failures"]}
+  return event
 
 
 def record_pairing(record: dict, path: Path = PAIRING_PATH) -> None:
@@ -358,14 +523,25 @@ def new_pairings(last_seq: int, path: Path = PAIRING_PATH) -> list[dict]:
   return records
 
 
-def pairing_event(record: dict) -> dict:
+def pairing_system(record: dict, collector: Callable[..., dict]) -> dict:
+  """The device's Wi-Fi and Bluetooth activity during a pairing window that did not end in a pairing."""
+  try:
+    start = datetime.fromisoformat(record["started"]).timestamp()
+    system = collector(start, start + float(record.get("duration_s") or record.get("window_s") or 0))
+    return {"android_auto_pairing_system": slice_context(system)}
+  except Exception:
+    return {}
+
+
+def pairing_event(record: dict, collector: Callable[..., dict] | None = None) -> dict:
   result = str(record.get("result", "unknown"))
+  system = pairing_system(record, collector) if collector is not None and result != "paired" else {}
   return {
     "message": f"Android Auto pairing {result}\n\n" + sanitize(pairing_summary(record)),
     "level": "info" if result == "paired" else "warning",
     "fingerprint": ["android-auto-pairing", result],
     "tags": {**software_tags([record]), "aa.report": "pairing", "aa.pairing": result, "aa.transport": record.get("transport", "unknown")},
-    "contexts": {"android_auto_pairing": sanitize(record)},
+    "contexts": {"android_auto_pairing": sanitize(record), **system},
   }
 
 
@@ -387,6 +563,11 @@ class PairingAttempt:
       self.record["steps"].pop(0)
       self.record["steps_omitted"] = self.record.get("steps_omitted", 0) + 1
 
+  def reached_connection(self) -> bool:
+    """The car was approved or connected before the window ended."""
+    return any(step.get("step") == "status" and (step.get("approved") or step.get("state") in ("paired", "connected"))
+               for step in self.record["steps"])
+
   def finish(self, result: str, **values) -> None:
     self.step(result, **values)
     self._sink({**self.record, "result": result, "duration_s": round(self._clock() - self._opened, 1)})
@@ -414,7 +595,8 @@ def _write_atomic(path: Path, text: str) -> None:
 
 
 def send_reports(capture: Callable[..., bool], flush: Callable[[], None] = lambda: None, *, state_path: Path = STATE_PATH,
-                 log_dir: Path | None = None, pairing_path: Path = PAIRING_PATH, now: float | None = None) -> int:
+                 log_dir: Path | None = None, pairing_path: Path = PAIRING_PATH, now: float | None = None,
+                 collector: Callable[..., dict] | None = None) -> int:
   """Send what is new since the last call; returns how many reports were queued.
 
   Capture must return True only after the server accepts the event."""
@@ -424,7 +606,7 @@ def send_reports(capture: Callable[..., bool], flush: Callable[[], None] = lambd
   queued = 0
 
   for record in new_pairings(pairing_seq, pairing_path):
-    if not capture(**pairing_event(record)):
+    if not capture(**pairing_event(record, collector or system_slice.collect)):
       break
     pairing_seq, queued = int(record["seq"]), queued + 1
 
diff --git a/openpilot/starpilot/system/android_auto/car_profiles.py b/openpilot/starpilot/system/android_auto/car_profiles.py
new file mode 100644
index 0000000000..52ac24a729
--- /dev/null
+++ b/openpilot/starpilot/system/android_auto/car_profiles.py
@@ -0,0 +1,58 @@
+"""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}
+
+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}},
+]
+
+
+def profile_ids() -> list[str]:
+  return [rule["id"] for rule in RULES]
+
+
+def valid_override(value: str) -> bool:
+  return value in ("", "default", *profile_ids())
+
+
+def fingerprint_from(head_unit: dict, address: str) -> dict:
+  found = {key: str(head_unit[key])[:80] for key in FINGERPRINT_KEYS if head_unit.get(key)}
+  return {"address": address.upper(), **found} if found else {}
+
+
+def _matches(rule: dict, fingerprint: dict) -> bool:
+  match = rule.get("match") or {}
+  return bool(match) and all(re.search(pattern, str(fingerprint.get(key, "")), re.IGNORECASE) for key, pattern in match.items())
+
+
+def resolve(config: dict) -> tuple[str, str]:
+  """(profile id, source) where source is "override", "detected" or "standard"."""
+  override = config.get("car_profile_override", "")
+  if override == "default":
+    return "default", "override"
+  if override in profile_ids():
+    return override, "override"
+  fingerprint = config.get("car_fingerprint") or {}
+  if fingerprint.get("address") == str(config.get("receiver_address", "")).upper():
+    for rule in RULES:
+      if _matches(rule, fingerprint):
+        return rule["id"], "detected"
+  return "default", "standard"
+
+
+def tuning(config: dict) -> dict:
+  profile, _ = resolve(config)
+  rule = next((item for item in RULES if item["id"] == profile), {})
+  return {**DEFAULTS, **{key: value for key, value in (rule.get("tuning") or {}).items() if key in DEFAULTS}}
+
+
+def summary(config: dict) -> dict:
+  """What the UI may show: nothing at all while the standard behavior applies."""
+  profile, source = resolve(config)
+  rule = next((item for item in RULES if item["id"] == profile), None)
+  return {"car_profile": profile, "car_profile_source": source, "car_profile_label": rule["label"] if rule else "",
+          "car_profile_ids": profile_ids()}
diff --git a/openpilot/starpilot/system/android_auto/daemon.py b/openpilot/starpilot/system/android_auto/daemon.py
index 39df0de9c3..f5ac3d2719 100644
--- a/openpilot/starpilot/system/android_auto/daemon.py
+++ b/openpilot/starpilot/system/android_auto/daemon.py
@@ -28,7 +28,7 @@ from openpilot.starpilot.system.android_auto.source_verifier import GalaxySource
 from openpilot.starpilot.system.android_auto.supervisor import Supervisor
 
 PAIRING_COMMANDS = {"prepare_pairing", "pairing_status", "pairing_response", "cancel_pairing", "pair_device"}
-AUTHENTICATED_COMMANDS = {"start", "set_auto_connect", "select_receiver", "set_view", "set_connection",
+AUTHENTICATED_COMMANDS = {"start", "set_auto_connect", "select_receiver", "set_view", "set_connection", "set_car_type", "set_car_profile",
                           "prepare_pairing", "pairing_status", "pairing_response", "cancel_pairing", "pair_device", "devices", "bluetooth_action",
                           "phone_window", "bluetooth_power"}
 
@@ -124,6 +124,10 @@ def handle(supervisor: Supervisor, request: dict[str, Any], verifier: GalaxySour
     supervisor.set_view(str(request.get("view", "")))
   elif command == "set_connection":
     supervisor.set_connection(str(request.get("connection", "")))
+  elif command == "set_car_type":
+    supervisor.set_car_type(str(request.get("car_type", "")))
+  elif command == "set_car_profile":
+    supervisor.set_car_profile(str(request.get("profile", "")))
   elif command == "prepare_pairing":
     supervisor.prepare_pairing()
   elif command == "pairing_status":
diff --git a/openpilot/starpilot/system/android_auto/device_health.py b/openpilot/starpilot/system/android_auto/device_health.py
new file mode 100644
index 0000000000..16e195e756
--- /dev/null
+++ b/openpilot/starpilot/system/android_auto/device_health.py
@@ -0,0 +1,57 @@
+"""Cheap device load readings for the 30 s Android Auto stats line: plain file reads, no D-Bus and no subprocesses."""
+
+from __future__ import annotations
+
+import glob
+
+
+def _read(path: str) -> str | None:
+  try:
+    with open(path) as handle:
+      return handle.read(4096)
+  except OSError:
+    return None
+
+
+def _first_number(path: str) -> float | None:
+  text = _read(path)
+  try:
+    return float(text.split()[0]) if text else None
+  except (ValueError, IndexError):
+    return None
+
+
+def _meminfo_available_mb() -> int | None:
+  for line in (_read("/proc/meminfo") or "").splitlines():
+    if line.startswith("MemAvailable:"):
+      try:
+        return int(line.split()[1]) // 1024
+      except (ValueError, IndexError):
+        return None
+  return None
+
+
+def wireless_link(interface: str = "wlan0") -> dict:
+  """Link quality, signal and noise of the joined network from /proc/net/wireless."""
+  for line in (_read("/proc/net/wireless") or "").splitlines():
+    name, _, rest = line.partition(":")
+    if name.strip() != interface:
+      continue
+    fields = rest.split()
+    try:
+      return {"wifi_link": int(float(fields[1].rstrip("."))), "wifi_dbm": int(float(fields[2].rstrip("."))),
+              "wifi_noise": int(float(fields[3].rstrip(".")))}
+    except (ValueError, IndexError):
+      return {}
+  return {}
+
+
+def sample(interface: str = "wlan0") -> dict:
+  """Load, free memory, CPU clocks, hottest thermal zone and Wi-Fi link; absent readings are left out."""
+  load = _read("/proc/loadavg")
+  temps = [value / 1000 for path in glob.glob("/sys/class/thermal/thermal_zone*/temp") if (value := _first_number(path)) is not None]
+  clocks = {f"cpu{core}_mhz": round(khz / 1000) for core in (0, 4)
+            if (khz := _first_number(f"/sys/devices/system/cpu/cpu{core}/cpufreq/scaling_cur_freq")) is not None}
+  values = {"load1": float(load.split()[0]) if load else None, "mem_available_mb": _meminfo_available_mb(),
+            "temp_max_c": round(max(temps), 1) if temps else None, **clocks, **wireless_link(interface)}
+  return {key: value for key, value in values.items() if value is not None}
diff --git a/openpilot/starpilot/system/android_auto/identity.py b/openpilot/starpilot/system/android_auto/identity.py
index cdd0bccf85..7de1a3848c 100644
--- a/openpilot/starpilot/system/android_auto/identity.py
+++ b/openpilot/starpilot/system/android_auto/identity.py
@@ -83,7 +83,7 @@ def load_identity(directory: Path | None = None, now: datetime | None = None) ->
                   expires.isoformat() if expires is not None else "unknown", days_left)
 
 
-CONFIG_VERSION = 6
+CONFIG_VERSION = 7
 # Before config versions, every save wrote these defaults, which pinned projection
 # at 12 fps / 4000 kbps. Unversioned files holding exactly them get today's defaults.
 LEGACY_DEFAULTS = {"fps": 12, "bitrate_kbps": 4000}
@@ -131,6 +131,9 @@ 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
+  "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
 }
 
 
@@ -149,6 +152,10 @@ def load_config(path: Path | None = None) -> dict:
         stored = {key: value for key, value in stored.items() if key not in VERIFY_RESET}
       if not isinstance(version, int) or version < 6:
         stored = {key: value for key, value in stored.items() if key not in DEDICATED_WIFI_RESET}
+      if not isinstance(version, int) or version < 7:  # adapter owners from before the adapter model choice keep connecting
+        on_adapter = stored.get("car_type") == "adapter" or (not stored.get("car_type") and stored.get("companion_address"))
+        if on_adapter and not stored.get("car_profile_override"):
+          stored = {**stored, "car_profile_override": "default"}
       config.update({key: value for key, value in stored.items() if key in DEFAULT_CONFIG and isinstance(value, type(DEFAULT_CONFIG[key]))})
   except (OSError, ValueError):
     pass
@@ -160,6 +167,9 @@ def load_config(path: Path | None = None) -> dict:
     config["connection"] = "wireless"
   if not 1024 <= int(config["headunitpad_port"]) <= 65535:
     config["headunitpad_port"] = DEFAULT_CONFIG["headunitpad_port"]
+  if config["car_type"] not in ("", "builtin", "adapter"):
+    config["car_type"] = ""
+  config["car_fingerprint"] = {str(k): str(v)[:80] for k, v in config["car_fingerprint"].items()}
   if config["usb_mode"] not in ("auto", "handshake", "direct"):
     config["usb_mode"] = "auto"
   config["bitrate_kbps"] = max(1000, min(12000, int(config["bitrate_kbps"])))
diff --git a/openpilot/starpilot/system/android_auto/session.py b/openpilot/starpilot/system/android_auto/session.py
index cf3f9398a4..2c8f740dea 100644
--- a/openpilot/starpilot/system/android_auto/session.py
+++ b/openpilot/starpilot/system/android_auto/session.py
@@ -68,6 +68,17 @@ INPUT_EVENT = 0x8001
 INPUT_BINDING_REQUEST = 0x8002
 INPUT_BINDING_RESPONSE = 0x8003
 
+# Car data (sensor) and Bluetooth channels, opened the way a phone does.
+SENSOR_SERVICE = 2
+BLUETOOTH_SERVICE = 6
+SENSOR_START_REQUEST = 0x8001
+SENSOR_START_RESPONSE = 0x8002
+SENSOR_EVENT = 0x8003
+BLUETOOTH_PAIRING_REQUEST = 0x8001
+BLUETOOTH_PAIRING_RESPONSE = 0x8002
+BLUETOOTH_AUTH_DATA = 0x8003
+SENSOR_NIGHT, SENSOR_DRIVING_STATUS = 10, 13
+
 CODEC_H264_BP = 3
 SETUP_STATUS_READY = 2
 FOCUS_PROJECTED = 1
@@ -118,6 +129,18 @@ def codec_config(access_unit: bytes) -> bytes:
   return b"".join(units)
 
 
+def wire_frame(access_unit: bytes, *, drop_config: bool) -> bytes:
+  """The picture NAL units as Android's encoder sends them: no AUD, and no SPS/PPS when the codec config went separately."""
+  starts = list(START_CODE.finditer(access_unit))
+  drop = {9, 7, 8} if drop_config else {9}
+  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 access_unit[match.end()] & 31 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
@@ -184,6 +207,9 @@ def choose_video_mode(channels: list[dict]) -> VideoMode:
 class Session:
   """TLS, framing and control-channel handshake; one instance per TCP connection."""
 
+  # Wireless adapters relay to the car, which can take a while (or wait for the driver) before it answers.
+  DISCOVERY_TIMEOUT = 60.0
+
   def __init__(self, peer, cert: str, key: str, log: Callable[..., None] | None = None, ca: str | None = None, *,
                receive_timeout: float = 3.0, send_timeout: float = 3.0, handshake_timeout: float = 15.0):
     self.peer = peer
@@ -268,10 +294,10 @@ class Session:
         self.peer.settimeout(previous_timeout)
     return -(-len(data) // FRAGMENT_SIZE)
 
-  def receive(self, *, deadline: float | None = None) -> tuple[int, int, bytes]:
+  def receive(self, *, deadline: float | None = None, patient: bool = False) -> tuple[int, int, bytes]:
     """Read one complete message within one deadline, tolerating partial reads."""
     message_deadline = time.monotonic() + (self.receive_timeout if self.authenticated else self.handshake_timeout)
-    deadline = message_deadline if deadline is None else min(deadline, message_deadline)
+    deadline = message_deadline if deadline is None else deadline if patient else min(deadline, message_deadline)
     timed_peer = hasattr(self.peer, "gettimeout") and hasattr(self.peer, "settimeout")
     previous_timeout = self.peer.gettimeout() if timed_peer else None
 
@@ -436,7 +462,7 @@ class Session:
 
   def discover(self, device_name: str, device_brand: str) -> list[dict]:
     self.send(0, MSG_SERVICE_DISCOVERY_REQUEST, field(4, device_name) + field(5, device_brand))
-    raw = self.wait_for(0, MSG_SERVICE_DISCOVERY_RESPONSE)
+    raw = self.wait_for(0, MSG_SERVICE_DISCOVERY_RESPONSE, timeout=self.DISCOVERY_TIMEOUT, patient=True)
     response = parse_fields(raw)
     channels = []
     for descriptor in response.get(1, []):
@@ -469,6 +495,16 @@ class Session:
           item["input_config"] = parse_input_config(one(fields, 4))
         except ValueError:
           item["input_config"] = InputConfig()
+      if isinstance(one(fields, SENSOR_SERVICE), bytes):
+        try:
+          item["sensors"] = [one(parse_fields(s), 1) for s in parse_fields(one(fields, SENSOR_SERVICE)).get(1, []) if isinstance(s, bytes)]
+        except ValueError:
+          item["sensors"] = []
+      if isinstance(one(fields, BLUETOOTH_SERVICE), bytes):
+        try:
+          item["bluetooth"] = parse_bluetooth(one(fields, BLUETOOTH_SERVICE))
+        except ValueError:
+          item["bluetooth"] = {}
       channels.append(item)
     # Everything but the channel list: make, model, year, software and, on newer units, headunit_info.
     head_unit = redact_head_unit(describe_fields({number: values for number, values in response.items() if number != 1}))
@@ -477,10 +513,10 @@ class Session:
                head_unit=head_unit)
     return channels
 
-  def wait_for(self, channel: int, kind: int, timeout: float = 10.0) -> bytes:
+  def wait_for(self, channel: int, kind: int, timeout: float = 10.0, patient: bool = False) -> bytes:
     deadline = time.monotonic() + timeout
     while time.monotonic() < deadline:
-      ch, message, data = self.receive()
+      ch, message, data = self.receive(deadline=deadline, patient=patient)
       if ch == channel and message == kind:
         return data
       self.dispatch(ch, message, data, expected=f"{channel}/{kind:#x}")
@@ -499,6 +535,33 @@ HEAD_UNIT_INFO = 17         # ServiceDiscoveryResponse.headunit_info
 HEAD_UNIT_INFO_VEHICLE_ID = 4
 
 
+def packed_varints(value) -> list[int]:
+  """A repeated enum: packed bytes on newer units, one varint per field on older ones."""
+  if isinstance(value, int):
+    return [value]
+  out, pos = [], 0
+  while pos < len(value):
+    number, shift = 0, 0
+    while True:
+      if pos >= len(value) or shift > 63:
+        raise ValueError("Truncated packed varint")
+      byte = value[pos]
+      pos += 1
+      number |= (byte & 127) << shift
+      shift += 7
+      if byte < 128:
+        break
+    out.append(number)
+  return out
+
+
+def parse_bluetooth(data: bytes) -> dict:
+  fields = parse_fields(data)
+  address = one(fields, 1)
+  methods = [m for value in fields.get(2, []) for m in packed_varints(value)]
+  return {"car_address": address.decode(errors="replace") if isinstance(address, bytes) else "", "pairing_methods": methods}
+
+
 def redact_head_unit(described: dict) -> dict:
   """Drop the vehicle identifier from a described discovery response: logs are shared for diagnosis."""
   if SDR_VEHICLE_ID in described:
@@ -549,6 +612,13 @@ class ProjectionSession(Session):
     self.epoch_acked = 0
     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.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
+    self.sensor_channel: int | None = None
+    self.sensor_events: dict[int, int] = {}
+    self.bluetooth_channel: int | None = None
     self.nav = None  # NavStatus, attached by the supervisor when the head unit offers turn-by-turn
     self.audio = None  # MediaAudio, attached by the supervisor when Spotify plays through Android Auto
     self.input_events = 0
@@ -567,6 +637,8 @@ class ProjectionSession(Session):
     self.mode = choose_video_mode(self.channels)
     self.open_video()
     self.open_input()
+    if self.phone_services:
+      self.open_phone_services()
     self.request_projection()
     return self.mode
 
@@ -585,7 +657,7 @@ class ProjectionSession(Session):
     configs = setup.get(3, [])
     if configs and mode.config_index not in configs:
       raise ValueError(f"Head unit did not accept video configuration {mode.config_index}: {json_fields(setup)}")
-    self.window = min(window, self.MAX_WINDOW)
+    self.window = min(window, self.max_window)
     self.event("video_setup", mode=mode.as_dict(), window=window, used_window=self.window)
 
   def open_input(self) -> None:
@@ -609,6 +681,36 @@ class ProjectionSession(Session):
     except (TimeoutError, ValueError) as error:
       self.event("input_unavailable", error=str(error))
 
+  def _open_optional(self, channel: dict, name: str) -> bool:
+    try:
+      self.send(channel["id"], MSG_CHANNEL_OPEN_REQUEST, field(1, 0) + field(2, channel["id"]), control=True)
+      opened = parse_fields(self.wait_for(channel["id"], MSG_CHANNEL_OPEN_RESPONSE, timeout=3.0))
+      if signed(one(opened, 1)) != 0:
+        raise ValueError(f"channel open rejected: {signed(one(opened, 1))}")
+      return True
+    except (TimeoutError, ValueError) as error:
+      self.event(f"{name}_unavailable", channel=channel["id"], error=str(error))
+      return False
+
+  def open_phone_services(self) -> None:
+    """Open the car-data and Bluetooth channels before asking for the screen, as a phone does. Failures are not fatal."""
+    sensors = next((ch for ch in self.channels if "sensors" in ch), None)
+    if sensors is not None and self._open_optional(sensors, "sensors"):
+      self.sensor_channel = sensors["id"]
+      # Only what decides whether the screen may project; location would put the car's position in the session log.
+      wanted = [kind for kind in (SENSOR_DRIVING_STATUS, SENSOR_NIGHT) if kind in sensors["sensors"]]
+      for kind in wanted:
+        self.send(sensors["id"], SENSOR_START_REQUEST, field(1, kind) + field(2, 0))
+      self.event("sensors_opened", channel=sensors["id"], requested=wanted)
+    bluetooth = next((ch for ch in self.channels if "bluetooth" in ch), None)
+    if bluetooth is not None and self._open_optional(bluetooth, "bluetooth"):
+      self.bluetooth_channel = bluetooth["id"]
+      methods = bluetooth["bluetooth"].get("pairing_methods") or []
+      if self.phone_address:
+        self.send(bluetooth["id"], BLUETOOTH_PAIRING_REQUEST, field(1, self.phone_address) + field(2, methods[0] if methods else 2))
+      self.event("bluetooth_opened", channel=bluetooth["id"], phone_address=self.phone_address,
+                 car_address=bluetooth["bluetooth"].get("car_address", ""), pairing_methods=methods)
+
   def request_projection(self) -> None:
     """Ask for display focus; the Mazda donor needed this, DHU grants it unsolicited."""
     assert self.mode is not None
@@ -693,6 +795,24 @@ class ProjectionSession(Session):
         self.event("input_bound", status=signed(one(fields, 1, 0)))
       else:
         self.ignored("input_ignored", channel, kind, data)
+    elif channel is not None and channel == self.sensor_channel:
+      if kind == SENSOR_START_RESPONSE:
+        self.event("sensor_started", status=signed(one(fields, 1, 0)))
+      elif kind == SENSOR_EVENT:
+        for number, values in fields.items():
+          first = number not in self.sensor_events
+          self.sensor_events[number] = self.sensor_events.get(number, 0) + len(values)
+          if first:
+            self.event("sensor_event", field=number, data=describe_fields(fields))
+      else:
+        self.ignored("sensor_ignored", channel, kind, data)
+    elif channel is not None and channel == self.bluetooth_channel:
+      if kind == BLUETOOTH_PAIRING_RESPONSE:
+        self.event("bluetooth_pairing_response", already_paired=one(fields, 1), status=signed(one(fields, 2, 0)))
+      elif kind == BLUETOOTH_AUTH_DATA:
+        self.event("bluetooth_auth_data", data=describe_fields(fields))
+      else:
+        self.ignored("bluetooth_ignored", channel, kind, data)
     else:
       self.ignored("channel_ignored", channel, kind, data)
 
@@ -803,12 +923,15 @@ class ProjectionSession(Session):
       raise ValueError("A fresh media epoch must start with SPS/PPS and an IDR frame")
     assert self.mode is not None
     fragments = 0
+    config = b""
     if self.needs_keyframe:
       config = 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))
     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)
@@ -839,4 +962,5 @@ class ProjectionSession(Session):
   def stats(self) -> dict:
     return {"frames_sent": self.frames_sent, "frames_acked": self.acked, "pending": self.unacked,
             "focus_epoch": self.focus_epoch, "focused": self.focused, "max_ack_ms": round(self.max_ack_seconds * 1000),
-            "input_events": self.input_events, "touch": self.touch is not None}
+            "input_events": self.input_events, "touch": self.touch is not None,
+            "sensor_events": sum(self.sensor_events.values())}
diff --git a/openpilot/starpilot/system/android_auto/supervisor.py b/openpilot/starpilot/system/android_auto/supervisor.py
index 2ea8e7550c..d280134064 100644
--- a/openpilot/starpilot/system/android_auto/supervisor.py
+++ b/openpilot/starpilot/system/android_auto/supervisor.py
@@ -16,6 +16,7 @@ on Stop. Nothing here runs as root or touches vehicle control.
 
 from __future__ import annotations
 
+import errno
 import ipaddress
 import json
 import math
@@ -32,7 +33,7 @@ from pathlib import Path
 from typing import Any
 
 from openpilot.common.hardware import COMMA_HARDWARE
-from openpilot.starpilot.system.android_auto import identity as identity_store
+from openpilot.starpilot.system.android_auto import car_profiles, device_health, identity as identity_store, system_slice
 from openpilot.starpilot.system.android_auto.auto_connect import AutoConnectPolicy
 from openpilot.starpilot.system.android_auto.bootstrap import NAMES, BootstrapError, WirelessBootstrap
 from openpilot.starpilot.system.android_auto.bugsink_report import PairingAttempt
@@ -59,6 +60,7 @@ 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"
+NO_ANDROID_AUTO_WAIT = 8.0    # a paired device must offer Android Auto within this long, or we say it does not
 USB_HANDSHAKE_WAIT = 10.0    # the car connected but sent no AOA START this long -> present as an accessory directly
 USB_CONFIGURE_WAIT = 15.0    # slower receivers need time to enumerate after the AOA switch
 LINK_CHECK_INTERVAL = 1.0    # how often the link watcher asks whether the car's Wi-Fi is still up
@@ -93,11 +95,8 @@ def _is_onroad() -> bool:
     return False
 
 
-def wired_blocker() -> str:
-  """Why wired USB must not take the comma's USB-C port, or "" when it is free.
-
-  Chestnut and Jetlink's computer link both use that port.
-  """
+def jetlink_blocker() -> str:
+  """Why wired USB cannot connect right now: Jetlink's computer link is using the USB-C port. Wired can still be chosen."""
   try:
     from openpilot.common.params import Params
     mode = Params().get("JetlinkMode")
@@ -105,6 +104,11 @@ def wired_blocker() -> str:
       return "Turn off Jetlink to use wired Android Auto"
   except Exception:
     pass
+  return ""
+
+
+def chestnut_blocker() -> str:
+  """Why wired USB cannot be chosen at all: a Chestnut is plugged into the comma's USB-C port."""
   try:
     from openpilot.starpilot.models.jetlink_adapter import adapter
     if adapter().chestnut_present():
@@ -114,6 +118,11 @@ def wired_blocker() -> str:
   return ""
 
 
+def wired_blocker() -> str:
+  """Why wired USB must not take the comma's USB-C port, or "" when it is free."""
+  return jetlink_blocker() or chestnut_blocker()
+
+
 class Cancelled(Exception):
   pass
 
@@ -151,6 +160,14 @@ def _wifi_dbm(interface: str = "wlan0") -> int | None:
   return None
 
 
+LOCAL_SOCKET_ERRORS = (errno.ENOSYS, errno.EAFNOSUPPORT, errno.EPROTONOSUPPORT)
+
+
+def car_never_answered(error: BaseException) -> bool:
+  """False when this device's own Bluetooth stack failed, so the car's cached channel says nothing about the car."""
+  return not (isinstance(error, OSError) and error.errno in LOCAL_SOCKET_ERRORS)
+
+
 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:]
@@ -220,6 +237,8 @@ class EventLog:
     self._writer: threading.Thread | None = None
     self._writer_stop: threading.Event | None = None
     self._dropped = 0
+    self.path: Path | None = None
+    self.started = 0.0
 
   def open(self) -> None:
     try:
@@ -227,6 +246,7 @@ class EventLog:
       logs = sorted(self.directory.glob("session-*.jsonl"), key=identity_store.session_log_order)
       for old in logs[:max(0, len(logs) - MAX_LOG_FILES + 1)]:
         old.unlink(missing_ok=True)
+      system_slice.prune_sidecars(self.directory)
       number = max([0, *(identity_store.session_log_order(log)[0] for log in logs)]) + 1
       path = self.directory / f"session-{number:06d}-{identity_store.timestamp()}.jsonl"
       fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_APPEND, 0o600)
@@ -234,6 +254,7 @@ class EventLog:
     except OSError:
       return
     with self.lock:
+      self.path, self.started = path, datetime.now(UTC).timestamp()
       self._queue = queue.Queue(maxsize=LOG_QUEUE_MAX)
       self._dropped = 0
       self._writer_stop = threading.Event()
@@ -267,6 +288,11 @@ class EventLog:
     stopped.set()
     writer.join(timeout=2.0)
 
+  def capture_system(self) -> None:
+    """Save what the device was doing during this session beside its log, off the session's thread."""
+    if self.path is not None:
+      system_slice.write_sidecar_async(self.path, self.started, datetime.now(UTC).timestamp())
+
   def _line(self, record: dict) -> str:
     return json.dumps(record, default=str) + "\n"
 
@@ -286,6 +312,8 @@ class EventLog:
 
 
 class Supervisor:
+  _pairing_note = ""      # why a paired car was not chosen, kept after the pairing window closes
+  _no_aa_since = 0.0
   def __init__(self, bluez_factory=None, lease_factory=None, bluetooth_client=None, frame_path: str | None = None,
                synthetic: bool = False, car_frame_path: str = CAR_FRAME_PATH, touch_path: str = DEFAULT_TOUCH_SOCKET,
                control_path: str = DEFAULT_CONTROL_SOCKET, renderer_command: list[str] | None = None, onroad=_is_onroad,
@@ -347,9 +375,14 @@ class Supervisor:
     status["receiver_name"] = self.config["receiver_name"]
     status["companion_address"] = self.config.get("companion_address", "")
     status["companion_name"] = self.config.get("companion_name", "")
+    status["pairing_note"] = self._pairing_note
+    status["car_type"] = self.car_type()
+    status.update(car_profiles.summary(self.config))
+    status["adapter_choice_needed"] = self._adapter_choice_needed()
     status["configured_view"] = self.config["view"]
     status["connection"] = self.config["connection"]
-    status["wired_blocked"] = wired_blocker()
+    status["wired_blocked"] = chestnut_blocker()
+    status["wired_busy"] = jetlink_blocker()
     status["pairing_ready"] = self._pairing_active()
     status["auto_connect"] = bool(self.config["auto_connect"])
     status["dedicated_wifi_interface"] = bool(self.config["dedicated_wifi_interface"])
@@ -381,10 +414,15 @@ class Supervisor:
       identity_store.save_config(self.config)
     self.log("dedicated_wifi_selected", enabled=bool(enabled))
 
+  def _adapter_choice_needed(self) -> bool:
+    return self.car_type() == "adapter" and not self.config.get("car_profile_override")
+
   def start(self, trigger: str = "manual") -> None:
     with self._lock:
       if not self._projection_enabled():
         raise RuntimeError("Android Auto is disabled")
+      if self._adapter_choice_needed():
+        raise RuntimeError("Choose your adapter model (AAWireless or Other) in Galaxy first")
       if self.config["connection"] == "wired" and (reason := wired_blocker()):
         raise RuntimeError(reason)
       if self._thread is not None and self._thread.is_alive():
@@ -430,7 +468,7 @@ class Supervisor:
       if self._bluez is not None and self.config['receiver_address'] and self.config['receiver_address'] != address:
         self._bluez.release()
       if self.config["receiver_address"] != address:
-        self.config.update(companion_address="", companion_name="")
+        self.config.update(companion_address="", companion_name="", car_fingerprint={})
       self.config.update(receiver_address=address, receiver_name=name or address)
       identity_store.save_config(self.config)
     self._unselect_car_audio(address)
@@ -458,7 +496,7 @@ class Supervisor:
       if chosen:
         if self._bluez is not None:
           self._bluez.release()
-        self.config.update(receiver_address="", receiver_name="", companion_address="", companion_name="")
+        self.config.update(receiver_address="", receiver_name="", companion_address="", companion_name="", car_fingerprint={})
       elif companion:
         self.config.update(companion_address="", companion_name="")
       identity_store.save_config(self.config)
@@ -478,7 +516,7 @@ class Supervisor:
     """Choose wireless (Bluetooth + car Wi-Fi), wired (USB), or HeadunitPad or Open Headunit (on the Galaxy hotspot) projection."""
     if connection not in identity_store.CONNECTIONS:
       raise RuntimeError(f"Unknown connection {connection!r}")
-    if connection == "wired" and (reason := wired_blocker()):
+    if connection == "wired" and (reason := chestnut_blocker()):
       raise RuntimeError(reason)
     with self._lock:
       if self._thread is not None and self._thread.is_alive():
@@ -487,8 +525,55 @@ class Supervisor:
       identity_store.save_config(self.config)
     self.log("connection_selected", connection=connection)
 
+  def car_type(self) -> str:
+    """What is in the car, for the setup page: wired and tablet follow the connection, wireless is built-in or an adapter."""
+    connection = self.config["connection"]
+    if connection == "wired":
+      return "usb"
+    if connection in ("headunitpad", "openheadunit"):
+      return "app"
+    return self.config["car_type"] or ("adapter" if self.config.get("companion_address") else "builtin")
+
+  def set_car_type(self, car_type: str) -> None:
+    if car_type not in ("builtin", "adapter", "usb", "app"):
+      raise RuntimeError(f"Unknown car type {car_type!r}")
+    previous_wireless_type = self.config["car_type"] or ("adapter" if self.config.get("companion_address") else "builtin")
+    connection = {"usb": "wired", "app": "headunitpad" if self.config["connection"] not in ("headunitpad", "openheadunit")
+                  else self.config["connection"]}.get(car_type, "wireless")
+    if connection != self.config["connection"]:
+      self.set_connection(connection)
+    if car_type in ("builtin", "adapter"):
+      with self._lock:
+        self.config["car_type"] = car_type
+        if previous_wireless_type != car_type:
+          if self._bluez is not None and self.config["receiver_address"]:
+            self._bluez.release()
+          self.config.update(receiver_address="", receiver_name="", companion_address="", companion_name="", car_fingerprint={})
+        if car_type != "adapter":
+          self.config["car_profile_override"] = ""  # the adapter model only applies to a wireless adapter
+        identity_store.save_config(self.config)
+    self.log("car_type_selected", car_type=car_type)
+
+  def set_car_profile(self, profile: str) -> None:
+    """Pin a car profile ("default" for standard behavior) or go back to picking it by fingerprint ("")."""
+    if not car_profiles.valid_override(profile):
+      raise RuntimeError(f"Unknown car profile {profile!r}")
+    with self._lock:
+      self.config["car_profile_override"] = profile
+      identity_store.save_config(self.config)
+    self.log("car_profile_selected", profile=profile or "auto")
+
+  def _remember_fingerprint(self, head_unit: dict) -> None:
+    fingerprint = car_profiles.fingerprint_from(head_unit, self.config["receiver_address"])
+    if fingerprint and fingerprint != self.config.get("car_fingerprint"):
+      with self._lock:
+        self.config["car_fingerprint"] = fingerprint
+        identity_store.save_config(self.config)
+
   def prepare_pairing(self, seconds: float = 180.0) -> None:
     """Present as a phone (HFP gateway, smartphone class) while the car pairs."""
+    if self._adapter_choice_needed():
+      raise RuntimeError("Choose your adapter model (AAWireless or Other) in Galaxy first")
     if self._bluez_factory is None and (self._source_session is None or self._shared_bluetooth_owner is None or
                                         not self._shared_bluetooth_owner.session_valid(self._source_session)):
       raise RuntimeError('Current Galaxy pairing authorization required')
@@ -506,6 +591,7 @@ class Supervisor:
       self._pairing_known = known
       self._pairing_until = time.monotonic() + seconds
       self._pairing_attempt, self._pairing_seen = PairingAttempt(seconds), ()
+      self._pairing_note, self._no_aa_since = "", 0.0
     self.log("pairing_window", seconds=seconds)
 
   def pair_device(self, address: str) -> None:
@@ -533,6 +619,8 @@ class Supervisor:
     with self._lock:
       attempt, self._pairing_attempt = getattr(self, '_pairing_attempt', None), None
     if attempt is not None:
+      if result in ("interrupted", "cancelled", "expired") and attempt.reached_connection():
+        values["ended"], result = result, "paired_not_selected"
       attempt.finish(result, **values)
 
   def pairing_response(self, prompt_id: str, accepted: bool, value: str = '') -> None:
@@ -715,6 +803,7 @@ class Supervisor:
               self._shared_bluetooth_owner.phone_lease is not None and
               self._shared_bluetooth_owner.phone_lease.receiver == device["address"])]
       if not new:
+        self._note_missing_android_auto(devices, receiver)
         return
     with self._lock:
       attempt, self._pairing_attempt = getattr(self, '_pairing_attempt', None), None
@@ -729,6 +818,23 @@ class Supervisor:
       if attempt is not None:
         attempt.finish("select_failed", error=str(error))
 
+  def _note_missing_android_auto(self, devices: list, receiver: dict | None) -> None:
+    """An approved, paired device that still does not offer wireless Android Auto after a short wait is not a car we can use."""
+    device = next((item for item in devices if receiver is not None and item["address"] == receiver["address"] and
+                   item["paired"] and not item.get("android_auto")), None)
+    if device is None:
+      self._no_aa_since = 0.0
+      return
+    now = time.monotonic()
+    if not self._no_aa_since:
+      self._no_aa_since = now
+    elif now - self._no_aa_since >= NO_ANDROID_AUTO_WAIT and not self._pairing_note:
+      name = device["name"] or "This device"
+      hint = "Using a wireless adapter? Choose Wireless adapter, pair the adapter here, then connect your car on the Bluetooth page."
+      self._pairing_note = f"{name} paired, but it doesn't offer wireless Android Auto. {hint}"
+      self._pairing_step("no_android_auto")
+      self.log("pairing_no_android_auto", address=device["address"])
+
   def close(self) -> None:
     self.stop()
     if self._bluez is not None:
@@ -793,6 +899,8 @@ class Supervisor:
     owner = self._shared_bluetooth_owner
     if owner is None:
       return None
+    if operation == 'forget' and self.config['receiver_address'].upper() == address.upper():
+      return self._forget_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.
@@ -825,6 +933,22 @@ class Supervisor:
         identity_store.save_config(self.config)
       return result
 
+  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
+    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.manual_stop(self._session_alive())
+    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)
+    return result
+
   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()
@@ -1014,6 +1138,7 @@ class Supervisor:
         self.log("bluetooth_release_failed", error=str(error))
       self.log("session_stop")
       self.log.close()
+      self.log.capture_system()
       self._set(state="idle", detail="", running=False, retry_in=0.0, mode=None)
 
   @staticmethod
@@ -1051,6 +1176,9 @@ class Supervisor:
       self.log('companion_car_connected', address=companion)
     elif device.get('android_auto') and '0000111e-0000-1000-8000-00805f9b34fb' not in device.get('uuids', []):
       raise RuntimeError('Connect your paired car in Galaxy Bluetooth first to select it for this Android Auto adapter')
+    if delay := car_profiles.tuning(config)["connect_delay_s"]:
+      self.log("car_profile_connect_delay", seconds=delay)
+      self._wait(delay)
     bluez.connect_device(address)
     self._wait(1.0)
 
@@ -1071,14 +1199,15 @@ class Supervisor:
                                version_status=int(config.get("version_status", 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:
-      if source == "cache" and not self._stop.is_set() and self._status["last_stage"] in ("rfcomm", "wifi_start"):
+    except Exception as error:
+      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)
       raise
     if source == "sdp":
       self._remember_channel(address, channel)
     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
     keepalive_stop = threading.Event()
     threading.Thread(target=boot.keepalive, args=(keepalive_stop,), name="aa_rfcomm_keepalive", daemon=True).start()
@@ -1284,12 +1413,25 @@ class Supervisor:
         self._wait(1.0 + attempt * 0.5)
     raise RuntimeError(f"Car did not accept the projection connection: {last_error}")
 
+  def _adapter_address(self) -> str:
+    """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
+      return ""
+
   def _project(self, result, lease, ident, connect=None, fragment_acks: bool = False) -> None:
     config = self.config
     sock = connect() if connect is not None else self._connect_tcp(result, lease)
     ca = ident.root if config.get("verify_head_unit", False) else None
     session = ProjectionSession(sock, ident.cert, ident.key, self.log, ca)
     session.fragment_acks = fragment_acks
+    tuning = car_profiles.tuning(config)
+    session.max_window = tuning["max_window"]
+    session.phone_frames = tuning["phone_frames"]
+    if tuning["phone_services"]:
+      session.phone_services = True
+      session.phone_address = self._adapter_address()
     self._stage("authenticating")
     session.authenticate()
     self._stage("negotiating")
@@ -1466,7 +1608,7 @@ class Supervisor:
                  "uptime_s": round(now - started), "frames_from_view": source.frames, "wifi_dbm": watch.wifi_dbm}
         self._set(stats=stats)
         if int(now - started) % 30 == 0:
-          self.log("stats", **stats)
+          self.log("stats", **{**device_health.sample(getattr(watch.lease, "interface", "wlan0")), **stats})
           encode_peak = 0.0  # the peak covers each logged 30 s window
       spent = time.monotonic() - pass_started
       if spent > STREAM_STALL_LOG:
diff --git a/openpilot/starpilot/system/android_auto/system_slice.py b/openpilot/starpilot/system/android_auto/system_slice.py
new file mode 100644
index 0000000000..76098c946f
--- /dev/null
+++ b/openpilot/starpilot/system/android_auto/system_slice.py
@@ -0,0 +1,118 @@
+"""Bounded device logs captured beside an Android Auto session log."""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import threading
+from datetime import UTC, datetime
+from pathlib import Path
+
+from openpilot.starpilot.system.android_auto import identity as identity_store
+from openpilot.starpilot.system.android_auto import system_snapshot
+
+MARGIN_S = 30
+DEADLINE_S = 6.0
+MAX_LINES = 250          # per source; the newest lines of the window
+MAX_LINE = 300
+SIDECAR_SUFFIX = ".system.json"
+QUOTED = re.compile(r"'[^']*'|\"[^\"]*\"")
+SSID = re.compile(r"(?i)\b(e?ssid)\b[=: ]+\S+")
+
+
+def _timestamp(value: float) -> str:
+  return datetime.fromtimestamp(value, UTC).strftime("%Y-%m-%d %H:%M:%S")
+
+
+def commands(start: float, end: float) -> dict[str, list[str]]:
+  """Window-limited journals plus point-in-time state; every command runs at the lowest priority."""
+  journal = ["nice", "-n", "19", "journalctl", "--no-pager", "-q", "-o", "short-iso-precise", "--utc",
+             "--since", _timestamp(start - MARGIN_S), "--until", _timestamp(end + MARGIN_S), "-n", "2000"]
+  return {
+    "network": [*journal, "-u", "NetworkManager", "-u", "wpa_supplicant"],
+    "bluetooth": [*journal, "-u", "bluetooth"],
+    "kernel": [*journal, "-k"],
+    "wifi_link": ["nice", "-n", "19", "nmcli", "-t", "-f", "DEVICE,ACTIVE,CHAN,FREQ,SIGNAL", "device", "wifi", "list", "--rescan", "no"],
+    "devices": ["nice", "-n", "19", "nmcli", "-t", "-f", "DEVICE,TYPE,STATE", "device"],
+    "processes": ["nice", "-n", "19", "ps", "-eo", "pid,psr,ni,pcpu,pmem,rss,etime,stat,comm", "--sort=-pcpu"],
+  }
+
+
+def scrub_line(line: str, names=()) -> str:
+  """One log line without hardware addresses' leading bytes, quoted names, SSIDs or any known car or phone name."""
+  for name in names:
+    if name:
+      line = line.replace(str(name), "<name>")
+  line = system_snapshot._MAC.sub("<address>", line)
+  return SSID.sub(lambda match: match[1] + " <ssid>", QUOTED.sub("'<name>'", line))[:MAX_LINE]
+
+
+def _lines(data: bytes) -> list[str]:
+  text = system_snapshot.redact(data).decode("utf-8", errors="replace")
+  return [line for line in text.splitlines() if line.strip()][-MAX_LINES:]
+
+
+def collect(start: float, end: float, *, collector=system_snapshot.collect) -> dict:
+  """The slice for [start, end] (epoch seconds), each source as {"lines": [...]} or {"error": ...}."""
+  files = collector(start, DEADLINE_S, command_set=commands(start, end))
+  try:
+    manifest = json.loads(files.get("manifest.json", b"{}"))["commands"]
+  except (ValueError, KeyError, TypeError):
+    manifest = {}
+  result = {"window": {"start": _timestamp(start), "end": _timestamp(end)}, "sources": {}}
+  for name in commands(start, end):
+    entry = manifest.get(name, {})
+    if name in files:
+      result["sources"][name] = {"lines": _lines(files[name])}
+    else:
+      result["sources"][name] = {"error": entry.get("error") or f"no output (exit {entry.get('exit')})"}
+    if entry.get("error") and name in files:
+      result["sources"][name]["error"] = entry["error"]
+  proc = files.get("proc.txt")
+  if proc:
+    result["sources"]["proc"] = {"lines": _lines(proc)}
+  return result
+
+
+def sidecar_path(log_path: Path) -> Path:
+  match = re.fullmatch(r"session-(\d{6})-.*\.jsonl", log_path.name)
+  return log_path.with_name(f"session-{match[1] if match else log_path.stem}{SIDECAR_SUFFIX}")
+
+
+def write_sidecar(log_path: Path, start: float, end: float, *, collector=system_snapshot.collect) -> None:
+  """Capture the window and save it beside the session log; never raises."""
+  try:
+    path = sidecar_path(log_path)
+    text = json.dumps(collect(start, end, collector=collector))
+    temporary = path.with_name(path.name + ".tmp")
+    fd = os.open(temporary, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
+    with os.fdopen(fd, "w") as handle:
+      handle.write(text)
+    os.replace(temporary, path)
+  except Exception:
+    pass
+
+
+def write_sidecar_async(log_path: Path, start: float, end: float) -> threading.Thread:
+  thread = threading.Thread(target=write_sidecar, args=(log_path, start, end), name="aa_system_slice", daemon=True)
+  thread.start()
+  return thread
+
+
+def read_sidecar(log_path: Path) -> dict:
+  try:
+    value = json.loads(sidecar_path(log_path).read_text())
+    return value if isinstance(value, dict) else {}
+  except (OSError, ValueError):
+    return {}
+
+
+def prune_sidecars(directory: Path | None = None) -> None:
+  """Remove sidecars whose session log has been pruned."""
+  directory = directory or identity_store.LOG_DIR
+  kept = {identity_store.session_log_order(path)[0] for path in directory.glob("session-*.jsonl")}
+  for path in directory.glob(f"session-*{SIDECAR_SUFFIX}*"):
+    match = re.match(r"session-(\d{6})\.", path.name)
+    if not match or int(match[1]) not in kept:
+      path.unlink(missing_ok=True)
diff --git a/openpilot/starpilot/system/android_auto/tests/fake_head_unit.py b/openpilot/starpilot/system/android_auto/tests/fake_head_unit.py
index 24b137d212..0983940f1c 100644
--- a/openpilot/starpilot/system/android_auto/tests/fake_head_unit.py
+++ b/openpilot/starpilot/system/android_auto/tests/fake_head_unit.py
@@ -63,12 +63,21 @@ def video_config(resolution: int, margin_w: int = 0, margin_h: int = 0) -> bytes
   return field(1, resolution) + field(2, 2) + field(3, margin_w) + field(4, margin_h) + field(5, 160)
 
 
-def discovery_response(video_channel: int = 3, input_channel: int = 1) -> bytes:
+SENSOR_CHANNEL, BLUETOOTH_CHANNEL = 7, 8
+
+
+def discovery_response(video_channel: int = 3, input_channel: int = 1, *, phone_services: bool = False) -> bytes:
+  """``phone_services`` adds the car-data and Bluetooth channels (sensor types one per entry, pairing method packed)."""
   av = field(1, 3) + field(4, video_config(1)) + field(4, video_config(2, 0, 240))
   video = field(1, video_channel) + field(3, av)
   audio = field(1, 4) + field(3, field(1, 1))
   touch = field(1, input_channel) + field(4, field(1, 84) + field(1, 4) + field(2, field(1, 1280) + field(2, 720)))
-  return field(1, video) + field(1, audio) + field(1, touch) + field(2, "Honda") + field(3, "Civic")
+  extra = b""
+  if phone_services:
+    sensors = b"".join(field(1, field(1, kind)) for kind in (1, 3, 7, 8, 10, 13, 21))
+    extra = (field(1, field(1, SENSOR_CHANNEL) + field(2, sensors)) +
+             field(1, field(1, BLUETOOTH_CHANNEL) + field(6, field(1, "F8:36:9B:0A:7D:C8") + field(2, bytes([2])))))
+  return field(1, video) + field(1, audio) + field(1, touch) + extra + field(2, "Honda") + field(3, "Civic")
 
 
 class FakeHeadUnit:
@@ -76,8 +85,13 @@ class FakeHeadUnit:
 
   def __init__(self, identity: dict[str, Path], *, window: int = 4, reject_auth: bool = False, require_client_cert: bool = True,
                unsolicited_focus: bool = False, version: tuple[int, int] = (1, 7), ack_codec_config: bool | int = True,
-               connect_to: tuple[str, int] | None = None, ack_fragments: bool = False):
+               connect_to: tuple[str, int] | None = None, ack_fragments: bool = False,
+               phone_services: bool = False):
+    self.phone_services = phone_services
+    self.sensor_requests: list[int] = []
+    self.pairing_requests: list[tuple[str, int]] = []
     self.unsolicited_focus = unsolicited_focus
+    self.opened: list[int] = []
     self.connect_to = connect_to
     self.ack_fragments = ack_fragments
     self.fragments = 0
@@ -218,7 +232,7 @@ class FakeHeadUnit:
       fields = parse_fields(data) if kind not in (0, 1) else {}
       if channel == 0 and kind == 5:
         self.device_name = one(fields, 4, b"").decode()
-        self._send(0, 6, discovery_response())
+        self._send(0, 6, discovery_response(phone_services=self.phone_services))
       elif channel == 0 and kind == 11:
         self._send(0, 12, data)
       elif channel == 0 and kind == 15:
@@ -226,7 +240,17 @@ class FakeHeadUnit:
         self.shutdown_received.set()
         return
       elif kind == 7:
+        self.opened.append(channel)
         self._send(channel, 8, field(1, 0), control=True)
+      elif self.phone_services and channel == SENSOR_CHANNEL and kind == 0x8001:
+        self.sensor_requests.append(int(one(fields, 1, 0) or 0))
+        self._send(SENSOR_CHANNEL, 0x8002, field(1, 0))
+        if one(fields, 1) == 13:
+          self._send(SENSOR_CHANNEL, 0x8003, field(13, field(1, 0)))  # driving status: unrestricted
+      elif self.phone_services and channel == BLUETOOTH_CHANNEL and kind == 0x8001:
+        address = one(fields, 1, b"")
+        self.pairing_requests.append((address.decode() if isinstance(address, bytes) else "", int(one(fields, 2, 0) or 0)))
+        self._send(BLUETOOTH_CHANNEL, 0x8002, field(1, 1) + field(2, 0))  # not paired
       elif channel == 3 and kind == 0x8000:
         self._send(3, 0x8003, field(1, 2) + field(2, self.window) + field(3, 1))
         if self.unsolicited_focus:  # like the DHU: grant focus before the phone asks
diff --git a/openpilot/starpilot/system/android_auto/tests/test_android_auto.py b/openpilot/starpilot/system/android_auto/tests/test_android_auto.py
index 7bb601cd2a..c4c3d21bea 100644
--- a/openpilot/starpilot/system/android_auto/tests/test_android_auto.py
+++ b/openpilot/starpilot/system/android_auto/tests/test_android_auto.py
@@ -12,8 +12,10 @@ import pytest
 from openpilot.starpilot.system.android_auto import bootstrap as bs
 from openpilot.starpilot.system.android_auto import hfp, sdp
 from openpilot.starpilot.system.android_auto.frame_source import FrameConsumer, FrameProducer, FrameRequest, fit_content
-from openpilot.starpilot.system.android_auto.session import (AuthenticationRejected, ProjectionSession, VideoMode, choose_video_mode)
-from openpilot.starpilot.system.android_auto.tests.fake_head_unit import FakeHeadUnit, make_identity, rfcomm_head_unit
+from openpilot.starpilot.system.android_auto.session import (AuthenticationRejected, ProjectionSession, START_CODE, VideoMode, choose_video_mode,
+                                                              wire_frame)
+from openpilot.starpilot.system.android_auto.tests.fake_head_unit import (BLUETOOTH_CHANNEL, SENSOR_CHANNEL, FakeHeadUnit, make_identity,
+                                                                     rfcomm_head_unit)
 from openpilot.starpilot.system.android_auto.wire import field, one, parse_fields, signed
 
 
@@ -569,6 +571,86 @@ def test_session_sends_codec_config_before_each_epoch(identity, ack_codec_config
   assert hu.codec_configs == [(1, sps_pps, 0), (2, sps_pps, 4)]  # one per epoch, before its keyframe
 
 
+def test_wire_frame_drops_aud_and_optionally_config():
+  aud, sps, pps, idr = b"\x00\x00\x00\x01\x09\xf0", b"\x00\x00\x00\x01\x67\x42", b"\x00\x00\x00\x01\x68\xce", b"\x00\x00\x00\x01\x65\x88"
+  assert wire_frame(aud + sps + pps + idr, drop_config=True) == idr
+  assert wire_frame(aud + sps + pps + idr, drop_config=False) == sps + pps + idr
+  assert wire_frame(b"junk", drop_config=True) == b"junk"
+
+
+def test_session_sends_picture_units_only_when_asked(identity):
+  hu = FakeHeadUnit(identity)
+  session = connect(hu, identity)
+  session.phone_frames = True
+  session.authenticate()
+  session.start("StarPilot", "comma.ai")
+  pump_until(session, lambda: session.focused)
+  session.send_frame(b"\x00\x00\x00\x01\x09\xf0\x00\x00\x00\x01\x67\x42\x00\x00\x00\x01\x68\xce\x00\x00\x00\x01\x65\x88", 1, keyframe=True)
+  pump_until(session, lambda: session.unacked == 0)
+  session.shutdown()
+  session.peer.close()
+  hu.thread.join(5)
+  assert hu.error is None, hu.error
+  for _, frame in hu.frames:
+    assert frame and all(frame[m.end()] & 31 not in (7, 8, 9) for m in START_CODE.finditer(frame))
+
+
+@pytest.mark.parametrize("max_window, offered, used", [(2, 30, 2), (30, 30, 30), (30, 100, 30), (30, 4, 4)])
+def test_session_streams_at_the_window_the_profile_allows(identity, max_window, offered, used):
+  hu = FakeHeadUnit(identity, window=offered)
+  session = connect(hu, identity)
+  session.max_window = max_window
+  session.authenticate()
+  session.start("StarPilot", "comma.ai")
+  assert session.window == used
+  session.shutdown()
+  session.peer.close()
+  hu.thread.join(5)
+
+
+def test_session_opens_car_data_and_bluetooth_like_a_phone(identity):
+  hu = FakeHeadUnit(identity, phone_services=True)
+  session = connect(hu, identity)
+  session.phone_services = True
+  session.phone_address = "39:90:21:64:07:00"
+  session.authenticate()
+  session.start("StarPilot", "comma.ai")
+  pump_until(session, lambda: session.focused and session.sensor_events)
+  session.shutdown()
+  session.peer.close()
+  hu.thread.join(5)
+  assert hu.error is None
+  assert {SENSOR_CHANNEL, BLUETOOTH_CHANNEL} <= set(hu.opened)
+  assert hu.sensor_requests == [13, 10]  # driving status and night only; never location
+  assert hu.pairing_requests == [("39:90:21:64:07:00", 2)]
+  assert session.stats()["sensor_events"] == 1
+
+
+def test_session_leaves_car_data_alone_by_default(identity):
+  hu = FakeHeadUnit(identity, phone_services=True)
+  session = connect(hu, identity)
+  session.authenticate()
+  session.start("StarPilot", "comma.ai")
+  pump_until(session, lambda: session.focused)
+  session.shutdown()
+  session.peer.close()
+  hu.thread.join(5)
+  assert hu.error is None and SENSOR_CHANNEL not in hu.opened and BLUETOOTH_CHANNEL not in hu.opened and hu.pairing_requests == []
+
+
+def test_session_projects_without_a_bluetooth_address(identity):
+  hu = FakeHeadUnit(identity, phone_services=True)
+  session = connect(hu, identity)
+  session.phone_services = True
+  session.authenticate()
+  session.start("StarPilot", "comma.ai")
+  pump_until(session, lambda: session.focused)
+  session.shutdown()
+  session.peer.close()
+  hu.thread.join(5)
+  assert hu.error is None and BLUETOOTH_CHANNEL in hu.opened and hu.pairing_requests == []
+
+
 def test_session_keeps_unsolicited_focus_grant(identity):
   hu = FakeHeadUnit(identity, unsolicited_focus=True)
   session = connect(hu, identity)
@@ -1156,3 +1238,48 @@ def test_supervisor_retries_wifi_recovery_while_idle(monkeypatch):
   sup._session_alive = lambda: True  # ty: ignore[invalid-assignment]  # test double
   sup.recover_wifi(2000)  # never while a session owns wlan0
   assert len(calls) == 2
+
+
+def test_jetlink_delays_wired_but_does_not_stop_choosing_it(identity, tmp_path, monkeypatch):
+  from openpilot.starpilot.system.android_auto import supervisor as supervisor_module
+  sup, _ = make_supervisor(identity, tmp_path, monkeypatch, lambda *a, **k: None)
+  monkeypatch.setattr(supervisor_module, "jetlink_blocker", lambda: "Turn off Jetlink to use wired Android Auto")
+  monkeypatch.setattr(supervisor_module, "chestnut_blocker", lambda: "")
+  sup.set_connection("wired")
+  status = sup.status()
+  assert sup.config["connection"] == "wired" and status["wired_blocked"] == "" and "Jetlink" in status["wired_busy"]
+  with pytest.raises(RuntimeError, match="Turn off Jetlink"):
+    sup.start()
+
+
+def test_chestnut_still_stops_choosing_wired(identity, tmp_path, monkeypatch):
+  from openpilot.starpilot.system.android_auto import supervisor as supervisor_module
+  sup, _ = make_supervisor(identity, tmp_path, monkeypatch, lambda *a, **k: None)
+  monkeypatch.setattr(supervisor_module, "jetlink_blocker", lambda: "")
+  monkeypatch.setattr(supervisor_module, "chestnut_blocker", lambda: "Wired Android Auto is unavailable while Chestnut is connected")
+  with pytest.raises(RuntimeError, match="Chestnut"):
+    sup.set_connection("wired")
+
+
+def test_discovery_waits_past_the_message_timeout_for_a_slow_adapter():
+  from openpilot.starpilot.system.android_auto.session import Session
+  a, b = socket.socketpair()
+  session = Session.__new__(Session)
+  session.peer = a
+  session.authenticated = False
+  session.handshake_timeout = 0.1
+  session.fragments = {}
+  session.bytes_received = 0
+  def send_slowly():
+    time.sleep(0.2)
+    b.sendall(b"\x00\x03\x00\x02")
+    time.sleep(0.2)
+    b.sendall(b"\x00\x06")
+  sender = threading.Thread(target=send_slowly)
+  sender.start()
+  try:
+    assert session.wait_for(0, 6, timeout=1.0, patient=True) == b""
+  finally:
+    sender.join()
+    a.close()
+    b.close()
diff --git a/openpilot/starpilot/system/android_auto/tests/test_bt_sockets.py b/openpilot/starpilot/system/android_auto/tests/test_bt_sockets.py
index 3c8af690ba..54aadc2afe 100644
--- a/openpilot/starpilot/system/android_auto/tests/test_bt_sockets.py
+++ b/openpilot/starpilot/system/android_auto/tests/test_bt_sockets.py
@@ -24,12 +24,21 @@ class TestBluetoothSocketFallback(unittest.TestCase):
 
   def test_unimplemented_connect_uses_same_protocol_and_timeout(self):
     with self.capabilities(), patch.object(bt_sockets, '_native', side_effect=OSError(errno.ENOSYS, 'Function not implemented')), \
-         patch.object(bt_sockets, '_libc_connect') as libc:
+         patch.object(bt_sockets.time, 'sleep'), patch.object(bt_sockets, '_libc_connect') as libc:
       for connect, port in self.routes():
         self.assertIs(connect(self.ADDRESS.lower(), port, 4), libc.return_value)
       self.assertEqual(libc.call_args_list[0].args, (3, socket.SOCK_STREAM, self.ADDRESS, 1, 4))
       self.assertEqual(libc.call_args_list[1].args, (0, socket.SOCK_SEQPACKET, self.ADDRESS, 1, 4))
 
+  def test_unimplemented_connect_retries_natively_before_falling_back(self):
+    ok = Mock()
+    with self.capabilities(), patch.object(bt_sockets, '_native', side_effect=[OSError(errno.ENOSYS, 'x'), ok]) as native, \
+         patch.object(bt_sockets.time, 'sleep') as sleep, patch.object(bt_sockets, '_libc_connect') as libc:
+      self.assertIs(bt_sockets.connect_rfcomm(self.ADDRESS, 1), ok)
+    self.assertEqual(native.call_count, 2)
+    sleep.assert_called_once_with(bt_sockets.ENOSYS_RETRY_S)
+    libc.assert_not_called()
+
   def test_real_connection_failures_do_not_retry(self):
     for code in (errno.EHOSTDOWN, errno.ECONNREFUSED, errno.ETIMEDOUT, errno.EPERM, errno.EAFNOSUPPORT):
       with self.subTest(errno=code), self.capabilities(), \
@@ -43,19 +52,21 @@ class TestBluetoothSocketFallback(unittest.TestCase):
 
   def test_fallback_failure_propagates_without_loop(self):
     with self.capabilities(), patch.object(bt_sockets, '_native', side_effect=OSError(errno.ENOSYS, 'unimplemented')) as native, \
+         patch.object(bt_sockets.time, 'sleep'), \
          patch.object(bt_sockets, '_libc_connect', side_effect=OSError(errno.EHOSTDOWN, 'host down')) as libc:
       with self.assertRaises(OSError) as caught:
         bt_sockets.connect_rfcomm(self.ADDRESS, 1)
       self.assertEqual(caught.exception.errno, errno.EHOSTDOWN)
-      native.assert_called_once()
+      self.assertEqual(native.call_count, bt_sockets.ENOSYS_RETRIES + 1)
       libc.assert_called_once()
 
   def test_native_failure_closes_original_descriptor(self):
     original = Mock()
     original.connect.side_effect = OSError(errno.ENOSYS, 'unimplemented')
-    with self.capabilities(), patch.object(socket, 'socket', return_value=original), patch.object(bt_sockets, '_libc_connect') as libc:
+    with self.capabilities(), patch.object(socket, 'socket', return_value=original), patch.object(bt_sockets.time, 'sleep'), \
+         patch.object(bt_sockets, '_libc_connect') as libc:
       self.assertIs(bt_sockets.connect_rfcomm(self.ADDRESS, 1), libc.return_value)
-    original.close.assert_called_once()
+    self.assertEqual(original.close.call_count, bt_sockets.ENOSYS_RETRIES + 1)
 
   def test_missing_python_capability_uses_libc(self):
     with patch.object(bt_sockets, 'socket') as python_socket, patch.object(bt_sockets, '_libc_connect') as libc:
diff --git a/openpilot/starpilot/system/android_auto/tests/test_bugsink_report.py b/openpilot/starpilot/system/android_auto/tests/test_bugsink_report.py
index 87bc9e6a18..b759b5e8dc 100644
--- a/openpilot/starpilot/system/android_auto/tests/test_bugsink_report.py
+++ b/openpilot/starpilot/system/android_auto/tests/test_bugsink_report.py
@@ -312,6 +312,9 @@ def test_supervisor_records_build_at_session_start(monkeypatch):
     def close(self):
       pass
 
+    def capture_system(self):
+      pass
+
     def __call__(self, name, **values):
       records.append({"event": name, **values})
 
@@ -325,3 +328,115 @@ def test_supervisor_records_build_at_session_start(monkeypatch):
   sup._release_phone = lambda: None  # ty: ignore[invalid-assignment]  # test double
   sup._run(1)
   assert records[0]["software"] == {"commit": "session-build", "branch": "session-branch"}
+
+
+HANDSHAKE_FAILED = [
+  (0, 0, "session_start", {"receiver": "Honda HFL", "trigger": "auto"}),
+  (0, 1, "stage", {"state": "rfcomm"}),
+  (0, 2, "bootstrap_tx", {"message": "WifiVersionRequest", "bytes": 4}),
+  (0, 3, "hfp_command", {"command": "AT+CIND"}),
+  (0, 3, "nav_guidance_sent", {}),
+  (0, 4, "bootstrap_rx", {"message": "WifiVersionResponse", "bytes": 6}),
+  (0, 5, "sdp_retry", {"error": "[Errno 112] Host is down to AA:BB:CC:DD:EE:FF", "settle": 1.5}),
+  (0, 25, "attempt_failed", {"stage": "wifi_start", "error": "head unit did not answer in time", "kind": "BootstrapTimeout"}),
+]
+
+
+def test_failed_sessions_carry_a_scrubbed_handshake_trace(tmp_path):
+  event = br.drive_event([br.session_record(write_session(tmp_path, 1, HANDSHAKE_FAILED))])
+  trace = event["contexts"]["android_auto_trace_session_1"]
+  names = [item["event"] for item in trace["events"]]
+  assert names[:3] == ["session_start", "stage", "bootstrap_tx"] and "bootstrap_rx" in names and "sdp_retry" in names
+  assert "hfp_command" not in names and "nav_guidance_sent" not in names
+  assert trace["omitted"] == 0 and trace["events"][2]["at_s"] == 2.0
+  text = json.dumps(event)
+  assert "AA:BB:CC:DD:EE:FF" not in text and "Honda HFL" not in text
+
+
+def test_trace_keeps_the_newest_events_within_its_budget(tmp_path):
+  noisy = [(0, 0, "session_start", {})] + [(i // 60, i % 60, "sdp_retry", {"error": "x" * 250, "n": i}) for i in range(1, 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"]["android_auto_trace_session_1"]
+  assert trace["omitted"] > 0 and [e["event"] for e in trace["events"]][-2:] == ["attempt_failed", "session_stop"]
+  assert len(json.dumps(trace)) <= br.TRACE_SESSION_BYTES + 1024
+  assert len(json.dumps(event)) < 400 << 10
+
+
+CLEAN = [(0, 0, "session_start", {"receiver": "Honda HFL", "trigger": "auto"}),
+         (0, 11, "projection_ready", {"mode": {"width": 1280, "height": 720, "fps": 30, "margin_width": 0, "margin_height": 0}}),
+         (0, 11, "frame_pipeline", {"nv12": True, "target_fps": 30, "encoder": "v4l2"}),
+         (0, 12, "stage", {"state": "streaming"}),
+         (0, 12, "video_acknowledged", {}),
+         (0, 42, "stats", {"fps": 30.0, "wifi_dbm": -50, "focused": True, "frames_sent": 900, "load1": 1.5, "temp_max_c": 61.0}),
+         (1, 12, "stats", {"fps": 29.0, "wifi_dbm": -52, "focused": True, "frames_sent": 1800, "load1": 1.7, "temp_max_c": 63.0})]
+
+
+def test_clean_drives_send_no_trace(tmp_path):
+  event = br.drive_event([br.session_record(write_session(tmp_path, 1, CLEAN))])
+  assert not any(key.startswith("android_auto_trace_session_") for key in event["contexts"])
+  assert "aa.attention" not in event["tags"]
+
+
+def test_session_carries_stats_series_and_routine_event_counts(tmp_path):
+  events = [*CLEAN, (1, 20, "nav_guidance_sent", {}), (1, 21, "nav_guidance_sent", {}), (1, 22, "media_key", {})]
+  record = br.session_record(write_session(tmp_path, 1, events))
+  assert record["series"]["at_s"] == [42.0, 72.0] and record["series"]["load1"] == [1.5, 1.7]
+  assert record["series"]["temp_max_c"] == [61.0, 63.0] and "cpu0_mhz" not in record["series"]
+  assert record["quiet_events"] == {"nav_guidance_sent": 2, "media_key": 1}
+
+
+def test_sessions_that_streamed_poorly_get_a_trace(tmp_path):
+  event = br.drive_event([br.session_record(write_session(tmp_path, 1, STREAMED))])
+  assert "android_auto_trace_session_1" in event["contexts"]
+  assert {"encoder_recoveries", "unfocused"} <= set(event["tags"]["aa.attention"].split(","))
+  assert event["contexts"]["android_auto_trace_session_1"]["routine_events"] == {}
+
+
+def test_sessions_that_never_streamed_get_a_trace(tmp_path):
+  stopped = [(0, 0, "session_start", {"receiver": "Honda HFL"}), (0, 5, "stage", {"state": "negotiating_video"})]
+  event = br.drive_event([br.session_record(write_session(tmp_path, 1, stopped))])
+  assert "android_auto_trace_session_1" in event["contexts"] and event["tags"]["aa.attention"] == "stopped"
+
+
+def sidecar(tmp_path, number, lines):
+  path = tmp_path / f"session-{number:06d}.system.json"
+  path.write_text(json.dumps({"window": {"start": "a", "end": "b"}, "sources": {"network": {"lines": lines}, "kernel": {"error": "timed out"}}}))
+
+
+def test_device_slice_is_attached_scrubbed_for_sessions_that_need_attention(tmp_path):
+  path = write_session(tmp_path, 1, HANDSHAKE_FAILED)
+  sidecar(tmp_path, 1, ["wpa: Trying to associate with SSID 'HomeNet' bssid aa:bb:cc:dd:ee:ff", "wpa: ssid=Secret1 Honda HFL gone"])
+  (tmp_path / "car_ui.log").write_text("ui line Honda HFL\n" * 3)
+  event = br.drive_event([br.session_record(path)])
+  system = event["contexts"]["android_auto_system_session_1"]
+  assert system["kernel"] == {"error": "timed out"} and len(system["network"]["lines"]) == 2
+  text = json.dumps(event)
+  assert "HomeNet" not in text and "Secret1" not in text and "Honda HFL" not in text and "AA:BB:CC" not in text.upper()
+  assert len(event["contexts"]["android_auto_car_ui"]["lines"]) == 3
+
+
+def test_clean_sessions_do_not_attach_a_device_slice(tmp_path):
+  path = write_session(tmp_path, 1, CLEAN)
+  sidecar(tmp_path, 1, ["line"])
+  assert not any(key.startswith("android_auto_system") for key in br.drive_event([br.session_record(path)])["contexts"])
+
+
+def test_oversized_reports_shed_detail_and_still_fit(tmp_path):
+  path = write_session(tmp_path, 1, HANDSHAKE_FAILED)
+  big = br.drive_event([br.session_record(path)])
+  big["contexts"]["android_auto_system_session_1"] = {"network": {"lines": ["y" * 290] * 3000}}
+  fitted = br.fit_event(big)
+  assert br.event_size(fitted) <= br.EVENT_BUDGET
+  assert fitted["tags"]["aa.truncated"] == "yes" and "android_auto_system_session_1" in fitted["contexts"]["android_auto_shed"]["dropped"]
+  assert "android_auto_drive" in fitted["contexts"]
+
+
+def test_pairing_that_failed_carries_a_device_slice_but_success_does_not(tmp_path):
+  record = {"seq": 1, "started": "2026-10-16T12:00:00+00:00", "window_s": 60, "duration_s": 30, "steps": [], "result": "timeout"}
+  calls = []
+  collector = lambda start, end: calls.append((start, end)) or {"window": {}, "sources": {"bluetooth": {"lines": ["bt 'Phone X' up"]}}}  # noqa: E731
+  event = br.pairing_event(record, collector)
+  assert event["contexts"]["android_auto_pairing_system"]["bluetooth"]["lines"] == ["bt '<name>' up"]
+  assert calls[0][1] - calls[0][0] == 30
+  assert "android_auto_pairing_system" not in br.pairing_event({**record, "result": "paired"}, collector)["contexts"]
diff --git a/openpilot/starpilot/system/android_auto/tests/test_car_never_answered.py b/openpilot/starpilot/system/android_auto/tests/test_car_never_answered.py
new file mode 100644
index 0000000000..9c4bb9ee31
--- /dev/null
+++ b/openpilot/starpilot/system/android_auto/tests/test_car_never_answered.py
@@ -0,0 +1,16 @@
+import errno
+import unittest
+
+from openpilot.starpilot.system.android_auto.bootstrap import BootstrapTimeout
+from openpilot.starpilot.system.android_auto.supervisor import car_never_answered
+
+
+class TestCarNeverAnswered(unittest.TestCase):
+  def test_local_bluetooth_failures_keep_the_cached_channel(self):
+    for code in (errno.ENOSYS, errno.EAFNOSUPPORT, errno.EPROTONOSUPPORT):
+      self.assertFalse(car_never_answered(OSError(code, 'local')))
+
+  def test_car_side_failures_drop_the_cached_channel(self):
+    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))
diff --git a/openpilot/starpilot/system/android_auto/tests/test_car_profiles.py b/openpilot/starpilot/system/android_auto/tests/test_car_profiles.py
new file mode 100644
index 0000000000..e97d04f1a0
--- /dev/null
+++ b/openpilot/starpilot/system/android_auto/tests/test_car_profiles.py
@@ -0,0 +1,223 @@
+"""Car profiles are picked by fingerprint; cars without a rule keep the standard behavior."""
+
+import json
+import threading
+from unittest.mock import Mock
+
+import pytest
+
+from openpilot.starpilot.system.android_auto import bugsink_report as br, car_profiles, daemon, identity as identity_store
+from openpilot.starpilot.system.android_auto.supervisor import Supervisor
+from openpilot.starpilot.system.android_auto.tests.fake_head_unit import make_identity
+from openpilot.starpilot.system.android_auto.tests.test_android_auto import make_supervisor
+
+ADAPTER = "AA:BB:CC:DD:EE:01"
+PALISADE = {"id": "palisade", "label": "Hyundai Palisade", "match": {"car_make": "^hyundai$", "car_model": "palisade"},
+            "tuning": {"connect_delay_s": 10.0, "unknown_key": 1}}
+
+
+@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):
+  sup, _ = make_supervisor(identity, tmp_path, monkeypatch, lambda *a, **k: None)
+  return sup
+
+
+@pytest.fixture
+def palisade(monkeypatch):
+  monkeypatch.setattr(car_profiles, "RULES", [PALISADE])
+
+
+def config(**values):
+  return {"receiver_address": ADAPTER, "car_profile_override": "", "car_fingerprint": {}, **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.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
+
+
+def test_leaving_the_adapter_setup_clears_the_adapter_model(sup):
+  sup.config["car_type"] = "adapter"
+  sup.config.update(receiver_address=ADAPTER, receiver_name="AAWireless", companion_address="car",
+                    companion_name="Car", car_fingerprint={"address": ADAPTER})
+  sup.set_car_profile("aawireless")
+  sup.set_car_type("builtin")
+  assert sup.config["car_profile_override"] == ""
+  assert not sup.config["receiver_address"] and not sup.config["companion_address"] and not sup.config["car_fingerprint"]
+
+
+def test_an_adapter_setup_must_choose_its_model_before_pairing_or_starting(sup):
+  sup.config["car_type"] = "adapter"
+  assert sup.status()["adapter_choice_needed"] is True
+  with pytest.raises(RuntimeError, match="adapter model"):
+    sup.prepare_pairing()
+  with pytest.raises(RuntimeError, match="adapter model"):
+    sup.start()
+  sup.set_car_profile("default")
+  assert sup.status()["adapter_choice_needed"] is False
+  sup.config["car_type"] = "builtin"
+  sup.config["car_profile_override"] = ""
+  assert sup.status()["adapter_choice_needed"] is False
+
+
+def test_every_car_is_standard_without_rules():
+  assert car_profiles.resolve(config(car_fingerprint={"address": ADAPTER, "car_make": "Hyundai"})) == ("default", "standard")
+  assert car_profiles.tuning(config()) == car_profiles.DEFAULTS
+  assert car_profiles.summary(config())["car_profile_label"] == ""
+
+
+def test_fingerprint_picks_a_profile_only_for_the_chosen_receiver(palisade):
+  fingerprint = {"address": ADAPTER, "car_make": "Hyundai", "car_model": "Palisade"}
+  assert car_profiles.resolve(config(car_fingerprint=fingerprint)) == ("palisade", "detected")
+  assert car_profiles.resolve(config(car_fingerprint={**fingerprint, "address": "AA:BB:CC:DD:EE:09"})) == ("default", "standard")
+  assert car_profiles.resolve(config(car_fingerprint={"address": ADAPTER, "car_make": "Hyundai", "car_model": "Sonata"})) == ("default", "standard")
+
+
+def test_tuning_keeps_only_known_keys(palisade):
+  tuned = car_profiles.tuning(config(car_profile_override="palisade"))
+  assert tuned == {**car_profiles.DEFAULTS, "connect_delay_s": 10.0}
+
+
+def test_override_pins_a_profile_or_forces_standard(palisade):
+  fingerprint = {"address": ADAPTER, "car_make": "Hyundai", "car_model": "Palisade"}
+  assert car_profiles.resolve(config(car_profile_override="default", car_fingerprint=fingerprint)) == ("default", "override")
+  assert car_profiles.resolve(config(car_profile_override="palisade")) == ("palisade", "override")
+  assert car_profiles.resolve(config(car_profile_override="gone")) == ("default", "standard")
+  assert car_profiles.valid_override("") and car_profiles.valid_override("default") and car_profiles.valid_override("palisade")
+  assert not car_profiles.valid_override("gone")
+
+
+def test_old_config_files_load_with_standard_defaults(tmp_path):
+  path = tmp_path / "config.json"
+  path.write_text(json.dumps({"config_version": 6, "connection": "wired", "car_type": "bogus"}))
+  loaded = identity_store.load_config(path)
+  assert loaded["car_type"] == "" and loaded["car_profile_override"] == "" and loaded["car_fingerprint"] == {}
+  assert loaded["connection"] == "wired"
+
+
+def test_car_type_follows_the_connection_and_companion(sup):
+  assert sup.status()["car_type"] == "builtin"
+  sup.config.update(companion_address="car")
+  assert sup.car_type() == "adapter"
+  sup.config.update(car_type="builtin")
+  assert sup.car_type() == "builtin"
+  sup.config.update(connection="headunitpad")
+  assert sup.car_type() == "app"
+
+
+def test_choosing_a_car_type_sets_the_connection(sup):
+  sup.set_car_type("adapter")
+  assert sup.car_type() == "adapter" and sup.config["connection"] == "wireless"
+  sup.set_car_type("app")
+  assert sup.config["connection"] == "headunitpad" and sup.car_type() == "app"
+  sup.set_car_type("builtin")
+  assert sup.config["connection"] == "wireless" and sup.car_type() == "builtin"
+  assert json.loads(identity_store.CONFIG_PATH.read_text())["car_type"] == "builtin"
+  with pytest.raises(RuntimeError):
+    sup.set_car_type("hovercraft")
+
+
+def test_profile_changes_are_pinned_and_validated(sup, palisade):
+  sup.set_car_profile("palisade")
+  status = sup.status()
+  assert status["car_profile"] == "palisade" and status["car_profile_source"] == "override" and status["car_profile_label"] == "Hyundai Palisade"
+  sup.set_car_profile("")
+  assert sup.status()["car_profile_source"] == "standard"
+  with pytest.raises(RuntimeError):
+    sup.set_car_profile("nope")
+
+
+def test_setup_commands_need_a_signed_in_galaxy_source():
+  assert {"set_car_type", "set_car_profile"} <= daemon.AUTHENTICATED_COMMANDS
+
+
+def test_head_unit_fingerprint_is_remembered_and_dropped_with_the_car(sup):
+  sup.config["receiver_address"] = ADAPTER
+  sup._remember_fingerprint({"car_make": "Hyundai", "car_model": "Palisade", "head_unit_make": "MOBIS", "ignored": "x"})
+  stored = json.loads(identity_store.CONFIG_PATH.read_text())["car_fingerprint"]
+  assert stored == {"address": ADAPTER, "head_unit_make": "MOBIS", "car_make": "Hyundai", "car_model": "Palisade"}
+  sup._remember_fingerprint({})
+  assert sup.config["car_fingerprint"] == stored
+
+
+def make_notifier():
+  sup = Supervisor.__new__(Supervisor)
+  sup._lock = threading.RLock()
+  sup._pairing_step = Mock()
+  sup.log = Mock()
+  return sup
+
+
+def test_a_paired_device_without_android_auto_is_explained_after_a_wait(monkeypatch):
+  sup = make_notifier()
+  receiver = {"address": ADAPTER, "name": "Civic"}
+  devices = [{"address": ADAPTER, "name": "Civic", "paired": True, "android_auto": False}]
+  clock = iter([100.0, 103.0, 109.0])
+  monkeypatch.setattr("time.monotonic", lambda: next(clock))
+  for _ in range(2):
+    sup._note_missing_android_auto(devices, receiver)
+  assert sup._pairing_note == ""
+  sup._note_missing_android_auto(devices, receiver)
+  assert "doesn't offer wireless Android Auto" in sup._pairing_note and "Wireless adapter" in sup._pairing_note
+  sup._pairing_step.assert_called_once_with("no_android_auto")
+
+
+def test_a_device_that_offers_android_auto_never_gets_a_note():
+  sup = make_notifier()
+  sup._no_aa_since = 5.0
+  sup._note_missing_android_auto([{"address": ADAPTER, "name": "Car", "paired": True, "android_auto": True}], {"address": ADAPTER})
+  assert sup._pairing_note == "" and sup._no_aa_since == 0.0
+
+
+@pytest.mark.parametrize("end", ["interrupted", "cancelled", "expired"])
+def test_a_pairing_that_connected_is_not_reported_as_interrupted(end):
+  records = []
+  attempt = br.PairingAttempt(180, sink=records.append)
+  attempt.step("status", state="connected", prompt=False, approved=True)
+  sup = make_notifier()
+  sup._pairing_attempt = attempt
+  sup._end_pairing(end, reason="Bluetooth lease released")
+  assert records[0]["result"] == "paired_not_selected" and records[0]["steps"][-1]["ended"] == end
+
+
+def test_a_pairing_that_never_connected_keeps_its_result():
+  records = []
+  attempt = br.PairingAttempt(180, sink=records.append)
+  attempt.step("status", state="idle", prompt=False, approved=False)
+  sup = make_notifier()
+  sup._pairing_attempt = attempt
+  sup._end_pairing("interrupted", reason="Galaxy session ended")
+  assert records[0]["result"] == "interrupted"
+
+
+def test_the_new_result_has_a_bugsink_report():
+  attempt = br.PairingAttempt(180, sink=lambda record: None)
+  attempt.step("status", state="connected", prompt=False, approved=True)
+  event = br.pairing_event({**attempt.record, "result": "paired_not_selected", "duration_s": 5.0})
+  assert event["fingerprint"] == ["android-auto-pairing", "paired_not_selected"] and event["level"] == "warning"
+
+
+@pytest.mark.parametrize("stored, kept", [({"car_type": "adapter"}, True), ({"car_type": "", "companion_address": "AA:BB:CC:DD:EE:02"}, True),
+                                          ({"car_type": "builtin", "companion_address": "AA:BB:CC:DD:EE:02"}, False), ({}, False),
+                                          ({"car_type": "adapter", "car_profile_override": "aawireless"}, True)])
+def test_adapter_owners_from_before_the_model_choice_keep_connecting(tmp_path, stored, kept):
+  path = tmp_path / "config.json"
+  path.write_text(json.dumps({"config_version": 6, **stored}))
+  config = identity_store.load_config(path)
+  assert (config["car_profile_override"] != "") is kept
+  assert config["car_profile_override"] == stored.get("car_profile_override", "default" if kept else "")
+
+
+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"] == ""
diff --git a/openpilot/starpilot/system/android_auto/tests/test_companion_bluetooth.py b/openpilot/starpilot/system/android_auto/tests/test_companion_bluetooth.py
index 562c66905e..ef17d6ac46 100644
--- a/openpilot/starpilot/system/android_auto/tests/test_companion_bluetooth.py
+++ b/openpilot/starpilot/system/android_auto/tests/test_companion_bluetooth.py
@@ -278,6 +278,41 @@ class CompanionTests(unittest.TestCase):
       save.assert_not_called()
     self.assertEqual(host.config['companion_address'], '')
 
+  def test_forgetting_the_selected_car_stops_its_retry_then_deletes_it(self):
+    from openpilot.starpilot.system.android_auto.supervisor import Supervisor
+    host = Supervisor.__new__(Supervisor)
+    host._lock = threading.RLock()
+    host.config = {'receiver_address': ADAPTER}
+    host._shared_bluetooth_owner = self.owner
+    host.auto = Mock()
+    alive = {'value': True}
+    host._session_alive = lambda: alive['value']
+    host.stop = Mock(side_effect=lambda: alive.update(value=False))
+    host.forget_receiver = Mock(return_value=True)
+    self.owner.request = Mock(return_value={'devices': []})  # test double
+    self.assertEqual(host.companion_bluetooth_action('forget', ADAPTER.lower(), SESSION), {'devices': []})
+    host.auto.manual_stop.assert_called_once_with(True)
+    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())
+
+  def test_forgetting_the_selected_car_waits_out_pairing_and_expired_sessions(self):
+    from openpilot.starpilot.system.android_auto.supervisor import Supervisor
+    host = Supervisor.__new__(Supervisor)
+    host.config = {'receiver_address': ADAPTER}
+    host._shared_bluetooth_owner = self.owner
+    host.stop = Mock()
+    self.lease.session = SESSION
+    with self.assertRaises(Rejected) as error:
+      host.companion_bluetooth_action('forget', ADAPTER, SESSION)
+    self.assertEqual(error.exception.code, 'busy')
+    self.lease.session = None
+    self.state['valid'] = False
+    with self.assertRaises(Rejected) as error:
+      host.companion_bluetooth_action('forget', ADAPTER, SESSION)
+    self.assertEqual(error.exception.code, 'session_expired')
+    host.stop.assert_not_called()
+
   def daemon_call(self, operation='connect', address=CAR, valid=True, parked=True):
     supervisor = SimpleNamespace(companion_bluetooth_action=self.owner.companion_action,
       bind_source_session=lambda session: self.fail('Companion command must not rebind projection source'))
diff --git a/openpilot/starpilot/system/android_auto/tests/test_device_health.py b/openpilot/starpilot/system/android_auto/tests/test_device_health.py
new file mode 100644
index 0000000000..625edb9871
--- /dev/null
+++ b/openpilot/starpilot/system/android_auto/tests/test_device_health.py
@@ -0,0 +1,14 @@
+from openpilot.starpilot.system.android_auto import device_health
+
+
+def test_wireless_link_reads_quality_signal_and_noise(monkeypatch):
+  text = "Inter-| sta-|   Quality   |\n face | tus | link level noise |\n wlan0: 0000   58.  -52.  -256.        0\n"
+  monkeypatch.setattr(device_health, "_read", lambda path: text if path == "/proc/net/wireless" else None)
+  assert device_health.wireless_link() == {"wifi_link": 58, "wifi_dbm": -52, "wifi_noise": -256}
+  assert device_health.wireless_link("wlan1") == {}
+
+
+def test_sample_leaves_out_what_the_device_does_not_have(monkeypatch):
+  monkeypatch.setattr(device_health, "_read", lambda path: "0.75 0.5 0.4 1/200 99\n" if path == "/proc/loadavg" else None)
+  monkeypatch.setattr(device_health.glob, "glob", lambda pattern: [])
+  assert device_health.sample() == {"load1": 0.75}
diff --git a/openpilot/starpilot/system/android_auto/tests/test_system_slice.py b/openpilot/starpilot/system/android_auto/tests/test_system_slice.py
new file mode 100644
index 0000000000..3befa8d156
--- /dev/null
+++ b/openpilot/starpilot/system/android_auto/tests/test_system_slice.py
@@ -0,0 +1,56 @@
+"""The per-session device slice: bounded line lists from a collector, saved beside the session log."""
+
+import json
+
+from openpilot.starpilot.system.android_auto import system_slice
+
+
+def fake_collector(since, deadline, *, command_set):
+  names = list(command_set)
+  files = {"network": b"line one aa:bb:cc:dd:ee:ff\nline two\n", "proc.txt": b"==== /proc/loadavg\n0.5\n"}
+  manifest = {name: {"command": "x", "exit": 0} for name in names}
+  manifest["kernel"]["error"] = "timed out after 6 s"
+  files["manifest.json"] = json.dumps({"commands": manifest}).encode()
+  return files
+
+
+def test_collect_turns_command_output_into_line_lists():
+  result = system_slice.collect(1_000_000.0, 1_000_060.0, collector=fake_collector)
+  sources = result["sources"]
+  assert sources["network"]["lines"] == ["line one xx:xx:xx:xx:xx:ff", "line two"]
+  assert sources["kernel"]["error"].startswith("timed out") and "lines" not in sources["kernel"]
+  assert "error" in sources["bluetooth"] and sources["proc"]["lines"][0].startswith("====")
+
+
+def test_commands_are_niced_and_cover_the_session_window():
+  command = system_slice.commands(1_000_000.0, 1_000_060.0)["network"]
+  assert command[:3] == ["nice", "-n", "19"] and "--utc" in command
+  assert command[command.index("--since") + 1] == "1970-01-12 13:46:10" and "NetworkManager" in command
+
+
+def test_scrub_line_masks_names_ssids_and_addresses_and_caps_length():
+  line = system_slice.scrub_line("assoc ssid=Home bssid aa:bb:cc:dd:ee:ff 'My Car' Danny " + "z" * 500, names=["Danny"])
+  assert "Home" not in line and "aa:bb" not in line and "My Car" not in line and "Danny" not in line and len(line) <= 300
+
+
+def test_sidecar_round_trip_and_pruning(tmp_path):
+  log = tmp_path / "session-000007-20261016-120000.jsonl"
+  log.write_text("")
+  system_slice.write_sidecar(log, 1_000_000.0, 1_000_060.0, collector=fake_collector)
+  assert system_slice.sidecar_path(log).name == "session-000007.system.json"
+  assert system_slice.read_sidecar(log)["sources"]["network"]["lines"][1] == "line two"
+  stale = tmp_path / "session-000002.system.json"
+  stale.write_text("{}")
+  system_slice.prune_sidecars(tmp_path)
+  assert not stale.exists() and system_slice.sidecar_path(log).exists()
+
+
+def test_a_collector_that_raises_leaves_no_sidecar(tmp_path):
+  log = tmp_path / "session-000001-20261016-120000.jsonl"
+  log.write_text("")
+
+  def broken(*_args, **_kwargs):
+    raise RuntimeError("boom")
+
+  system_slice.write_sidecar(log, 0.0, 1.0, collector=broken)
+  assert system_slice.read_sidecar(log) == {}