diff --git a/open_wearable/.gitignore b/open_wearable/.gitignore
index b223fb72a..8f0304540 100644
--- a/open_wearable/.gitignore
+++ b/open_wearable/.gitignore
@@ -33,6 +33,11 @@ migrate_working_dir/
 .pub/
 /build/
 
+# Patrol-generated entry point, local test settings, and run artifacts.
+**/test_bundle.dart
+.patrol.env
+/test-results/
+
 # Generated plugin registrants
 **/GeneratedPluginRegistrant.swift
 **/generated_plugin_registrant.cc
diff --git a/open_wearable/android/app/build.gradle b/open_wearable/android/app/build.gradle
index 30ee3d7cb..8bd257b88 100644
--- a/open_wearable/android/app/build.gradle
+++ b/open_wearable/android/app/build.gradle
@@ -29,9 +29,17 @@ android {
         targetSdk = flutter.targetSdkVersion
         versionCode = customVersionCode.toInteger()
         versionName = flutter.versionName
+        testInstrumentationRunner "pl.leancode.patrol.PatrolJUnitRunner"
+        testInstrumentationRunnerArguments["clearPackageData"] = "true"
     }
 
     buildTypes {
+        debug {
+            // Patrol runs debug builds. Give that build its own Android identity
+            // so it can live beside the user's normal OpenWearables app and so
+            // test-data cleanup never touches the production installation.
+            applicationIdSuffix = ".patrol"
+        }
         release {
             // TODO: Add your own signing config for the release build.
             // Signing with the debug keys for now, so `flutter run --release` works.
@@ -41,6 +49,10 @@ android {
             proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
         }
     }
+
+    testOptions {
+        execution "ANDROIDX_TEST_ORCHESTRATOR"
+    }
 }
 
 flutter {
@@ -52,3 +64,7 @@ kotlin {
         jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_17
     }
 }
+
+dependencies {
+    androidTestUtil "androidx.test:orchestrator:1.5.1"
+}
diff --git a/open_wearable/android/app/src/androidTest/java/edu/kit/teco/openWearable/MainActivityTest.java b/open_wearable/android/app/src/androidTest/java/edu/kit/teco/openWearable/MainActivityTest.java
new file mode 100644
index 000000000..1214fb702
--- /dev/null
+++ b/open_wearable/android/app/src/androidTest/java/edu/kit/teco/openWearable/MainActivityTest.java
@@ -0,0 +1,36 @@
+package edu.kit.teco.openWearable;
+
+import androidx.test.platform.app.InstrumentationRegistry;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+import pl.leancode.patrol.PatrolJUnitRunner;
+
+/** Runs every discovered Dart Patrol test as an Android instrumentation test. */
+@RunWith(Parameterized.class)
+public class MainActivityTest {
+    @Parameters(name = "{0}")
+    public static Object[] testCases() {
+        PatrolJUnitRunner instrumentation =
+                (PatrolJUnitRunner) InstrumentationRegistry.getInstrumentation();
+        instrumentation.setUp(MainActivity.class);
+        instrumentation.waitForPatrolAppService();
+        return instrumentation.listDartTests();
+    }
+
+    private final String dartTestName;
+
+    public MainActivityTest(String dartTestName) {
+        this.dartTestName = dartTestName;
+    }
+
+    @Test
+    public void runDartTest() {
+        PatrolJUnitRunner instrumentation =
+                (PatrolJUnitRunner) InstrumentationRegistry.getInstrumentation();
+        instrumentation.runDartTest(dartTestName);
+    }
+}
diff --git a/open_wearable/android/app/src/debug/res/values/strings.xml b/open_wearable/android/app/src/debug/res/values/strings.xml
new file mode 100644
index 000000000..a4723d769
--- /dev/null
+++ b/open_wearable/android/app/src/debug/res/values/strings.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="app_name">OpenWearables Test</string>
+</resources>
diff --git a/open_wearable/android/app/src/main/AndroidManifest.xml b/open_wearable/android/app/src/main/AndroidManifest.xml
index 744041532..a2a93bd10 100644
--- a/open_wearable/android/app/src/main/AndroidManifest.xml
+++ b/open_wearable/android/app/src/main/AndroidManifest.xml
@@ -1,5 +1,5 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android">
-    <application android:label="OpenWearables" android:name="${applicationName}" android:icon="@mipmap/ic_launcher" android:enableOnBackInvokedCallback="true">
+    <application android:label="@string/app_name" android:name="${applicationName}" android:icon="@mipmap/ic_launcher" android:enableOnBackInvokedCallback="true">
         <activity android:name=".MainActivity" android:exported="true" android:launchMode="singleTop" android:taskAffinity="" android:theme="@style/LaunchTheme" android:configChanges="orientation|keyboardHidden|keyboard|screenSize|smallestScreenSize|locale|layoutDirection|fontScale|screenLayout|density|uiMode" android:hardwareAccelerated="true" android:windowSoftInputMode="adjustResize" android:screenOrientation="portrait">
             <!-- Specifies an Android theme to apply to this Activity as soon as
                  the Android process has started. This theme is visible to the user
diff --git a/open_wearable/android/app/src/main/res/values/strings.xml b/open_wearable/android/app/src/main/res/values/strings.xml
new file mode 100644
index 000000000..58efd1693
--- /dev/null
+++ b/open_wearable/android/app/src/main/res/values/strings.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="app_name">OpenWearables</string>
+</resources>
diff --git a/open_wearable/docs/testing/README.md b/open_wearable/docs/testing/README.md
new file mode 100644
index 000000000..6b12ca8e3
--- /dev/null
+++ b/open_wearable/docs/testing/README.md
@@ -0,0 +1,279 @@
+# OpenWearables UI testing with Patrol
+
+These tests drive the production Flutter app through visible controls, native
+Android permission dialogs, and Bluetooth flows. Patrol is the test runner; the
+OpenEarable remains the real hardware under test.
+
+A phone is not needed to author tests or build the Android artifacts. A phone is
+needed to install and execute them, and the hardware journey also needs an
+advertising OpenEarable in range.
+
+This first phase targets Android. The same journey design can be carried to
+iOS after the Android suite is stable on real hardware.
+
+## Current setup
+
+| Component | Version or value |
+| --- | --- |
+| Flutter package | `patrol` `4.10.0` |
+| Command-line tool | `patrol_cli` `4.8.0` |
+| Android production app ID | `edu.kit.teco.openWearable` |
+| Android Patrol/debug app ID | `edu.kit.teco.openWearable.patrol` |
+| Android Patrol/debug label | `OpenWearables Test` |
+| Android runner | `pl.leancode.patrol.PatrolJUnitRunner` |
+| Test isolation | Android Test Orchestrator with only the test app's data cleared |
+
+Keep the CLI at `4.8.0`: `patrol` `4.10.0` requires that version or newer, and
+this repository pins the tested pair rather than silently taking a later CLI.
+
+The initial automated journeys are:
+
+| Test | Coverage matrix mapping | Current assertions |
+| --- | --- | --- |
+| `patrol_test/onboarding_permissions_test.dart` | `NAV-01` | Drives the real Android Bluetooth/location and microphone permission dialogs, reaches Overview, and confirms the connection screen no longer requests either permission. It passed on a Pixel 9a running Android 17/API 37 on 2026-09-29. |
+| `patrol_test/late_microphone_permission_test.dart` | `NAV-03` | Grants Bluetooth/location but deliberately skips microphone during onboarding, verifies that Connect Devices offers microphone recovery, grants the native permission from that recovery action, and verifies that the reminder disappears. It passed on a Pixel 9a running Android 17/API 37 on 2026-09-29. |
+| `patrol_test/overview_shortcuts_test.dart` | `NAV-07` | Opens all four Overview workflow shortcuts, verifies their Connect Devices, Configure, Live Data, and Recorder destinations, checks the no-device states, and confirms recording cannot start without connected sensors. It passed on a Pixel 9a running Android 17/API 37 on 2026-09-29. |
+| `patrol_test/this_device_connection_test.dart` | `CON-13` | Connects the Pixel itself through the visible discovery row, verifies the Connected and Overview states, opens its device details, disconnects it, and verifies cleanup. It passed on a Pixel 9a running Android 17/API 37 on 2026-09-29 and again on 2026-10-15 against the current main-based app. |
+| `patrol_test/this_device_recording_test.dart` | `CFG-02`, `CFG-03`, `LIVE-01`, `REC-02`, `REC-08` (fixture-specific/partial) | Connects the Pixel as a sensor device, configures its accelerometer at 5 Hz, applies the setting, opens Live Data, records for two seconds, verifies a visible non-empty CSV, deletes the test recording, verifies empty history, and disconnects. The strengthened journey passed twice on 2026-09-29 and again on 2026-10-15 against the current main-based app. |
+| `patrol_test/navigation_and_settings_test.dart` | `NAV-02`, `NAV-06`, `SET-01` (partial) | Completes first-run onboarding with the permission skip path, checks the missing-permission explanation, visits Devices, Sensors, Apps, and Settings, then toggles and restores Keep screen awake. It passed three times on a Pixel 9a running Android 17/API 37 on 2026-09-29. It does not yet check every setting, relaunch persistence, or every page scroll. |
+| `patrol_test/general_settings_test.dart` | `SET-01` (partial) | Changes all six General settings, verifies the changed values after reopening the page, restores every original value, and verifies cleanup. The five original settings were verified on 2026-09-29; all six, including Show sampling rates, passed on a Pixel 9a running Android 17/API 37 on 2026-10-15 against the current main-based app. Process-relaunch persistence remains planned. |
+| `patrol_test/open_earable_connection_test.dart` | `CON-01`, `CON-07`, `DEV-01` (partial) | Grants Android permissions, scans for one exact device ID, connects it, opens its information and battery sections, disconnects, reconnects, reopens details, and disconnects for cleanup. It does not yet assert every identity/version field. |
+| `patrol_test/open_earable_pair_test.dart` | `CON-09` | Enables the OpenEarable name filter, requires exactly two matching advertisers, captures their rotating BLE addresses for that run, connects both, verifies a combined card with L/R identities, splits and recombines the pair, then splits and disconnects both during guaranteed cleanup. It passed on a Pixel 9a running Android 17/API 37 with two OpenEarable-2B01 devices on 2026-09-30 and again on 2026-10-15 against the current main-based app. |
+| `patrol_test/open_earable_pair_sample_rate_test.dart` | `RATE-01` | Connects exactly two OpenEarables as a pair, enables 9-Axis IMU streaming at each requested rate, records both devices, calculates the received accelerometer rate from each side's CSV timestamps, checks the configured tolerance, deletes successful test artifacts, and disconnects both devices. It passed at 25/50/100 Hz on 2026-09-30 and again on 2026-10-15 against current main: measured L/R rates were 24.99, 49.95, and 99.90 Hz. The test still does not assert the expected/actual rate labels added to the live charts. See the [historical rate run](runs/2026-09-30-pixel-9a-pair-sample-rates.md) and [current regression run](runs/2026-10-15-pixel-9a-upstream-main-regression.md). |
+
+The exact assertions and limitations of every selectable suite are in
+[`test-catalog.md`](test-catalog.md). The complete planned journey inventory is
+in [`ui-coverage.md`](ui-coverage.md). An automated path being present does not
+mean it has passed on a real phone; record that only after a device run.
+Real-device run evidence is stored under [`runs/`](runs/).
+
+The 2026-10-15 run on the latest `upstream/main` passed navigation, permission
+flows, Overview shortcuts, all six General settings, phone-as-device
+connection/recording, and the two-device pairing lifecycle. The dedicated
+sample-rate test passed all three requested rates after the OpenEarables were
+woken. Earlier attempts exposed a new firmware-update dialog and intermittent
+advertising; the test now dismisses the notice during connection and cleans up
+partial pairs after failures. An exact-ID connection run also used an address
+that had rotated out of view. The current run record distinguishes these setup
+failures from feature assertions. Background recording, recovery, tracker
+behavior, firmware updates, sensor decoder compatibility, and the live
+expected/actual chart labels remain unverified; the catalog and coverage
+matrix list those gaps explicitly.
+
+## One-time Windows setup
+
+Flutter plugins use symbolic links on Windows. Enable **Developer Mode** under
+Windows **Settings > System > For developers**, then open a new terminal. Without
+it, `flutter pub get` or the Android build ends with a symlink-support error.
+
+From the `open_wearable` directory, install dependencies and the pinned Patrol
+CLI:
+
+```powershell
+flutter pub get
+dart pub global activate patrol_cli 4.8.0
+patrol doctor
+```
+
+If PowerShell cannot find `patrol`, add Dart's global executable directory to
+`PATH` as instructed by `dart pub global activate`, reopen the terminal, and run
+`patrol doctor` again.
+
+The helper scripts read the Android SDK path from `android/local.properties`
+and export it for their Patrol process. When running Patrol directly, set
+`ANDROID_HOME` and add its `platform-tools` directory to `PATH` if
+`patrol doctor` cannot find `adb`.
+
+## Build now without a phone
+
+Build the UI-only journey:
+
+```powershell
+.\tool\ui_tests\build_android.ps1 -Suite Navigation
+```
+
+Build the real-device Bluetooth journey with the exact identifier used by the
+app on Android (usually the Bluetooth address, not the display name):
+
+```powershell
+.\tool\ui_tests\build_android.ps1 `
+  -Suite Hardware `
+  -OpenEarableDeviceId 'AA:BB:CC:DD:EE:FF'
+```
+
+The hardware ID is compiled into that test build through
+`OPENEARABLE_DEVICE_ID`. The test deliberately refuses to select the first scan
+result because another nearby OpenEarable could otherwise be modified.
+
+The initial hardware journey requires a directly connected GATT OpenEarable
+that advertises again after disconnect and exposes the app's Device Information
+and Battery sections. A device represented as a system-managed `SystemDevice`
+uses the separate Forget/Bluetooth-settings flow and is covered by the planned
+system-device journey rather than this direct-disconnect test.
+
+Build the two-device stereo-pair journey:
+
+```powershell
+.\tool\ui_tests\build_android.ps1 -Suite PairHardware
+```
+
+The pair journey does not persist Android BLE addresses. The tested
+OpenEarable firmware uses private addresses that change after a power cycle.
+Instead, the test enables the app's OpenEarable name filter, requires exactly
+two matching visible rows, captures their current addresses, and uses those
+exact rows for the remainder of that run. It refuses to choose when the
+filtered result is not exactly two devices.
+
+`patrol build android` produces two APKs and prints their paths:
+
+- the OpenWearables app under test;
+- an Android instrumentation APK that controls the app and reports results.
+
+The instrumentation APK is not a standalone app with a launcher icon. Both
+APKs belong together and are normally installed and started by Patrol, `adb`
+instrumentation tooling, or an Android device farm.
+
+Android debug builds use the separate `edu.kit.teco.openWearable.patrol`
+application ID and the launcher label **OpenWearables Test**. The release app
+keeps `edu.kit.teco.openWearable`, so both can be installed at once. Patrol's
+data cleanup applies to the test installation only. The helper scripts always
+pass `--debug`; do the same if you run Patrol directly.
+
+## Run later on a phone
+
+### Find the command values
+
+Values written inside angle brackets, such as `<phone-serial>`, are examples
+that must be replaced in the command. They are not values to edit in the Dart
+test or in this documentation.
+
+Connect the unlocked Android phone with USB debugging enabled, accept the RSA
+prompt on the phone, and run:
+
+```powershell
+adb devices -l
+```
+
+The first column on a `device` row is the phone serial. For example:
+
+```text
+List of devices attached
+ABC123EXAMPLE    device product:tegu model:Pixel_9a
+```
+
+For that example, replace `<phone-serial>` with `ABC123EXAMPLE`. `patrol
+devices` can also list phones visible to Patrol:
+
+```powershell
+patrol devices
+```
+
+If exactly one Android phone is connected, `-AndroidDevice` can be omitted and
+Patrol will select that phone. The shortest pair-rate command is therefore:
+
+```powershell
+.\tool\ui_tests\run_android.ps1 `
+  -Suite PairSampleRate `
+  -SampleRatesHz 25,50,100
+```
+
+The pair suites do **not** require Bluetooth IDs on the command line.
+`PairHardware` and `PairSampleRate` enable the OpenEarable scan filter, require
+exactly two matching advertisers, capture their current rotating IDs, and use
+those exact devices for the remainder of that run. Wake or power-cycle both
+OpenEarables before the run and keep them near the phone. If fewer or more than
+two filtered devices are visible, the test fails instead of choosing
+ambiguously.
+
+Only the single-device `Hardware` suite requires
+`-OpenEarableDeviceId`. Find that current ID below the device name on the app's
+**Connect Devices** scan screen, then pass it exactly as displayed. An
+OpenEarable 2 ID can change after a power cycle, so read it again for a later
+single-device run. Prefer the pair suites when testing two OpenEarables.
+
+| Command value | Where it comes from | Required? |
+| --- | --- | --- |
+| `-AndroidDevice '<phone-serial>'` | First column from `adb devices -l`, or the identifier shown by `patrol devices`. | Optional when exactly one phone is connected. |
+| `-OpenEarableDeviceId 'AA:BB:CC:DD:EE:FF'` | Current ID shown for that device on the app's Connect Devices scan screen. | Only for the single-device `Hardware` suite. |
+| Pair Bluetooth IDs | Discovered automatically after filtering the app's scan results. | Never entered manually. |
+| `-SampleRatesHz 25,50,100` | Rates the user wants to test; the current OpenEarable 2 firmware offers 25, 50, and 100 Hz for 9-Axis IMU Bluetooth streaming. | Optional; default is 25 Hz. |
+| `-SampleDurationSeconds 12` | Recording time for each requested rate. Longer runs contain more samples. | Optional; default is 12 seconds and minimum is 5. |
+| `-SampleTolerancePercent 15` | Maximum allowed percentage difference between requested and received rate. | Optional; default is 15%. |
+
+Runtime BLE IDs written in a historical run record are evidence from that
+completed run. A reader does not reuse or replace them when starting a new pair
+test because the test discovers new IDs automatically.
+
+List every selectable suite or use the numbered chooser:
+
+```powershell
+.\tool\ui_tests\run_android.ps1 -ListSuites
+.\tool\ui_tests\choose_android_test.ps1 -AndroidDevice '<phone-serial>'
+```
+
+After confirming that the phone appears in both `adb devices` and `patrol
+devices`, run the UI-only journey:
+
+```powershell
+.\tool\ui_tests\run_android.ps1 `
+  -Suite Navigation `
+  -AndroidDevice '<phone-serial>'
+```
+
+For the hardware journey, charge and advertise the selected OpenEarable, keep
+it near the phone, and disconnect other apps that may already own its Bluetooth
+connection:
+
+```powershell
+.\tool\ui_tests\run_android.ps1 `
+  -Suite Hardware `
+  -AndroidDevice '<phone-serial>' `
+  -OpenEarableDeviceId 'AA:BB:CC:DD:EE:FF'
+```
+
+For a stereo pair, wake both sides and keep them near the phone. On the tested
+firmware the devices stop advertising after the test disconnects them, so wake
+or power-cycle both sides before another pair run:
+
+```powershell
+.\tool\ui_tests\run_android.ps1 `
+  -Suite PairHardware `
+  -AndroidDevice '<phone-serial>'
+```
+
+To set and verify one or more received pair IMU sample rates, wake both sides
+first and run:
+
+```powershell
+.\tool\ui_tests\run_android.ps1 `
+  -Suite PairSampleRate `
+  -AndroidDevice '<phone-serial>' `
+  -SampleRatesHz 25,50,100 `
+  -SampleDurationSeconds 12 `
+  -SampleTolerancePercent 15
+```
+
+The current OpenEarable 2 firmware exposes 25, 50, and 100 Hz for Bluetooth
+9-Axis IMU streaming. The test checks the left and right accelerometer files
+independently using the timestamps of samples that the app actually received.
+
+`patrol test` builds the current sources, installs both APKs, runs the selected
+test through Android instrumentation, and reports the result. Omitting
+`-AndroidDevice` lets Patrol select the only connected device or prompt when
+several are available. App data is cleared for isolation, so these journeys
+start at onboarding and should use a dedicated test installation/account.
+
+Direct Patrol equivalents are:
+
+```powershell
+patrol build android --debug --target patrol_test/navigation_and_settings_test.dart
+
+patrol test `
+  --debug `
+  --device '<phone-serial>' `
+  --target patrol_test/open_earable_connection_test.dart `
+  --dart-define=OPENEARABLE_DEVICE_ID=AA:BB:CC:DD:EE:FF
+```
+
+Patrol reference: [build](https://patrol.leancode.co/cli-commands/build) and
+[test](https://patrol.leancode.co/cli-commands/test).
diff --git a/open_wearable/docs/testing/runs/2026-09-29-pixel-9a-general-settings.md b/open_wearable/docs/testing/runs/2026-09-29-pixel-9a-general-settings.md
new file mode 100644
index 000000000..91e337a6e
--- /dev/null
+++ b/open_wearable/docs/testing/runs/2026-09-29-pixel-9a-general-settings.md
@@ -0,0 +1,36 @@
+# General settings — Pixel 9a, Android 17
+
+## Environment
+
+| Field | Value |
+| --- | --- |
+| Date | 2026-09-29 (Europe/Berlin) |
+| Phone | Google Pixel 9a (`tegu`) |
+| Android | 17, API 37 |
+| Test app | `edu.kit.teco.openWearable.patrol` (`OpenWearables Test`) |
+| Source | Local branch `test/patrol-ui-foundation`, working tree not committed |
+| Journey | `patrol_test/general_settings_test.dart` |
+
+## Result
+
+The final run passed with one successful journey, zero failures, and zero
+skips. It completed 43 logged Patrol actions in 13 seconds; the complete device
+phase took 63.1 seconds.
+
+The journey changed each of these settings independently:
+
+- Enable Bluetooth auto-connect
+- Keep screen awake
+- Disable all sensors on app close
+- Disable live data graphs
+- Hide live data graphs without data
+
+It left and reopened General settings, verified every changed value, restored
+the five original values in reverse order, reopened the page again, and
+verified cleanup. Platform semantics were disabled for this widget-value test
+after Flutter's live Android binding leaked a semantics handle during the first
+otherwise-functional attempt.
+
+Process termination and relaunch persistence remain planned. Patrol removed
+the temporary test packages after execution; the normal OpenWearables package
+was not targeted.
diff --git a/open_wearable/docs/testing/runs/2026-09-29-pixel-9a-late-microphone.md b/open_wearable/docs/testing/runs/2026-09-29-pixel-9a-late-microphone.md
new file mode 100644
index 000000000..008ebb94f
--- /dev/null
+++ b/open_wearable/docs/testing/runs/2026-09-29-pixel-9a-late-microphone.md
@@ -0,0 +1,30 @@
+# Late microphone permission recovery — Pixel 9a, Android 17
+
+## Environment
+
+| Field | Value |
+| --- | --- |
+| Date | 2026-09-29 (Europe/Berlin) |
+| Phone | Google Pixel 9a (`tegu`) |
+| Android | 17, API 37 |
+| Test app | `edu.kit.teco.openWearable.patrol` (`OpenWearables Test`) |
+| Journey | `patrol_test/late_microphone_permission_test.dart` |
+
+## Result
+
+The run passed with one successful journey, zero failures, and zero skips. It
+completed 21 logged Patrol actions in 14 seconds; the complete device phase
+took 75.1 seconds.
+
+Patrol enabled Bluetooth and Location, granted the two Android dialogs produced
+by the Bluetooth/location request, and deliberately used **Skip for now** on
+the app's microphone onboarding page. It then reached Overview, opened Devices
+and Connect Devices, and verified that the microphone recovery card was visible
+while the Bluetooth recovery card was absent. Tapping the microphone recovery
+action opened the native Android permission dialog. After Patrol granted it,
+the test verified that both recovery cards were absent and the scan action was
+still available.
+
+The permissions belonged to the isolated test package. Patrol removed the
+temporary test packages after execution and did not target the normal
+OpenWearables installation.
diff --git a/open_wearable/docs/testing/runs/2026-09-29-pixel-9a-navigation.md b/open_wearable/docs/testing/runs/2026-09-29-pixel-9a-navigation.md
new file mode 100644
index 000000000..fa93b027c
--- /dev/null
+++ b/open_wearable/docs/testing/runs/2026-09-29-pixel-9a-navigation.md
@@ -0,0 +1,44 @@
+# Navigation smoke test — Pixel 9a, Android 17
+
+## Environment
+
+| Field | Value |
+| --- | --- |
+| Date | 2026-09-29 (Europe/Berlin) |
+| Phone | Google Pixel 9a (`tegu`) |
+| Android | 17, API 37 |
+| CPU ABI | `arm64-v8a` |
+| Test app | `edu.kit.teco.openWearable.patrol` (`OpenWearables Test`) |
+| Controller | `edu.kit.teco.openWearable.patrol.test` |
+| Target SDK | 36 |
+| Source | Local branch `test/patrol-ui-foundation`, working tree not committed |
+| Journey | `patrol_test/navigation_and_settings_test.dart` |
+
+## Result
+
+The journey passed three times from Patrol's cleared test-app state. Each run
+reported one successful Dart journey and zero failures or skips. The third run
+was a regression check after making the shared onboarding helper handle the
+app's asynchronous permission explanation.
+
+| Run | Result | Automated actions | Dart journey time | End-to-end device phase |
+| --- | --- | ---: | ---: | ---: |
+| 1 | Passed | 19 | 8 seconds | 87 seconds |
+| 2 | Passed | 19 | 8.327 seconds | 64.3 seconds |
+| 3 | Passed | 19 | 8 seconds | 59.0 seconds |
+
+The run verified the permission-skip onboarding route, the missing-Bluetooth
+recovery explanation, forward navigation through Devices, Sensors, Apps, and
+Settings, and changing then restoring **Keep screen awake**.
+
+The production package `edu.kit.teco.openWearable` remained installed after
+the run. Patrol removed the temporary test and controller packages during its
+cleanup. Generated HTML, XML, and device logs remain under `build/app/` on the
+test PC and are ignored by Git.
+
+## Remaining scope
+
+This evidence does not cover permission grants, persistence after relaunch,
+reverse navigation and scrolling, the other General settings, BLE connection,
+OpenEarable capabilities, or physical behavior. Those remain separate rows in
+the coverage inventory.
diff --git a/open_wearable/docs/testing/runs/2026-09-29-pixel-9a-overview-shortcuts.md b/open_wearable/docs/testing/runs/2026-09-29-pixel-9a-overview-shortcuts.md
new file mode 100644
index 000000000..8e0d19ac1
--- /dev/null
+++ b/open_wearable/docs/testing/runs/2026-09-29-pixel-9a-overview-shortcuts.md
@@ -0,0 +1,32 @@
+# Overview shortcuts — Pixel 9a, Android 17
+
+## Environment
+
+| Field | Value |
+| --- | --- |
+| Date | 2026-09-29 (Europe/Berlin) |
+| Phone | Google Pixel 9a (`tegu`) |
+| Android | 17, API 37 |
+| Test app | `edu.kit.teco.openWearable.patrol` (`OpenWearables Test`) |
+| Journey | `patrol_test/overview_shortcuts_test.dart` |
+
+## Result
+
+The final run passed with one successful journey, zero failures, and zero
+skips. It completed 22 logged Patrol actions in 8 seconds; the complete device
+phase took 52.6 seconds.
+
+Patrol finished onboarding through the skip path and dismissed the app's
+asynchronous Bluetooth/location permission explanation when it appeared. From
+Overview, it opened all four visible workflow shortcuts and returned between
+them. It verified the missing-Bluetooth recovery on Connect Devices, the
+no-device prompts on Configure and Live Data, and the Local Recorder's
+no-sensors state. The test also inspected the visible Start Recording button
+and confirmed it was disabled while no sensors were connected.
+
+This run covers the no-device variant of NAV-07. The same shortcuts still need
+to be repeated with an identified connected device so their connected-session
+content can be verified.
+
+The isolated Patrol test package was removed after execution. The normal
+OpenWearables installation and nearby OpenEarables were not targeted.
diff --git a/open_wearable/docs/testing/runs/2026-09-29-pixel-9a-permissions.md b/open_wearable/docs/testing/runs/2026-09-29-pixel-9a-permissions.md
new file mode 100644
index 000000000..0d66e5600
--- /dev/null
+++ b/open_wearable/docs/testing/runs/2026-09-29-pixel-9a-permissions.md
@@ -0,0 +1,26 @@
+# Onboarding permissions — Pixel 9a, Android 17
+
+## Environment
+
+| Field | Value |
+| --- | --- |
+| Date | 2026-09-29 (Europe/Berlin) |
+| Phone | Google Pixel 9a (`tegu`) |
+| Android | 17, API 37 |
+| Test app | `edu.kit.teco.openWearable.patrol` (`OpenWearables Test`) |
+| Journey | `patrol_test/onboarding_permissions_test.dart` |
+
+## Result
+
+The run passed with one successful journey, zero failures, and zero skips. It
+completed 21 logged Patrol actions in 15 seconds; the complete device phase
+took 81.2 seconds.
+
+Patrol enabled the phone's Bluetooth and Location services, granted the two
+Android dialogs produced by the Bluetooth/location request, granted the
+microphone dialog, reached Overview, opened Connect Devices, and verified that
+neither permission-recovery card remained.
+
+The permissions belonged to the isolated test package. Patrol removed the
+temporary test packages after execution and did not target the normal
+OpenWearables installation.
diff --git a/open_wearable/docs/testing/runs/2026-09-29-pixel-9a-phone-sensor-recording.md b/open_wearable/docs/testing/runs/2026-09-29-pixel-9a-phone-sensor-recording.md
new file mode 100644
index 000000000..830614b8a
--- /dev/null
+++ b/open_wearable/docs/testing/runs/2026-09-29-pixel-9a-phone-sensor-recording.md
@@ -0,0 +1,30 @@
+# Phone sensor configuration and recording — Pixel 9a, Android 17
+
+## Environment
+
+| Field | Value |
+| --- | --- |
+| Date | 2026-09-29 (Europe/Berlin) |
+| Phone | Google Pixel 9a (`tegu`) |
+| Android | 17, API 37 |
+| Test app | `edu.kit.teco.openWearable.patrol` (`OpenWearables Test`) |
+| Journey | `patrol_test/this_device_recording_test.dart` |
+
+## Result
+
+The full journey passed twice. Each run reported one successful journey, zero
+failures, and zero skips. The stronger second run completed 50 logged Patrol
+actions in 27 seconds; its complete device phase took 72.3 seconds.
+
+Patrol connected the Pixel through the visible **this device** entry, opened
+the Accelerometer configuration sheet, selected 5 Hz, closed the sheet, and
+tapped Apply Profiles. Live Data displayed the Accelerometer card. The test
+then opened Recorder, verified Start Recording was enabled, recorded for two
+seconds, stopped, expanded the newest recording folder, and verified a CSV row
+with a non-zero displayed size. It confirmed deletion of that test-created
+folder, verified **No recordings yet**, and disconnected the phone fixture.
+
+This proves the app's UI path from local sensor discovery through configuration,
+stream setup, file creation, history refresh, and cleanup on this phone. It does
+not replace the corresponding OpenEarable BLE, multi-sensor, accuracy, or
+long-duration tests.
diff --git a/open_wearable/docs/testing/runs/2026-09-29-pixel-9a-this-device.md b/open_wearable/docs/testing/runs/2026-09-29-pixel-9a-this-device.md
new file mode 100644
index 000000000..f76f6c551
--- /dev/null
+++ b/open_wearable/docs/testing/runs/2026-09-29-pixel-9a-this-device.md
@@ -0,0 +1,27 @@
+# Phone-as-device connection — Pixel 9a, Android 17
+
+## Environment
+
+| Field | Value |
+| --- | --- |
+| Date | 2026-09-29 (Europe/Berlin) |
+| Phone | Google Pixel 9a (`tegu`) |
+| Android | 17, API 37 |
+| Test app | `edu.kit.teco.openWearable.patrol` (`OpenWearables Test`) |
+| Journey | `patrol_test/this_device_connection_test.dart` |
+
+## Result
+
+The run passed with one successful journey, zero failures, and zero skips. It
+completed 31 logged Patrol actions in 19 seconds; the complete device phase
+took 82.8 seconds.
+
+Patrol granted the native Android permissions, opened Connect Devices, and
+tapped the Pixel entry marked **this device**. The app probed the phone's real
+local sensor capabilities before adding it. The test verified the phone in the
+Connected list, a Connected Devices count of one on Overview, and the phone's
+device-detail page. It then disconnected the phone fixture and verified the
+empty Devices action returned.
+
+No external OpenEarable was selected or changed. The isolated Patrol package
+was removed after execution.
diff --git a/open_wearable/docs/testing/runs/2026-09-30-pixel-9a-openearable-pair.md b/open_wearable/docs/testing/runs/2026-09-30-pixel-9a-openearable-pair.md
new file mode 100644
index 000000000..c43fd3c02
--- /dev/null
+++ b/open_wearable/docs/testing/runs/2026-09-30-pixel-9a-openearable-pair.md
@@ -0,0 +1,44 @@
+# OpenEarable stereo pair — Pixel 9a, Android 17
+
+## Environment
+
+| Field | Value |
+| --- | --- |
+| Date | 2026-09-30 (Europe/Berlin) |
+| Phone | Google Pixel 9a (`tegu`) |
+| Android | 17, API 37 |
+| Test app | `edu.kit.teco.openWearable.patrol` (`OpenWearables Test`) |
+| Journey | `patrol_test/open_earable_pair_test.dart` |
+| Earables | Two `OpenEarable-2B01` devices, one left and one right |
+| Firmware observed | `2.2.7-dev.12+g23ff47e.dirty` on both sides |
+
+## Result
+
+The final run passed with one successful journey, zero failures, and zero
+skips. Patrol logged 45 actions in the 45-second Dart journey; the complete
+build, installation, and device phase took 90.9 seconds.
+
+The devices used private BLE addresses that changed after power cycling. The
+successful run discovered `6E:02:38:B2:F9:67` and `79:BC:C9:DC:E0:ED` at
+runtime. These are run-local identifiers, not stable fixture identities.
+
+Patrol granted the Android permissions, opened Connect Devices, enabled the
+OpenEarable-only filter, and required exactly two matching advertisers before
+selecting anything. It connected both exact runtime rows and verified that the
+main Devices screen produced one combined pair containing both `L` and `R`
+status labels. It switched **Combine stereo pair** off and verified two
+side-specific device rows, switched it on and verified the combined card
+returned, then used guaranteed cleanup to split the pair and disconnect both
+runtime IDs through their device-detail controls.
+
+Several development runs established two fixture constraints. Android BLE
+addresses rotate after a power cycle, so a saved address cannot select these
+devices reliably. The tested devices also stopped advertising after an app
+disconnect and needed to be woken or power-cycled before the next fresh run.
+The final journey handles address rotation and scan retries; waking hardware
+remains a physical fixture step.
+
+This verifies app-visible discovery, two real GATT connections, stereo side
+metadata, pair grouping, split/recombine behavior, and cleanup. It does not
+verify physical audio output, sensor accuracy, partial-pair loss, or every
+pair-specific control.
diff --git a/open_wearable/docs/testing/runs/2026-09-30-pixel-9a-pair-sample-rates.md b/open_wearable/docs/testing/runs/2026-09-30-pixel-9a-pair-sample-rates.md
new file mode 100644
index 000000000..04e0b04c7
--- /dev/null
+++ b/open_wearable/docs/testing/runs/2026-09-30-pixel-9a-pair-sample-rates.md
@@ -0,0 +1,65 @@
+# Pixel 9a OpenEarable pair sample-rate run — 2026-09-30
+
+## Fixture
+
+| Item | Value |
+| --- | --- |
+| Phone | Google Pixel 9a |
+| Android | Android 17 / API 37 |
+| Phone serial | Redacted from public documentation |
+| Devices | Two OpenEarable-2B01 units, combined as L/R pair |
+| Firmware observed for this fixture | `2.2.7-dev.12+g23ff47e.dirty` |
+| Runtime BLE IDs | Automatically discovered; redacted from public documentation |
+| Suite | `PairSampleRate` / `RATE-01` |
+| Requested rates | 25, 50, and 100 Hz |
+| Recording window | 12 seconds per requested rate |
+| Allowed deviation | 15% |
+
+The BLE IDs are evidence for this run only. These devices use rotating Android
+addresses, so the test discovers and captures the current IDs each time. A
+reader does not enter or replace these historical values when running the pair
+test.
+
+## Result
+
+**Passed:** 1 test, 120 Patrol actions, 0 failures, 0 skipped. The test phase
+took 106 seconds; build plus installation and execution took 2 minutes 35
+seconds.
+
+| Side | Requested | Observed | Samples received | Timestamp span | Difference |
+| --- | ---: | ---: | ---: | ---: | ---: |
+| L | 25.00 Hz | 24.99 Hz | 309 | 12.323 s | -0.04% |
+| R | 25.00 Hz | 24.99 Hz | 318 | 12.683 s | -0.04% |
+| L | 50.00 Hz | 49.95 Hz | 621 | 12.412 s | -0.10% |
+| R | 50.00 Hz | 49.95 Hz | 638 | 12.752 s | -0.10% |
+| L | 100.00 Hz | 99.90 Hz | 1,245 | 12.452 s | -0.10% |
+| R | 100.00 Hz | 99.90 Hz | 1,271 | 12.712 s | -0.10% |
+
+For each requested rate, Patrol opened the combined pair's 9-Axis IMU
+configuration, enabled Bluetooth streaming, selected the exact rate, applied
+the configuration, confirmed the accelerometer Live Data card, recorded, and
+stopped through visible controls. The test then found the non-empty left and
+right accelerometer CSV files and checked numeric, strictly increasing
+microsecond timestamps.
+
+The observed rate for each side was calculated from data the app received and
+wrote:
+
+```text
+(number of received samples - 1) / (last timestamp - first timestamp)
+```
+
+Each result was inside the configured ±15% range. The test also confirmed both
+files appeared in the expanded Recorder UI, deleted each successful test
+recording through its confirmation dialog, split the pair during cleanup, and
+disconnected both devices.
+
+## Scope limit
+
+This result verifies end-to-end received accelerometer cadence for the tested
+rates and fixture. It does not establish accelerometer value accuracy, packet
+jitter distribution, L/R clock synchronization, performance during phone
+background/lock, other sensors, or long-duration loss behavior.
+
+The generated Android report for the most recent local run is under
+`build/app/reports/androidTests/connected/debug/index.html`.
diff --git a/open_wearable/docs/testing/runs/2026-10-15-pixel-9a-upstream-main-regression.md b/open_wearable/docs/testing/runs/2026-10-15-pixel-9a-upstream-main-regression.md
new file mode 100644
index 000000000..0fabf0a23
--- /dev/null
+++ b/open_wearable/docs/testing/runs/2026-10-15-pixel-9a-upstream-main-regression.md
@@ -0,0 +1,72 @@
+# Pixel 9a regression run on updated upstream main
+
+Date: 2026-10-15  
+Phone: Pixel 9a, Android 17 / API 37  
+App source: `upstream/main` at `38beb402e27c6f9ffff2e0e5a259bc3821e4ddc1`  
+Test source: `test/patrol-after-merged-pr` at `daebce0aa9d4047271e08f67cfd9230a3e846446` plus the uncommitted test/doc updates in that checkout.  
+Build: Android debug Patrol APKs built successfully for Settings, PairSampleRate, and each executed suite.
+
+## Results
+
+| Suite | Result | Notes |
+| --- | --- | --- |
+| `Settings` | Passed | All six General settings changed, remained changed after reopening the page, then were restored. This includes the new Show sampling rates setting. |
+| `Navigation` | Passed | Onboarding skip path, main tabs, missing-permission explanation, and Keep screen awake toggle. |
+| `Overview` | Passed | All four shortcuts opened the expected no-device destination. |
+| `Permissions` | Passed | Granted Android Bluetooth/location and microphone prompts during onboarding. |
+| `PermissionRecovery` | Passed | Skipped microphone during onboarding, then granted it from Connect Devices. |
+| `ThisDevice` | Passed after test-harness fix | First run completed its UI assertions but failed teardown with an active Flutter semantics handle. Disabling semantics for this widget-tree-driven Patrol test fixed teardown; the rerun passed. |
+| `ThisDeviceData` | Passed | Selected 5 Hz for the phone Accelerometer, streamed, recorded a non-empty CSV, deleted it, and disconnected. This test verifies CSV existence, not the phone's measured 5 Hz rate. |
+| `PairDiscovery` | Passed on retry | The first run found no matching rows; after the pair lifecycle run, the discovery-only rerun found at least two devices. |
+| `PairHardware` | Passed | Discovered and connected two devices, checked L/R identities, split and recombined the pair, then disconnected both. |
+| `PairSampleRate` | Passed after fixture wake and test fix | The first attempt found no pair. The next attempt connected both rotating IDs, but a “Firmware Update Available” dialog for firmware 2.2.9 covered the app. Added visible dismissal and partial-pair cleanup, then woke both devices and reran successfully. L and R CSV measurements were 24.99 Hz for requested 25 Hz, 49.95 Hz for requested 50 Hz, and 99.90 Hz for requested 100 Hz. Every rate passed the 15% tolerance; all three test recordings were deleted and both devices disconnected. |
+| `Hardware` (single exact ID) | Not completed | APK built, but the exact BLE ID captured by the earlier pair test was no longer visible when this run scanned. The Pixel also briefly disappeared from ADB during this run. This is not a device-details assertion result. |
+
+### RATE-01 measurements
+
+The sample-rate assertion used each received CSV's first-column timestamps;
+the values below were captured from the phone's test log. Each side passed the
+15% tolerance, with strictly increasing timestamps and sufficient recording
+span.
+
+| Requested | Left samples / span / measured rate | Right samples / span / measured rate |
+| --- | --- | --- |
+| 25 Hz | 309 / 12.323 s / 24.99 Hz | 318 / 12.683 s / 24.99 Hz |
+| 50 Hz | 621 / 12.412 s / 49.95 Hz | 637 / 12.732 s / 49.95 Hz |
+| 100 Hz | 1,244 / 12.442 s / 99.90 Hz | 1,271 / 12.712 s / 99.90 Hz |
+
+## Interpretation
+
+The latest main-based app passed the phone-only flows, all six settings, phone
+sensor recording, the two-device pairing lifecycle, and RATE-01. The sample-rate
+test verified all three requested settings against timestamps in the CSV files
+written by the app: both sides measured 24.99 Hz, 49.95 Hz, and 99.90 Hz for
+requested 25, 50, and 100 Hz. It checked monotonic timestamps, recording span,
+sample count, and the 15% tolerance. This run did not validate the
+expected/actual rate labels on the live charts; those remain outside the
+existing Patrol assertions.
+
+The PairDiscovery test's empty scan and the later successful hardware runs show
+that BLE visibility varied during this session. OpenEarables must be advertising
+when the test scans; being powered on alone does not guarantee that the phone
+will see them. A wake/power cycle restored advertising. The PairSampleRate helper
+now dismisses the firmware notice and attempts cleanup after an interrupted
+partial connection.
+
+## Rerun commands
+
+From `open_wearable` in PowerShell, replace the Android serial with the value
+shown by `adb devices -l`:
+
+```powershell
+.\tool\ui_tests\run_android.ps1 -Suite PairSampleRate `
+  -AndroidDevice <phone-serial> `
+  -SampleRatesHz 25,50,100 `
+  -SampleDurationSeconds 12 `
+  -SampleTolerancePercent 15
+```
+
+The sample-rate test calculates the received accelerometer rate on the phone
+from each device's CSV timestamps. A pass checks the left and right rates
+against each requested rate within 15%. The table above records the observed
+sample counts, durations, and rates from this run.
diff --git a/open_wearable/docs/testing/test-catalog.md b/open_wearable/docs/testing/test-catalog.md
new file mode 100644
index 000000000..bdb342df2
--- /dev/null
+++ b/open_wearable/docs/testing/test-catalog.md
@@ -0,0 +1,322 @@
+# Patrol test catalog
+
+This catalog separates three different facts that are easy to confuse:
+
+- **Implemented** means a Patrol test exists in this repository.
+- **Verified** means that exact test has passed on the documented real phone and fixture.
+- **Planned** means the app could be tested this way, but no automated journey implements it yet.
+
+A green suite proves only the assertions listed below. It does not prove every
+feature on the screens that the journey happened to visit.
+The real-phone passes listed here record their specific run dates and fixtures.
+The current main-based Android run passed several existing paths, including
+the pair sample-rate check. See the
+[current regression run](runs/2026-10-15-pixel-9a-upstream-main-regression.md)
+for exact outcomes; historical passes do not substitute for unrun assertions.
+
+## How to choose a test
+
+Show the selectable suite names without running anything:
+
+```powershell
+.\tool\ui_tests\run_android.ps1 -ListSuites
+```
+
+Use the beginner-friendly numbered menu:
+
+```powershell
+.\tool\ui_tests\choose_android_test.ps1 -AndroidDevice '<phone-serial>'
+```
+
+Or select a suite directly:
+
+```powershell
+.\tool\ui_tests\run_android.ps1 `
+  -Suite PairHardware `
+  -AndroidDevice '<phone-serial>'
+```
+
+`<phone-serial>` means the first-column identifier reported by `adb devices
+-l` or the identifier shown by `patrol devices`. If exactly one phone is
+connected, omit `-AndroidDevice` entirely. Pair suites discover the two current
+rotating OpenEarable Bluetooth IDs automatically; users never enter those
+IDs. Only the single-device `Hardware` suite needs an
+`-OpenEarableDeviceId`, copied from the app's Connect Devices scan screen.
+
+See [Find the command values](README.md#find-the-command-values) for examples,
+defaults, and the complete parameter table.
+
+## Implemented suites and their exact checks
+
+### `Navigation`
+
+File: [`navigation_and_settings_test.dart`](../../patrol_test/navigation_and_settings_test.dart)  
+Real-device state: **verified** on Pixel 9a, Android 17/API 37.
+
+It checks:
+
+1. The welcome screen appears on a clean test-app install.
+2. The user can skip first-run permission setup and reach the main app.
+3. Connect Devices explains that Bluetooth and Location are required.
+4. Back navigation returns from Connect Devices.
+5. Devices, Sensors, Apps, and Settings can all be opened from the main navigation.
+6. Sensors exposes its Configuration tab.
+7. Apps contains the Posture Tracker tile.
+8. General settings opens.
+9. Keep screen awake changes when tapped and can be restored to its original value.
+
+It does not check every control on those pages, physical Bluetooth discovery,
+sensor data, recordings, app relaunch persistence, or the behavior of keeping
+the real display awake.
+
+### `Permissions`
+
+File: [`onboarding_permissions_test.dart`](../../patrol_test/onboarding_permissions_test.dart)  
+Real-device state: **verified** on Pixel 9a, Android 17/API 37.
+
+It checks:
+
+1. The welcome screen appears.
+2. Android Bluetooth/nearby-device, Location, and Microphone permission dialogs can be completed through the onboarding UI.
+3. The Overview page becomes available after onboarding.
+4. Connect Devices no longer shows either permission-recovery card.
+
+It does not check permanent denial, “Don't ask again,” permission revocation in
+Android Settings, upgrading from an older app version, or iOS permission dialogs.
+
+### `PermissionRecovery`
+
+File: [`late_microphone_permission_test.dart`](../../patrol_test/late_microphone_permission_test.dart)  
+Real-device state: **verified** on Pixel 9a, Android 17/API 37.
+
+It checks:
+
+1. Bluetooth/Location can be granted while Microphone is deliberately skipped.
+2. Connect Devices shows the missing-Microphone recovery action but no Bluetooth recovery action.
+3. Tapping recovery opens the Android permission flow.
+4. After granting, both recovery messages disappear and scanning is available.
+
+It does not check a permanently denied Microphone permission, denial a second
+time, revocation while the app is running, or recovery through system Settings.
+
+### `Overview`
+
+File: [`overview_shortcuts_test.dart`](../../patrol_test/overview_shortcuts_test.dart)  
+Real-device state: **verified** on Pixel 9a, Android 17/API 37.
+
+It checks:
+
+1. With no devices, Overview says that the app is disconnected.
+2. Connect Devices opens the correct connection screen.
+3. Configure Sensors opens the correct no-device configuration state with a scan action.
+4. View Sensor Data opens the correct no-device Live Data state with a scan action.
+5. Record opens Local Recorder.
+6. Recorder reports that no sensors are connected.
+7. Start Recording is disabled when no sensor exists.
+8. The user can return to Overview.
+
+It does not check shortcut behavior with connected devices, active streams, or
+an active recording.
+
+### `Settings`
+
+File: [`general_settings_test.dart`](../../patrol_test/general_settings_test.dart)  
+Real-device state: all six switches were verified on Pixel 9a, Android 17/API
+37, 2026-10-15: each changed, remained changed after reopening General settings,
+and was restored. Process-relaunch persistence remains planned; see the
+[current regression run](runs/2026-10-15-pixel-9a-upstream-main-regression.md).
+
+It checks each of these six switches:
+
+- Bluetooth auto-connect
+- Keep screen awake
+- Disable all sensors on app close
+- Disable live data graphs
+- Hide live data graphs without data
+- Show sampling rates
+
+For every switch it records the original value, changes it, leaves and reopens
+General settings, confirms that the changed value remains, restores the
+original value, reopens the page again, and confirms cleanup.
+
+It does not terminate/relaunch the process, wait for screen timeout, exercise
+auto-connect with hardware, close the app with active sensors, or verify how
+the graph settings change rendered graphs or sampling-rate labels.
+
+### `ThisDevice`
+
+File: [`this_device_connection_test.dart`](../../patrol_test/this_device_connection_test.dart)  
+Real-device state: **verified** on Pixel 9a, Android 17/API 37 on 2026-09-29
+and again on 2026-10-15 against the current main-based app.
+
+It checks:
+
+1. The phone can be chosen from the visible scan screen as a sensor device.
+2. Its scan entry disappears after connection.
+3. The Devices page shows the connected phone.
+4. Overview changes to one connected device.
+5. The phone's device-details page opens.
+6. Disconnect removes the connected row and returns the Devices page to its connect state.
+
+It does not check every phone sensor, unsupported-sensor handling, background
+behavior, reconnect, or phone model-specific sampling limitations.
+
+### `ThisDeviceData`
+
+File: [`this_device_recording_test.dart`](../../patrol_test/this_device_recording_test.dart)  
+Real-device state: **verified** on Pixel 9a, Android 17/API 37 twice on
+2026-09-29 and again on 2026-10-15 against the current main-based app.
+
+It checks:
+
+1. The phone connects as a sensor device.
+2. The Accelerometer configuration sheet opens.
+3. A 5.00 Hz choice is selectable.
+4. Applying the configuration exposes Accelerometer in Live Data.
+5. Live Data is no longer stuck at “Waiting for live sensor data.”
+6. Recorder is enabled.
+7. A two-second recording starts and stops through the visible UI.
+8. The latest recording exposes at least one CSV whose displayed size is not zero.
+9. Confirmed deletion removes that recording and restores “No recordings yet.”
+10. The phone sensor device disconnects cleanly.
+
+It does not calculate the phone's actual received sample rate, validate CSV
+columns or values, test other phone sensors/rates, keep multiple recordings, or
+test file opening and sharing.
+
+### `PairDiscovery`
+
+File: [`pair_discovery_test.dart`](../../patrol_test/pair_discovery_test.dart)  
+Real-device state: passed on Pixel 9a / Android 17 (API 37) on 2026-10-15 after
+an initial scan with no results; it remains a discovery-only check, while the
+pair lifecycle test makes the final pairing assertions.
+
+It checks:
+
+1. The OpenEarable-only filter can be enabled.
+2. An eight-second BLE scan completes.
+3. At least two filtered OpenEarable rows are present.
+4. The phone-as-device row is absent from that filtered result.
+5. It does not connect to any discovered device.
+
+It does not require exactly two devices, distinguish left from right, connect,
+or prove that either advertiser is usable.
+
+### `PairHardware`
+
+File: [`open_earable_pair_test.dart`](../../patrol_test/open_earable_pair_test.dart)  
+Real-device state: **verified** on Pixel 9a, Android 17/API 37 with two
+OpenEarable-2B01 devices running firmware `2.2.7-dev.12+g23ff47e.dirty` on
+2026-09-30 and again on 2026-10-15 against the current main-based app.
+
+It checks:
+
+1. The app filters scan results to OpenEarables.
+2. Exactly two matching devices must advertise; ambiguity causes a failure.
+3. Their current rotating Android BLE IDs are captured at runtime.
+4. Both exact scan rows connect.
+5. The Devices page creates one combined stereo-pair card.
+6. The combined card visibly contains both L and R identities.
+7. Splitting produces both exact individual device rows.
+8. The individual devices have different side labels, one L and one R.
+9. Recombining recreates the combined pair card.
+10. Guaranteed cleanup splits the pair and disconnects both devices.
+
+It does not configure sensors, stream, record, test partial-pair loss, verify
+audio/LED/battery features, or measure left/right time synchronization.
+
+### `PairSampleRate`
+
+File: [`open_earable_pair_sample_rate_test.dart`](../../patrol_test/open_earable_pair_sample_rate_test.dart)  
+Real-device state: **verified** on Pixel 9a, Android 17/API 37 with two
+OpenEarable-2B01 devices on 2026-09-30 and again on 2026-10-15 against current
+main. The current-main run checked 25/50/100 Hz and measured 24.99, 49.95, and
+99.90 Hz on both L/R accelerometer CSVs, respectively. An earlier attempt
+revealed a firmware-update dialog that blocked the UI; the helper now dismisses
+it and cleans up partial connections. See the [current regression run](runs/2026-10-15-pixel-9a-upstream-main-regression.md).
+
+For every requested rate, it checks:
+
+1. Exactly two OpenEarables are discovered and connected as a combined L/R pair.
+2. The combined `9-Axis IMU` configuration sheet opens.
+3. `Live stream to phone` is enabled for the pair.
+4. The exact requested rate is offered by the connected firmware; absence fails clearly.
+5. Applying the setting produces an `ACCELEROMETER` Live Data card.
+6. Recording starts through the visible Recorder UI.
+7. Recording stays active for the configured duration, 12 seconds by default.
+8. Recording stops and its files finish writing.
+9. The newest recording has one non-empty accelerometer CSV for L and one for R.
+10. Every received timestamp in each checked file is numeric and strictly increasing.
+11. Each file spans at least 60% of the requested recording window and contains at least ten samples.
+12. The observed rate is calculated independently for L and R as `(received samples - 1) / (last timestamp - first timestamp)`.
+13. Each observed rate is within the selected tolerance of the requested rate, 15% by default.
+14. Requested rate, observed rate, sample count, time span, side, and filename are printed as evidence.
+15. The test-created recording is deleted through the visible UI after a successful check.
+16. Both devices are disconnected in guaranteed cleanup.
+
+The OpenEarable 2 firmware in this workspace advertises `25`, `50`, and `100`
+Hz as streamable 9-Axis IMU rates. Run all three in one connection:
+
+```powershell
+.\tool\ui_tests\run_android.ps1 `
+  -Suite PairSampleRate `
+  -AndroidDevice '<phone-serial>' `
+  -SampleRatesHz 25,50,100 `
+  -SampleDurationSeconds 12 `
+  -SampleTolerancePercent 15
+```
+
+This test measures samples that reached the app and were written to CSV. It
+does not prove that acceleration values are physically accurate, that samples
+are synchronized between L and R, that packet timing has low jitter, that
+every other sensor meets its rate, that long recordings remain loss-free, or
+that the expected/actual sampling-rate labels on the live graphs agree with the
+CSV measurements. Those are separate checks listed below.
+
+### `Hardware`
+
+File: [`open_earable_connection_test.dart`](../../patrol_test/open_earable_connection_test.dart)  
+Real-device state: implemented for a single exact ID; rotating OpenEarable 2
+addresses make `PairHardware` the safer default for the current two-device fixture.
+
+It checks:
+
+1. A non-empty exact Bluetooth ID was supplied.
+2. That exact device appears in scan results and connects.
+3. Its details page opens and contains Device Information and Battery sections.
+4. It disconnects and becomes discoverable again.
+5. It reconnects, reopens details, and disconnects again for cleanup.
+
+It does not assert the displayed serial/version/battery values, accept rotating
+IDs automatically, or test any device control beyond connect/disconnect.
+
+## Features the framework could check but does not yet automate
+
+The complete case-by-case backlog is in [`ui-coverage.md`](ui-coverage.md).
+The main missing areas are:
+
+| Area | Examples of checks still available to add |
+| --- | --- |
+| Connection failures | Bluetooth off, scan timeout, connection timeout, cancellation, retry, out-of-range loss, auto-reconnect, duplicate devices, a third nearby OpenEarable, one side disappearing from a pair, preserving the surviving side while recovering its partner, retrying an unknown stereo position, and Android BLE cleanup after reconnect. |
+| Device information | Exact name, identifier, hardware/firmware version, battery level/status/health/energy, refresh behavior, and capability-dependent sections. |
+| Pair behavior | Side reassignment, restart persistence, mismatched firmware, partial-pair operation, multiple pairs, pair time synchronization, and reconnect after one or both devices sleep. |
+| Device controls | Listening mode, microphone source and gain, mute/reset, power-saving mode, saved status-LED/RGB values after reopening or changing devices, and verifying the physical output of those controls. |
+| Sensor configuration | Every sensor, sorted rate choices, every advertised rate, device-reported state after Apply, Stream versus on-device SD target and filename prefix, Off, multiple simultaneous sensors, saved profiles, invalid/duplicate profile names, pair readback after splitting, and failure during Apply. |
+| Sample-rate quality | The expected/actual labels on live graphs, all streamable sensors and rates, multiple sensors concurrently, long-duration loss rate, jitter distribution, maximum timestamp gap, duplicated samples, L/R clock offset and drift, background/locked-phone behavior, and repeatability across firmware versions. The current pair test checks only CSV timestamps for the 9-Axis IMU. |
+| Live Data | Correct units and axes, numerical updates, chart detail, channel visibility, expected/actual rate labels, low/high-pass and notch controls, no-data hiding, disabled graphs, and disconnect/reconnect while graphs are open. |
+| Recorder | Multiple recordings, elapsed-time accuracy, navigation while recording, rapid Start/Stop, stop-and-disable-sensors behavior, on-device recording prefixes/targets, filename/content schema, file-open failures, open/share/cancel, batch delete, locked/background recording, Android microphone capture during music playback, storage-full errors, and recordings across reconnect. |
+| Labels | Create/edit/delete label groups, validation, persistence, segment switching while recording, and exported label timing. |
+| Built-in apps | Posture Tracker stop/leave cleanup and reconnect recovery; calibration and reminders; Heart Tracker reconnect recovery, signals, and quality states; Seal Check measurement, graphs, export, retry, and disconnect behavior. |
+| Network connector | Enable/disable, port/path validation, persistence, local client connection, message schema, sensor-configuration report sharing, websocket/log lifecycle, disconnection, and no-network recovery. |
+| Logs and About | Open/share/delete logs, empty/error logs, shared logging lifecycle, version display, licenses, and browser links. |
+| Firmware update | Checklist, release catalog, offline retry, file picker, progress, cancel/abort gating, early reconnect and verification countdown, image-slot recovery, preserved FOTA logs, successful lab update, and failure without a false success. |
+| Android lifecycle/accessibility | Home/background, lock/unlock, process death, permission revocation, rotation, font/display scaling, keyboard overlap, dark mode, and screen-reader semantics. |
+| iPhone | The corresponding iOS onboarding, permissions, Bluetooth, native dialogs, background behavior, recording storage/sharing, and hardware journeys. |
+| Sensor decoding compatibility | 1.6 compact IMU/PPG data decoding and firmware-revision selection. The Patrol rate test inspects CSV timestamps only; deterministic payload decoding belongs in package tests with captured fixtures, plus hardware smoke tests for live values and firmware variants. |
+| Performance/reliability | Memory growth, battery use, UI responsiveness, repeated connect/disconnect cycles, hour-long streaming/recording, and stress with many sensors. |
+| Physical correctness | Known-motion sensor calibration, sensor bias/noise, optical/temperature reference comparison, audio quality, microphone gain response, LED color/brightness, and seal/heart algorithm accuracy. These require controlled fixtures or reference instruments in addition to Patrol. |
+
+Patrol can automate the app and Android system UI for most rows. Physical
+correctness needs external equipment or a controlled fixture, and firmware
+unit/integration tests should cover low-level protocol behavior that cannot be
+observed reliably through a phone UI alone.
diff --git a/open_wearable/docs/testing/ui-coverage.md b/open_wearable/docs/testing/ui-coverage.md
new file mode 100644
index 000000000..6d7f73aa5
--- /dev/null
+++ b/open_wearable/docs/testing/ui-coverage.md
@@ -0,0 +1,229 @@
+# App user-journey coverage
+
+This inventory defines tests that operate the real app through its user interface on a real phone, connected to real OpenEarables when a feature requires them. Patrol performs the taps, text entry, scrolling, navigation, and native-dialog interaction. The main assertion is the user-visible result of each action. Tests must not invoke a provider or BLE command in place of the UI action being tested.
+
+The first target is Android. Repeat the applicable journeys on iPhone after the Android foundation works. This is a source-derived inventory, not evidence that the journeys currently pass. Add scenarios when exploratory use exposes additional states or interactions.
+
+## Reading and maintaining this inventory
+
+- **Planned** means a scenario has not yet been implemented as a phone test. When implemented, record its test path; passing requires a real run and its evidence. A widget/unit test alone does not complete a row here.
+- **Implemented, unverified** means the complete automated path exists and builds, but still needs a real-phone run. **Partial, unverified** means the linked path covers only the stated subset. Neither status means passed.
+- **Verified** means the linked automated path passed on the named real-phone environment. **Partial, verified** means the stated subset passed while the rest of the row remains planned. A pass on one phone/OS does not replace the device matrix.
+- **None** means no earable is required; the real phone is always required. **One** means one identified test earable. **Pair** means known left/right earables. Other prerequisites name the capability or environment needed in addition.
+- **UI** is suitable for automatic UI operation and assertions. **UI + fixture/manual** means an external condition, physical action, or observation is needed; record these separately so an automated tap is not reported as validation of sound, light, fit, or sensor accuracy.
+- Expand a parameterized row into separate results for every supported option, sensor, channel, device, and relevant phone OS. A row is complete only when its applicable variants are covered.
+- Record **not applicable** with the observed device capability and reason; do not silently pass a missing feature. Record **blocked** when a required capability, phone, permission state, or fixture is unavailable.
+- Use test-created profiles, labels, recordings, and logs for destructive scenarios. Restore settings and disconnect test devices during cleanup; preserve failure evidence before cleanup.
+- For each run keep app/library/firmware versions, phone and OS, target device IDs, case ID, outcome, failed step, screenshot, and relevant app/device logs. A feature opening successfully does not prove that its action succeeded.
+
+Suggested order: implement startup/navigation, connect, configure/live data, and record journeys first; then settings/data management, capability-specific controls and mini-apps, then recovery and lifecycle combinations. Firmware installation, slot erase, and deliberate interrupted updates belong to an explicitly selected device-maintenance run with a recoverable test device.
+
+## Startup, onboarding, navigation, and overview
+
+Sources: [router](../../lib/router.dart), [startup/onboarding](../../lib/widgets/onboarding/permissions_onboarding_page.dart), [home shell](../../lib/widgets/home_page.dart), [overview](../../lib/widgets/home_page_overview.dart), [release pages](../../lib/widgets/updates/).
+
+| ID | User actions | Prerequisites / mode | Expected user-visible outcome | Status |
+| --- | --- | --- | --- | --- |
+| NAV-01 | Fresh install; launch; tap Get Started; allow the Bluetooth/location prompts appropriate to the Android version; allow microphone. | None; fresh permission state; UI | Welcome and permission pages advance in order; app reaches Overview without hanging at startup. | Verified on Pixel 9a / Android 17 (API 37), 2026-09-29 and 2026-10-15: [`onboarding_permissions_test.dart`](../../patrol_test/onboarding_permissions_test.dart); [current run record](runs/2026-10-15-pixel-9a-upstream-main-regression.md). |
+| NAV-02 | Fresh install; deny Bluetooth permission or choose Skip for now; finish onboarding; open Devices and Connect Devices. | None; UI | App remains usable; connection screen explains missing permission and offers Enable. No false connected state. | Verified three times on 2026-09-29 and again on 2026-10-15 on Pixel 9a / Android 17 (API 37): [`navigation_and_settings_test.dart`](../../patrol_test/navigation_and_settings_test.dart); [current run record](runs/2026-10-15-pixel-9a-upstream-main-regression.md). |
+| NAV-03 | Deny/skip microphone onboarding; later tap Enable Microphone from connection screen and grant permission. | None; UI | Non-audio navigation works; the permission reminder reflects the granted state. | Verified on Pixel 9a / Android 17 (API 37), 2026-09-29 and 2026-10-15: [`late_microphone_permission_test.dart`](../../patrol_test/late_microphone_permission_test.dart); [current run record](runs/2026-10-15-pixel-9a-upstream-main-regression.md). |
+| NAV-04 | Deny repeatedly/permanently; follow the offered system-settings recovery; return to app. | None; permission-reset fixture; UI | Recovery remains reachable; app reflects changed permissions when resumed without duplicate dialogs. | Planned |
+| NAV-05 | Finish onboarding; close and relaunch normally. | None; UI | Welcome is not shown again; startup reaches the app with saved preferences. | Planned |
+| NAV-06 | Tap Overview, Devices, Sensors, Apps, Settings; scroll each screen; repeat in reverse order. | None; UI | Correct section title/content is displayed; controls remain usable; empty states appear where hardware is absent. | Partial, verified three times on Pixel 9a / Android 17 (API 37), 2026-09-29: forward section navigation in [`navigation_and_settings_test.dart`](../../patrol_test/navigation_and_settings_test.dart); scrolling and reverse order remain planned; [run record](runs/2026-09-29-pixel-9a-navigation.md). |
+| NAV-07 | On Overview tap Connect devices, Configure sensors, View sensor data, and Record, returning between actions. | None; repeat with One; UI | Each shortcut opens the correct screen or Sensors tab; its state matches the connected session. | Partial, verified on Pixel 9a / Android 17 (API 37), 2026-09-29 and 2026-10-15: all four shortcuts and their no-device states passed in [`overview_shortcuts_test.dart`](../../patrol_test/overview_shortcuts_test.dart); the connected-device variant remains planned; [current run record](runs/2026-10-15-pixel-9a-upstream-main-regression.md). |
+| NAV-08 | Open a detail screen, sheet, and dialog; dismiss using visible close/back and Android system Back. | None; repeat One; UI | Returns to the expected parent, preserves applicable tab state, and does not leave overlays blocking touches. | Planned |
+| NAV-09 | Open Overview after connecting, starting/stopping recording, and disconnecting; open a device card. | One; UI | Device counts/cards and recording summary reflect the current session; card opens that device. | Planned |
+| NAV-10 | Open Release history from Settings; open each listed release; scroll; Close/Continue; return. | None; release registry entries; UI | Correct version/highlights render and navigation returns correctly. | Planned |
+| NAV-11 | Install an app update over an existing install with an unseen registered release; dismiss highlights; relaunch. | None; version-upgrade fixture; UI | Upgrade highlights appear according to the release policy, then do not repeatedly interrupt later launches. | Planned |
+
+## Discovery, connection, device list, and pairing
+
+Sources: [connection screen](../../lib/widgets/devices/connect_devices_page.dart), [device list](../../lib/widgets/devices/devices_page.dart), [device details](../../lib/widgets/devices/device_detail/device_detail_page.dart).
+
+| ID | User actions | Prerequisites / mode | Expected user-visible outcome | Status |
+| --- | --- | --- | --- | --- |
+| CON-01 | Open Connect Devices; wait for scan; locate the configured earable by ID; tap Connect. | One advertising; UI | Scan progress resolves; target moves to Connected; connected count changes; target appears in Devices. | Implemented, unverified: [`open_earable_connection_test.dart`](../../patrol_test/open_earable_connection_test.dart) |
+| CON-02 | Tap Scan Again after a scan; leave/reopen; pull to refresh where available. | One advertising; UI | A new scan runs and finishes; results do not accumulate duplicates; navigation stays responsive. | Planned |
+| CON-03 | Switch Device name filter off/on; edit Name contains; Apply; repeat Cancel and blank input. | One plus known other advertiser; UI | Results match the active filter; Cancel/blank input does not accidentally replace its previous value. | Planned |
+| CON-04 | Scan with no matching devices nearby; then make the target available and rescan. | One with controlled availability; UI + fixture/manual | Helpful empty/scanning states appear; rescan discovers the target without restarting the app. | Planned |
+| CON-05 | Tap Connect twice rapidly; try connection while target becomes unavailable; dismiss Connection Error; retry. | One with controlled availability; UI + fixture/manual | Busy/error state is clear; no duplicate device rows; retry recovers after target returns. | Planned |
+| CON-06 | Disable Bluetooth using phone system UI; open scan; enable Bluetooth and retry. | One; UI | Permission/adapter state is actionable; no endless spinner; discovery/connection works after recovery. | Planned |
+| CON-07 | Connect target; open Device details; disconnect; connect the same target again. | One; UI | Device disappears from connected views; reconnect restores its card and usable controls. | Implemented, unverified: [`open_earable_connection_test.dart`](../../patrol_test/open_earable_connection_test.dart) |
+| CON-08 | On Devices pull to refresh with an already system-connected supported device. | One with applicable system-device connection; UI | App discovers/reuses the system device without duplicate entries. | Planned |
+| CON-09 | Connect both known sides; combine/split their Devices card; open each side's details and the pair controls. | Pair with StereoDevice; UI | Correct L/R identities, pair grouping, and individual details appear; no unrelated devices are grouped. | Verified on Pixel 9a / Android 17 (API 37), 2026-09-30 and 2026-10-15: runtime discovery required exactly two filtered OpenEarables; both connected; combined L/R card, split side rows, recombine, and two-device cleanup passed in [`open_earable_pair_test.dart`](../../patrol_test/open_earable_pair_test.dart); [current run record](runs/2026-10-15-pixel-9a-upstream-main-regression.md). Opening both detail pages for inspection beyond cleanup remains planned. |
+| CON-10 | Disconnect one member of a displayed pair; reconnect it. | Pair; UI | Remaining side remains accessible; pair presentation updates and returns consistently. | Planned |
+| CON-11 | From Device details tap Forget; Cancel; repeat and follow the offered Bluetooth settings handoff. | One supporting the system-device forget flow; UI | Cancel keeps the app state; native Bluetooth settings opens; returning is usable. Actual unpairing is an explicit test-fixture operation. | Planned |
+| CON-12 | With two independently identifiable devices, connect and open each; disconnect just one. | Two devices; UI | The chosen device's metadata and controls are used; the other connection is unaffected. | Planned |
+| CON-13 | Open Connect Devices; select the entry marked this device; inspect Connected, Overview, and details; disconnect it. | Phone with supported local sensors; UI | The phone appears once as a connected sensor device, Overview count updates, details open, and disconnect restores the empty Devices state. | Verified on Pixel 9a / Android 17 (API 37), 2026-09-29 and 2026-10-15: [`this_device_connection_test.dart`](../../patrol_test/this_device_connection_test.dart); [current run record](runs/2026-10-15-pixel-9a-upstream-main-regression.md). |
+
+## Device details and capability-dependent controls
+
+Source: [device detail controls](../../lib/widgets/devices/device_detail/). Repeat each case only on hardware exposing the named capability; verify absent capabilities separately in DEV-10.
+
+| ID | User actions | Prerequisites / mode | Expected user-visible outcome | Status |
+| --- | --- | --- | --- | --- |
+| DEV-01 | Open Device details; scroll information and battery sections; leave/reopen. | One; optional identifier, version, battery capabilities; UI | Correct target address/identifier and available versions/battery fields load; unavailable values are handled without a permanent loading state. | Partial, unverified: details and battery sections plus reopen in [`open_earable_connection_test.dart`](../../patrol_test/open_earable_connection_test.dart); field-level identity/version assertions remain planned. |
+| DEV-02 | Select every advertised Listening Mode; reopen the page to read the selection. | One + AudioModeManager; UI | Selected mode and relevant beta label render correctly; loaded device state is consistent. Acoustic effectiveness is a separate physical observation. | Planned |
+| DEV-03 | Select each LE Audio Microphone Stream option; reopen. | One + MicrophoneManager; UI | Inner/Outer or other supported choice is reflected correctly; selection survives the readback. | Planned |
+| DEV-04 | Change Outer/Inner microphone gain with sliders/step controls; test supported endpoints; Mute, Unmute, Reset. | One + MicrophoneGainManager; UI | Values, enabled state, mute state, and reset values update consistently without crossing bounds. Actual gain requires an acoustic fixture/manual check. | Planned |
+| DEV-05 | Select each supported Power Saving Mode and reopen details. | One + PowerSavingModeManager; UI | Selection is readable after the change; errors are surfaced instead of a false success. | Planned |
+| DEV-06 | For listening mode, microphone stream, and power mode toggle Apply to stereo pair; change selection; inspect both sides. | Pair with matching relevant capabilities; UI | Single-device scope affects its visible setting; pair scope updates both; side badges and differing values remain understandable. | Planned |
+| DEV-07 | Use pair microphone gain controls; change/reset/mute, then inspect each side. | Pair + MicrophoneGainManager on both; UI | Pair controls and side-specific details remain consistent. | Planned |
+| DEV-08 | Disable LED; enable override; open color picker, choose color, Done; reopen details and change selected device. | One + StatusLed and RgbLed; UI | Disable and override are mutually exclusive; picker visibility/color swatch and saved readback agree after reopening/device changes. Actual emitted light is UI + fixture/manual. | Planned |
+| DEV-09 | Open RGB LED color picker; choose a color and dismiss. | One + RgbLed without StatusLed; UI | RGB-only control appears and remains usable without the status-LED section. Actual light is a separate observation. | Planned |
+| DEV-10 | Open details on devices with different capability sets; compare available sections. | Capability-diverse test devices; UI | Unsupported controls are absent; supported sections remain reachable; battery/metadata absence does not break the page. | Planned |
+| DEV-11 | While a control sheet is open, disconnect the target or one paired side; attempt action; return/reconnect. | One/Pair with controlled availability; UI + fixture/manual | No crash or false success; failed/partial applications are visible where supported; app can recover. | Planned |
+
+## Sensor configuration and profiles
+
+Sources: [sensor workspace](../../lib/widgets/sensors/sensor_page.dart), [configuration controls](../../lib/widgets/sensors/configuration/).
+
+| ID | User actions | Prerequisites / mode | Expected user-visible outcome | Status |
+| --- | --- | --- | --- | --- |
+| CFG-01 | Open Sensors; switch Configure, Live Data, Recorder; return to Configure with no earable. | None; UI | Correct content/empty state per tab; no unusable loading overlay; connect entry is available as designed. | Partial, verified on Pixel 9a / Android 17 (API 37), 2026-09-29: Configure, Live Data, and Recorder no-device states were verified through the Overview shortcuts in [`overview_shortcuts_test.dart`](../../patrol_test/overview_shortcuts_test.dart); direct tab switching back to Configure remains planned; [run record](runs/2026-09-29-pixel-9a-overview-shortcuts.md). |
+| CFG-02 | Expand each device/configuration; open each sensor settings sheet; inspect and change supported sampling rates/data targets; close. | One + SensorConfigurationManager; UI | Sensor names, rates, targets, current/draft indicators match the selected settings; unsupported options are not offered. | Partial, verified on Pixel 9a / Android 17 (API 37): phone Accelerometer at 5 Hz on 2026-09-29 and paired OpenEarable 9-Axis IMU streaming at 25/50/100 Hz on 2026-09-30. Other sensors, rates, targets, and detailed draft/readback indicators remain planned; [phone run](runs/2026-09-29-pixel-9a-phone-sensor-recording.md), [pair-rate run](runs/2026-09-30-pixel-9a-pair-sample-rates.md). |
+| CFG-03 | Change a streaming sensor; tap Apply Profiles; reopen configuration and Live Data. | One + streaming/configuration capabilities; UI | Pending state resolves to reported configuration and live data becomes available; no success claim before the visible result. | Partial, verified on Pixel 9a / Android 17 (API 37): applying the phone Accelerometer at 5 Hz produced Live Data and a recording; applying paired OpenEarable IMU at 25/50/100 Hz produced L/R recordings at each requested cadence. Explicit configuration readback after reopening remains planned; [phone run](runs/2026-09-29-pixel-9a-phone-sensor-recording.md), [pair-rate run](runs/2026-09-30-pixel-9a-pair-sample-rates.md). |
+| CFG-04 | Choose Off for active sensors; Apply Profiles; inspect Configure/Live Data. | One; UI | Off state is shown consistently; app remains responsive when streams stop. | Planned |
+| CFG-05 | Configure multiple sensors/rates/targets together; Apply Profiles; revisit all rows. | One with multiple sensors; UI | All selected rows reflect the intended configuration; one row does not silently overwrite another. | Planned |
+| CFG-06 | Configure a combined stereo pair; apply; split/inspect each member. | Pair + matching configuration capabilities; UI | Mirrored configuration shows the intended values for both members. | Partial, verified on Pixel 9a / Android 17 (API 37), 2026-09-30: one combined 9-Axis IMU selection yielded matching requested L/R rates at 25/50/100 Hz. Splitting and inspecting each member's configuration readback remains planned; [run record](runs/2026-09-30-pixel-9a-pair-sample-rates.md). |
+| CFG-07 | Load each built-in profile; View details; Apply Profiles. | One; UI | Profile summary and selected settings agree; built-in profile actions do not allow inappropriate modification. | Planned |
+| CFG-08 | Enter a unique Profile name; Save Profile; change settings; load the saved profile; relaunch and load again. | One; UI | Saved profile appears with the correct values and persists; loading restores the draft before apply. | Planned |
+| CFG-09 | Save empty/reserved/duplicate profile names; Cancel or confirm overwrite/change-name dialogs. | One with test profile; UI | Appropriate validation/dialog appears; cancellation preserves original profile; confirmed overwrite updates the intended profile. | Planned |
+| CFG-10 | Open saved profile actions; View details, Load, Overwrite with current settings, Delete; test cancellation. | One with test profile; UI | Each action targets the selected profile; delete/overwrite confirmations work; unrelated profiles remain. | Planned |
+| CFG-11 | Try a saved profile from an incompatible configuration/device. | Two differing supported configurations + saved profile; UI | Profile mismatch/error is visible; the app stays usable and does not misrepresent applied state. | Planned |
+| CFG-12 | Edit On-Device Filename Prefix; Cancel; Save valid/empty/boundary input; reopen. | One + edge recorder; SD for actual recording; UI | Prefix display/validation follows supported limits; cancellation retains the previous value. SD file contents are outside this UI assertion. | Planned |
+| CFG-13 | Select an on-device data target; Apply Profiles; stop using Off and apply again. | One + edge recording target + prepared SD; UI | Target/rate/status is displayed consistently and control returns to Off. Reading actual SD files is a separate hardware check. | Planned |
+| CFG-14 | During pending apply, disconnect target; reconnect and retry. | One with controlled availability; UI + fixture/manual | Failure/unknown state does not masquerade as applied; configuration can be read and edited after recovery. | Planned |
+| CFG-15 | Open microphone configuration; Refresh inputs; choose each available input, then Off. | Phone microphone permission; optional LE Audio input; UI | Source list and chosen-source label update; unavailable input is handled clearly; Off stops the audio view. | Planned |
+
+## Live sensor and microphone views
+
+Sources: [live values](../../lib/widgets/sensors/values/), [channel filters](../../lib/widgets/sensors/values/sensor_chart/axis_configuration_sheet.dart).
+
+| ID | User actions | Prerequisites / mode | Expected user-visible outcome | Status |
+| --- | --- | --- | --- | --- |
+| LIVE-01 | Configure streaming; open Live Data; inspect every available sensor card; scroll while values change. | One; UI | Correct device/sensor labels, units, and fresh values/plots appear; no layout overflow or stalled navigation. | Partial, verified on Pixel 9a / Android 17 (API 37), twice on 2026-09-29 and again on 2026-10-15: the phone Accelerometer card appeared after applying 5 Hz and produced a non-empty CSV in [`this_device_recording_test.dart`](../../patrol_test/this_device_recording_test.dart); detailed plot/unit assertions and other sensors/devices remain planned; [current run record](runs/2026-10-15-pixel-9a-upstream-main-regression.md). |
+| LIVE-02 | Tap each sensor card; inspect detail/chart; return. | One streaming; UI | Correct sensor detail opens; current values/channel names are visible; Back returns to Live Data. | Planned |
+| LIVE-03 | Open channel settings; switch Show channel off/on for individual axes. | One with multichannel sensor streaming; UI | Only the chosen channel visibility changes; selected states remain consistent when reopening the sheet. | Planned |
+| LIVE-04 | Enable/disable low-pass and high-pass filters; edit cutoff/order; apply to all; Reset. | One streaming; UI | Controls retain valid values, channel filter indicators reflect selections, and reset clears the intended settings. Signal-processing correctness is covered separately. | Planned |
+| LIVE-05 | Enable notch; edit Center, Width, Notch order; Apply to all; Reset; try blank/out-of-range fields. | One streaming; UI | Fields normalize/reject invalid input without a crash; the applied filter controls remain coherent. | Planned |
+| LIVE-06 | Turn on Disable live data graphs; visit card/detail; tap disabled overlay; re-enable. | One streaming; UI | Disabled overlay leads to General settings; charts resume after re-enable; recording state is unaffected. | Planned |
+| LIVE-07 | Toggle Hide live data graphs without data before and after starting a stream. | One; UI | Empty graphs hide/show as configured; data-bearing graphs appear once samples arrive. | Planned |
+| LIVE-08 | Use a phone/system microphone input; inspect audio chart and any available source/channel controls; switch source/Off. | Microphone permission + relevant inputs; UI | Waveform/source labels correspond to selection; missing input/Off does not display a fabricated active stream. | Planned |
+| LIVE-09 | View simultaneous streams from both devices; disconnect one; reconnect. | Pair/two devices; UI | Correct per-device data/cards remain; surviving device keeps updating; restored device does not create duplicate cards. | Partial, verified on Pixel 9a / Android 17 (API 37), 2026-09-30: simultaneous L/R accelerometer streams produced independent non-empty files at 25/50/100 Hz. Disconnect/reconnect during streaming remains planned; [run record](runs/2026-09-30-pixel-9a-pair-sample-rates.md). |
+| RATE-01 | On a combined pair, select one or more exact 9-Axis IMU rates; apply; record a stable window; inspect L/R accelerometer CSV timestamps. | Pair + matching streamable IMU rates; UI + exported-data assertion | Each side has numeric strictly increasing timestamps, sufficient duration/sample count, and a received rate within the configured tolerance of the requested rate. | Verified on Pixel 9a / Android 17 (API 37), 2026-10-15 against current main, with two OpenEarable-2B01 devices: requested 25/50/100 Hz yielded 24.99/49.95/99.90 Hz on both sides. An earlier attempt exposed and led to handling of the firmware-update dialog; the successful run followed a device wake/power cycle. This test checks CSV delivery, not live-graph expected/actual labels; [current run record](runs/2026-10-15-pixel-9a-upstream-main-regression.md). |
+| RATE-02 | Enable Show sampling rates; stream one sensor and then a combined pair at known rates; inspect the label on each live graph. | One/Pair with a streamable rate; UI + received-data assertion | The graph shows the configured expected rate and a changing actual rate derived from live samples; displayed actual rate is within the chosen tolerance. | Planned: the General settings switch is included in `general_settings_test.dart`; the live graph labels are not yet asserted. |
+| DATA-01 | Stream known sensor inputs on devices/firmware that use each supported wire format; inspect exported axis values and units. | Known sensor fixture or captured protocol payloads; unit/integration test plus hardware smoke run | Firmware-version detection selects the correct decoder and values match the reference; unsupported/malformed payloads fail clearly. Patrol currently checks timestamps/sample counts, not decoded measurement values. | Planned outside Patrol for deterministic payload fixtures; add a real-device smoke journey for live values and supported firmware variants. |
+
+## Local recording, files, and labels
+
+Sources: [active recorder page](../../lib/widgets/sensors/local_recorder/local_recorder_view.dart), [recording card](../../lib/widgets/sensors/local_recorder/local_recorder_recording_card.dart), [recording history](../../lib/widgets/sensors/local_recorder/local_recorder_all_recordings_page.dart), [labels](../../lib/widgets/sensors/local_recorder/labels/).
+
+The current Android recorder creates a timestamped directory automatically through `pickRecordingDirectory()`; the old standalone `RecordingControls` widget is not the active recorder screen. Do not automate an Android directory picker that the current journey does not show. Opening files and sharing can hand off to native apps; assert the handoff and cancel the chooser by default rather than sending files to a real recipient.
+
+| ID | User actions | Prerequisites / mode | Expected user-visible outcome | Status |
+| --- | --- | --- | --- | --- |
+| REC-01 | Open Recorder without sensors and inspect the empty history. | None; clean recording fixture; UI | Start Recording is unavailable with a clear reason; the empty-history state is usable. The See all recordings action is intentionally hidden until more than one recording exists. | Verified on Pixel 9a / Android 17 (API 37), 2026-09-29 through the no-device Recorder destination in [`overview_shortcuts_test.dart`](../../patrol_test/overview_shortcuts_test.dart); [run record](runs/2026-09-29-pixel-9a-overview-shortcuts.md). |
+| REC-02 | Configure sensor streaming; Start Recording; wait for elapsed time; Stop Recording; expand latest folder. | One; UI | Recording state and elapsed time advance; stop completes; new recording and expected file rows/sizes are visible. | Verified for the phone Accelerometer on 2026-09-29 and for paired OpenEarable L/R accelerometers at 25/50/100 Hz on 2026-09-30. Other sensors, on-device SD recording, filename-prefix behavior, and broader multi-sensor combinations remain planned; [phone run](runs/2026-09-29-pixel-9a-phone-sensor-recording.md), [pair-rate run](runs/2026-09-30-pixel-9a-pair-sample-rates.md). |
+| REC-03 | Start Recording; navigate among main tabs and back; tap recording activity indicator where available; stop. | One; UI | Session and elapsed time remain consistent; indicator returns to Recorder; no accidental second session. | Planned |
+| REC-04 | Run stop with the turn-off-sensors option both disabled and enabled; visit Configure afterward. | One; UI | Stop behavior follows the option and UI reflects remaining active sensors or Off. | Planned |
+| REC-05 | Make several recordings; pull to refresh; See all recordings; expand/collapse folders. | One + test-created recordings; UI | Latest and full history agree; file counts, names, sizes and ordering are useful and stable. | Planned |
+| REC-06 | Tap a recorded file; return from the offered viewer/native chooser. | Test-created file + installed compatible viewer where required; UI | The selected file is handed off/opened or an actionable failure appears; returning preserves history. | Planned |
+| REC-07 | Share file; cancel native share sheet; Share folder; cancel; batch-select/share and cancel. | Test recordings + native share support; UI | Correct selected file/folder set reaches chooser; cancellation preserves data and exits busy state. | Planned |
+| REC-08 | Delete folder from Recorder; Cancel then confirm; repeat single/batch deletion in history. | Test-created recordings only; UI | Cancel preserves data; confirmation removes only selected recordings and updates counts/empty states. | Partial, verified twice on Pixel 9a / Android 17 (API 37), 2026-09-29: confirmed deletion removed the test-created phone-sensor recording and restored the empty state in [`this_device_recording_test.dart`](../../patrol_test/this_device_recording_test.dart); Cancel and history/batch variants remain planned; [run record](runs/2026-09-29-pixel-9a-phone-sensor-recording.md). |
+| REC-09 | Open history while recording; try available selection/share/delete actions for current recording. | One recording; UI | Current recording protections remain clear; history cannot silently invalidate the active session. Treat unexpected allowed deletion as a defect. | Planned |
+| REC-10 | Rapidly tap Start/Stop; leave/re-enter; start a fresh recording. | One; UI | No duplicate session, stuck button, invalid elapsed timer, or lost stop action. | Planned |
+| REC-11 | Select microphone recording input; record, change microphone configuration, stop, inspect files. | Compatible audio input + permission; optional One with LE Audio; UI | Recording/source/channel UI stays coherent; resulting audio file rows are present. Audibility/quality is a separate observation. | Planned |
+| LAB-01 | Open Manage label groups; Create; enter Group name; Add labels, names, and colors; Save; reopen. | None; UI | Saved group/labels/colors appear and persist; no unlabeled duplicate editor state. | Planned |
+| LAB-02 | Edit existing group name and labels; delete a label, Cancel/confirm; leave and reopen the editor. | Test label group; UI | Edits persist through the existing-group autosave flow; correct items change; cancellation leaves intended data intact. | Planned |
+| LAB-03 | Enter blank/duplicate names and incomplete groups; attempt Save; leave with unsaved edits; choose Stay/Leave. | None; UI | Validation and leave confirmation prevent silent unintended loss; no crash with invalid input. | Planned |
+| LAB-04 | Delete a test label group; Cancel then confirm; inspect selector. | Test label group; UI | Group remains on Cancel, disappears on Delete; selected-group state handles deletion. | Planned |
+| LAB-05 | Select label group in Recorder; Start Recording; tap different labels and No Label; stop. | One + test label group; UI | Current Segment changes with selection; label controls have correct enabled/disabled state; session completes. Exported segment timing can be checked as supporting data evidence. | Planned |
+| LAB-06 | Choose No Labels and record; compare with a selected group; relaunch. | One; UI | Label controls and saved selection match the chosen mode; no stale active label leaks into a new session. | Planned |
+
+## Built-in apps
+
+Sources: [app catalog and capability checks](../../lib/apps/widgets/apps_page.dart), [earable picker](../../lib/apps/widgets/select_earable_view.dart), [posture](../../lib/apps/posture_tracker/view/), [heart](../../lib/apps/heart_tracker/widgets/heart_tracker_page.dart), [seal check](../../lib/apps/seal_check/audio_response_measurement_view.dart).
+
+| ID | User actions | Prerequisites / mode | Expected user-visible outcome | Status |
+| --- | --- | --- | --- | --- |
+| APP-01 | Open Apps with no devices, compatible device, and incompatible capability set; inspect/tap every tile. | None then capability-varied devices; UI | Posture Tracker, Heart Tracker, Seal Check have correct enabled/disabled state and explanatory compatibility information. | Planned |
+| APP-02 | Launch each enabled app; choose intended device; back out before selection; repeat with multiple candidates. | One/two compatible devices; UI | Picker includes eligible devices, identifies the selected target, and Cancel/Back returns cleanly. | Planned |
+| POST-01 | Open Posture Tracker; Start Tracking; inspect Roll/Pitch and status; stop/restart; leave. | One OpenEarable + SensorManager; UI | Ready/tracking/stopped states and controls agree; stopping/leaving releases its sensor stream and does not leave stale readings. | Planned |
+| POST-02 | Open posture settings; enable/disable Bad Posture Reminder; edit all four angle/time thresholds; return. | One compatible; UI | Conditional fields and displayed thresholds update; numeric input edge cases do not crash the app. | Planned |
+| POST-03 | Start tracking; Calibrate (Optional) / Calibrate as Main Posture; move between neutral and tilted poses. | One worn or in motion fixture; UI + fixture/manual | Calibration returns to tracking; angle/status views respond; reminder behavior can be observed for known poses. | Planned |
+| POST-04 | Disconnect during tracking; restore/reconnect the selected wearable. | One with controlled availability; UI + fixture/manual | Unavailable state is understandable; posture tracking resumes for the selected device without duplicate/stale streams. | Planned |
+| HEART-01 | Open Heart Tracker on a PPG-capable device; inspect heart metrics, filtered PPG, and quality states; leave/reopen. | One + PPG, optional accelerometer/optical temperature; UI + fixture/manual for usable contact | Correct charts/metrics or honest waiting/quality feedback appears; no claim of valid heart rate from absent/poor signal. Accuracy is a separate assessment. | Planned |
+| HEART-02 | Launch on a catalog-compatible sensor device lacking PPG. | Compatible family/SensorManager but no PPG; UI | No PPG sensor message is shown; Back remains usable. | Planned |
+| HEART-03 | Lose sensor contact and/or disconnect while viewing; restore/reconnect; leave app. | PPG device; UI + fixture/manual | Quality/no-data states and recovery are clear; Heart Tracker resumes after reconnect and navigation/subsequent sensor configuration remain usable. | Planned |
+| SEAL-01 | Open Seal Check; inspect initial Save JSON disabled state; tap Measure; wait for progress/result. | One + AudioResponseManager; UI + fixture/manual for controlled fit/audio environment | Measuring state/progress appears; Measure cannot overlap; result/quality view or actionable error replaces progress. | Planned |
+| SEAL-02 | After measurement inspect graph/data table and available side tabs; Measure again. | One; run both sides separately or Pair where offered; UI | Results belong to selected side(s); fresh result replaces old data; navigation/scrolling works. | Planned |
+| SEAL-03 | Save JSON; complete/cancel offered native save UI and observe message. | Completed measurement; UI | Correct saved/cancelled result is reported; existing measurement remains visible. | Planned |
+| SEAL-04 | Disconnect during measurement; observe error; Try again after reconnect; leave mid-measurement. | One with controlled availability; UI + fixture/manual | Errors/retry are actionable; leaving does not trap navigation or leave app controls unusable. | Planned |
+
+## Settings, connectors, logs, and about
+
+Sources: [settings pages](../../lib/widgets/settings/), [logging pages](../../lib/widgets/logging/), [connector indicator](../../lib/widgets/connector_activity_indicator.dart).
+
+| ID | User actions | Prerequisites / mode | Expected user-visible outcome | Status |
+| --- | --- | --- | --- | --- |
+| SET-01 | Open General settings; toggle every switch individually; leave/reopen; relaunch. | None; UI | Auto-connect, Keep screen awake, Disable all sensors on app close, Disable live data graphs, Hide live data graphs without data, and Show sampling rates persist correctly. | Partial, verified on Pixel 9a / Android 17 (API 37), 2026-10-15: all six switches changed, remained changed after reopening, and were restored; process relaunch remains planned; [current run record](runs/2026-10-15-pixel-9a-upstream-main-regression.md). |
+| SET-02 | Enable/disable Bluetooth auto-connect; disconnect/relaunch with remembered target in range. | One remembered; UI | Reconnection behavior follows preference; manual connection remains available. | Planned |
+| SET-03 | Toggle Keep screen awake; leave app idle foreground across phone screen-timeout interval. | None; controlled phone timeout; UI + fixture/manual | Foreground screen behavior follows setting; background phone behavior remains normal. | Planned |
+| SET-04 | Open Network Connector settings; edit enabled, Port, Path; Save & Apply; leave/reopen/relaunch. | None; local network; UI | Dirty/save state, endpoint, runtime status, and persisted settings agree. | Planned |
+| SET-05 | Enter empty/non-numeric/out-of-range port and invalid path; Save & Apply; correct input; Reset to Defaults. | None; UI | Validation is actionable; invalid settings are not silently reported running; reset/save restore defaults. | Planned |
+| SET-06 | Refresh IP address; change network/no network; open View documentation and return. | Controlled network + browser; UI | IP/unavailable status updates; documentation handoff returns cleanly. | Planned |
+| SET-07 | Enable connector; tap connector activity indicator from several main tabs; disable connector; repeat without a reachable network address. | None; controlled network; UI | Indicator opens connector settings; active/network-unavailable appearance follows runtime; disable removes indicator. | Planned |
+| LOG-01 | Open Log files; refresh as offered; open a log; scroll/select text; Back. | Existing app log; UI | Filename/metadata and readable contents display; return preserves list. | Planned |
+| LOG-02 | Share a log and cancel native share sheet; delete test log Cancel/confirm; Clear all Cancel/confirm. | Disposable log fixture; UI | Correct chooser and confirmations appear; list/empty state updates without deleting on Cancel. | Planned |
+| LOG-03 | Open an empty log or a file unavailable by the time it is read. | Controlled log fixture; UI + fixture | Empty/error view is understandable; no infinite loader or navigation trap. | Planned |
+| ABOUT-01 | Open About; inspect name/version; open source, TECO, OpenWearables links; return from browser. | None; browser/network; UI | Correct information and destination handoffs; returning keeps app usable. | Planned |
+| ABOUT-02 | Open Open source licenses; expand/open several package entries; scroll; Back. | None; UI | Package names and license text load correctly; no stuck loading state or broken return navigation. | Planned |
+
+## Firmware update and recovery UI
+
+Sources: [FOTA pages](../../lib/widgets/fota/). These scenarios test the app workflow. Actual installation and erase require a dedicated maintenance fixture; cancellation/checklist/catalog browsing can be tested without flashing. Do not automatically force a low-battery update merely to cover a button.
+
+| ID | User actions | Prerequisites / mode | Expected user-visible outcome | Status |
+| --- | --- | --- | --- | --- |
+| FOTA-01 | Open Firmware Update from Device details; read instructions; toggle checklist entries; Back. | One + FotaManager; UI | Intended target is selected; checklist gates progression; Back returns without installing. | Planned |
+| FOTA-02 | Open warning with normal/unknown/low battery states; inspect dialogs and Cancel paths; open recovery link. | Battery-state fixtures; UI + fixture/manual | Appropriate battery gates and recovery handoff appear; cancellation prevents update start. | Planned |
+| FOTA-03 | Complete checklist; open firmware selector; scroll releases; inspect Current/Latest/Beta; select/cancel. | One + FOTA; network; UI | Selected firmware details and Start Update availability agree with the chosen item. | Planned |
+| FOTA-04 | Select current, older, or beta release; inspect each confirmation and Cancel. | Matching catalog/version fixtures; UI | Correct branch-specific warning appears; Cancel leaves selection/update state coherent. | Planned |
+| FOTA-05 | Choose custom firmware; Cancel/Continue warning; cancel file picker; repeat with lab-approved file. | One + FOTA; approved test package; UI | Native picker and selected-file details are correct; cancellation does not start install; invalid package errors are usable. | Planned |
+| FOTA-06 | Load release list without network; Reload after restoration. | Controlled network; UI | Error/reload state appears; valid list replaces it after network recovery. | Planned |
+| FOTA-07 | Start an approved update; observe steps/progress; try Back; complete/reconnect; inspect verification banner/details. | Dedicated recoverable One + approved firmware; UI + fixture/manual | App prevents inappropriate navigation, reports progress/outcome, and displays verified target/version after reconnect. | Planned |
+| FOTA-08 | During update open Abort Update confirmation; Keep Updating; separately test abort/error/retry with recovery fixture. | Dedicated recoverable One; UI + fixture/manual | Confirmation and final aborted/error states are clear; no false success; recovery flow remains reachable. | Planned |
+| FOTA-09 | Open Show Log when available; scroll log messages; return. | Update run with logger; UI | Logs render with severity colors; loading/read errors are handled; returning does not lose progress/outcome. | Planned |
+| FOTA-10 | Open Image Slots; refresh; inspect slot metadata/status; use Retry on read failure; open mcumgr web link. | One + FotaSlotInfoCapability; UI | Slot data, empty/error states, retry, and external recovery navigation work. | Planned |
+| FOTA-11 | Inspect protected slot actions; for eligible inactive secondary slot open Erase slot and Cancel; separately confirm erase. | Dedicated recoverable One + eligible slot; UI + fixture/manual | Protected slots cannot be erased; Cancel changes nothing; deliberate erase shows result and refreshed slot state. | Planned |
+| FOTA-12 | Trigger controlled stuck-update condition; Ignore or Open Image Slots; inspect post-update verification timeout/failure. | Recovery fixture; UI + fixture/manual | Recovery/verification messages are actionable and do not present unverified completion as success. | Planned |
+
+## Cross-feature and phone lifecycle regression
+
+These cases add realistic sequences that individual screen tests miss. Execute them against the relevant journeys above instead of replacing their feature assertions.
+
+| ID | User actions | Prerequisites / mode | Expected user-visible outcome | Status |
+| --- | --- | --- | --- | --- |
+| LIFE-01 | While connected/streaming, press Home; return before and after 10 seconds with Disable all sensors on app close both enabled and disabled. | One; UI | Sensor UI on resume agrees with the selected lifecycle policy and elapsed interval; connection state is honest. | Planned |
+| LIFE-02 | Background/foreground while recording; lock/unlock; return and Stop Recording. Repeat for phone microphone capture while music is playing where supported. | One; phone lock configured for lab; UI | Session state, elapsed time, stop control and resulting recording remain coherent; verify Android earable streams resume and microphone capture stays active; document actual OS interruption behavior. | Planned |
+| LIFE-03 | Navigate to system settings; revoke permission while app is backgrounded; return to scan/audio screen; grant again. | One for BLE variant; UI | App handles permission changes without crash and offers recovery. | Planned |
+| LIFE-04 | Power off/move earable out of range while in device details, Configure, Live Data, Recorder, and each mini-app; return device. | One; UI + fixture/manual | Each active screen has a usable disconnected/error state; reconnection does not duplicate cards or restore stale success. | Planned |
+| LIFE-05 | Rotate where supported, change system font size/display scale, open keyboard, and scroll long sheets/forms. | None; repeat One; UI | Text and actions remain reachable; no clipped confirmation buttons, overflow, or lost input. | Planned |
+| LIFE-06 | Repeatedly open/close sensor details and mini-apps; switch tabs during streaming and recording. | One; UI | No accumulating duplicate updates, stale overlays, obvious UI stalls, or unintended recording stops. | Planned |
+| LIFE-07 | Relaunch after a normal close and after OS process termination during an idle/recording session. | One + disposable session; UI + fixture | Startup recovers without an endless loader; preserved recordings remain discoverable; terminated session is not falsely shown as still recording. | Planned |
+| LIFE-08 | With pair streaming, change listening/microphone controls, record labelled segments, visit mini-app, return and stop. | Pair with applicable capabilities; UI | Cross-feature state remains coherent; changes/cleanup from one feature do not silently invalidate the next workflow. | Planned |
+
+## Capability and environment expansion checklist
+
+Before claiming full coverage, collect the actual capabilities of the lab devices and expand the cases above for:
+
+- Every exposed sensor/configuration, sampling-rate option, target option, profile type, and chart channel.
+- Single earable, both stereo positions, combined/split pair, partial pair loss, and multiple independent devices.
+- Listening modes, microphone source/gain controls, power modes, RGB/status LED combinations, battery metadata, edge recording, FOTA and image-slot capability presence/absence.
+- Phone microphone and LE Audio inputs that are actually supported by the selected phone/OS/device combination.
+- Fresh install, existing data, upgrade, granted/denied/permanently-denied permissions, Bluetooth disabled, no network, background/lock/resume, and process restart.
+- Small-screen/large-text layouts and Android native permission/share/file/browser surfaces; corresponding iPhone surfaces later.
+- Explicitly unavailable product capabilities (for example PPG on a particular device revision): keep the relevant feature untested/not applicable for that fixture rather than counting a disabled tile as its full functional coverage.
+
+Source files may contain unused widgets or platform-specific branches. Add a phone journey only after confirming a real navigation path; retain a separate note for unreachable/dead UI if discovered. Physical sound quality, optical output, sensor measurement accuracy, and firmware algorithm correctness require separate checks and are not implied by a green UI test.
diff --git a/open_wearable/lib/main.dart b/open_wearable/lib/main.dart
index 195fcc45b..55f75f414 100644
--- a/open_wearable/lib/main.dart
+++ b/open_wearable/lib/main.dart
@@ -43,77 +43,84 @@ import 'view_models/wearables_provider.dart';
 
 const bool _isAppStorePreview = bool.fromEnvironment('APP_STORE_PREVIEW');
 
-void main() async {
+Future<void> main() async {
   WidgetsFlutterBinding.ensureInitialized();
+  runApp(await createApp());
+}
+
+/// Initializes the app's production services and returns its root widget.
+///
+/// The caller must initialize Flutter's binding first. Keeping initialization
+/// separate from [runApp] lets on-device UI tests await the same startup before
+/// mounting the app with their test binding. Create once per app process; the
+/// router and device services retain process-wide state.
+Future<Widget> createApp() async {
   LogFileManager logFileManager = await LogFileManager.create();
   final wearableConnector = WearableConnector();
   initOpenWearableLogger(logFileManager.libLogger);
   initLogger(logFileManager.logger);
 
   if (_isAppStorePreview) {
-    runApp(AppStorePreviewApp(logFileManager: logFileManager));
-    return;
+    return AppStorePreviewApp(logFileManager: logFileManager);
   }
 
   await AutoConnectPreferences.initialize();
   await AppShutdownSettings.initialize();
   await ConnectorSettings.initialize(wearableConnector: wearableConnector);
 
-  runApp(
-    MultiProvider(
-      providers: [
-        ChangeNotifierProvider(create: (context) => WearablesProvider()),
-        ChangeNotifierProvider(
-          create: (context) => FirmwareUpdateRequestProvider(),
-        ),
-        ChangeNotifierProvider(
-          create: (context) => LabelGroupProvider(),
-        ),
-        ChangeNotifierProxyProvider<LabelGroupProvider, LabelProvider>(
-          create: (context) => LabelProvider(null),
-          update: (context, labelGroupProvider, labelProvider) {
-            labelProvider?.setLabelGroup(labelGroupProvider.selectedLabelGroup);
-            return labelProvider!;
-          },
-        ),
-        ChangeNotifierProxyProvider2<WearablesProvider, LabelGroupProvider,
-            SensorRecorderProvider>(
-          create: (context) => SensorRecorderProvider(),
-          update: (
-            context,
-            wearablesProvider,
-            labelGroupProvider,
-            recorderProvider,
-          ) {
-            final provider = recorderProvider ?? SensorRecorderProvider();
-            final labelGroup = labelGroupProvider.selectedLabelGroup;
-            final wearables = [...wearablesProvider.wearables];
-            if (labelGroup != null) {
-              final labelProvider = context.read<LabelProvider>();
-              wearables.add(
-                LabelWearable(
-                  labelGroup: labelGroup,
-                  labelStream: labelProvider.activeLabelStream,
-                ),
-              );
-            }
-            logger.t(
-              'Updating SensorRecorderProvider with label group: $labelGroup',
-            );
-            provider.synchronizeConnectedWearables(
-              wearables,
+  return MultiProvider(
+    providers: [
+      ChangeNotifierProvider(create: (context) => WearablesProvider()),
+      ChangeNotifierProvider(
+        create: (context) => FirmwareUpdateRequestProvider(),
+      ),
+      ChangeNotifierProvider(
+        create: (context) => LabelGroupProvider(),
+      ),
+      ChangeNotifierProxyProvider<LabelGroupProvider, LabelProvider>(
+        create: (context) => LabelProvider(null),
+        update: (context, labelGroupProvider, labelProvider) {
+          labelProvider?.setLabelGroup(labelGroupProvider.selectedLabelGroup);
+          return labelProvider!;
+        },
+      ),
+      ChangeNotifierProxyProvider2<WearablesProvider, LabelGroupProvider,
+          SensorRecorderProvider>(
+        create: (context) => SensorRecorderProvider(),
+        update: (
+          context,
+          wearablesProvider,
+          labelGroupProvider,
+          recorderProvider,
+        ) {
+          final provider = recorderProvider ?? SensorRecorderProvider();
+          final labelGroup = labelGroupProvider.selectedLabelGroup;
+          final wearables = [...wearablesProvider.wearables];
+          if (labelGroup != null) {
+            final labelProvider = context.read<LabelProvider>();
+            wearables.add(
+              LabelWearable(
+                labelGroup: labelGroup,
+                labelStream: labelProvider.activeLabelStream,
+              ),
             );
-            return provider;
-          },
-        ),
-        Provider.value(value: wearableConnector),
-        ChangeNotifierProvider(
-          create: (context) => AppBannerController(),
-        ),
-        ChangeNotifierProvider.value(value: logFileManager),
-      ],
-      child: const MyApp(),
-    ),
+          }
+          logger.t(
+            'Updating SensorRecorderProvider with label group: $labelGroup',
+          );
+          provider.synchronizeConnectedWearables(
+            wearables,
+          );
+          return provider;
+        },
+      ),
+      Provider.value(value: wearableConnector),
+      ChangeNotifierProvider(
+        create: (context) => AppBannerController(),
+      ),
+      ChangeNotifierProvider.value(value: logFileManager),
+    ],
+    child: const MyApp(),
   );
 }
 
@@ -216,7 +223,10 @@ class _MyAppState extends State<MyApp> with WidgetsBindingObserver {
               actions: [
                 PlatformDialogAction(
                   cupertino: (_, __) => CupertinoDialogActionData(),
-                  child: const Text('Later'),
+                  child: const Text(
+                    'Later',
+                    key: ValueKey<String>('ui.firmwareUpdate.later'),
+                  ),
                   onPressed: () => rootNavigatorKey.currentState?.pop(),
                 ),
                 PlatformDialogAction(
diff --git a/open_wearable/lib/models/bluetooth_auto_connector.dart b/open_wearable/lib/models/bluetooth_auto_connector.dart
index b3291ff20..0f521fafc 100644
--- a/open_wearable/lib/models/bluetooth_auto_connector.dart
+++ b/open_wearable/lib/models/bluetooth_auto_connector.dart
@@ -496,6 +496,7 @@ class BluetoothAutoConnector {
           ),
           actions: [
             PlatformDialogAction(
+              key: const ValueKey('ui.permissions.required.cancel'),
               onPressed: nav.pop,
               child: PlatformText("Cancel"),
             ),
diff --git a/open_wearable/lib/widgets/common/no_devices_prompt.dart b/open_wearable/lib/widgets/common/no_devices_prompt.dart
index dff97e412..bcab7ef07 100644
--- a/open_wearable/lib/widgets/common/no_devices_prompt.dart
+++ b/open_wearable/lib/widgets/common/no_devices_prompt.dart
@@ -2,12 +2,14 @@ import 'package:flutter/material.dart';
 
 class NoDevicesPrompt extends StatelessWidget {
   final VoidCallback onScanPressed;
+  final Key? scanButtonKey;
   final String title;
   final String subtitle;
 
   const NoDevicesPrompt({
     super.key,
     required this.onScanPressed,
+    this.scanButtonKey,
     this.title = 'No devices connected',
     this.subtitle = 'Scan for devices to start streaming and recording data.',
   });
@@ -60,6 +62,7 @@ class NoDevicesPrompt extends StatelessWidget {
           ),
           const SizedBox(height: 14),
           FilledButton.icon(
+            key: scanButtonKey,
             onPressed: onScanPressed,
             icon: const Icon(Icons.search_rounded, size: 18),
             label: const Text('Scan for devices'),
diff --git a/open_wearable/lib/widgets/devices/connect_devices_page.dart b/open_wearable/lib/widgets/devices/connect_devices_page.dart
index 043ad3e52..557dff336 100644
--- a/open_wearable/lib/widgets/devices/connect_devices_page.dart
+++ b/open_wearable/lib/widgets/devices/connect_devices_page.dart
@@ -154,6 +154,7 @@ class _ConnectDevicesPageState extends State<ConnectDevicesPage> {
         trailingActions: [
           const AppBarRecordingIndicator(),
           PlatformIconButton(
+            key: const ValueKey('ui.scan.start'),
             icon: _scanSnapshot.isScanning
                 ? const SizedBox(
                     width: 18,
@@ -195,6 +196,7 @@ class _ConnectDevicesPageState extends State<ConnectDevicesPage> {
                     'Allow Bluetooth and Location so the app can find and connect to your wearable.',
                   ),
                   trailing: PlatformElevatedButton(
+                    key: const ValueKey('ui.scan.enableBluetooth'),
                     onPressed: _requestBlePermissions,
                     child: const Text('Enable'),
                   ),
@@ -215,6 +217,7 @@ class _ConnectDevicesPageState extends State<ConnectDevicesPage> {
                     'OpenWearables can record audio from the device microphone for synchronized audio data. Grant microphone access to enable this.',
                   ),
                   trailing: PlatformElevatedButton(
+                    key: const ValueKey('ui.scan.enableMicrophone'),
                     onPressed: _requestMicPermission,
                     child: const Text('Enable'),
                   ),
@@ -276,6 +279,9 @@ class _ConnectDevicesPageState extends State<ConnectDevicesPage> {
                 return Card(
                   margin: const EdgeInsets.only(bottom: 8),
                   child: PlatformListTile(
+                    key: isThisDevice
+                        ? const ValueKey('ui.scan.thisDevice')
+                        : ValueKey('ui.scan.device.${device.id}'),
                     leading: Icon(
                       isThisDevice ? Icons.smartphone : Icons.bluetooth,
                     ),
@@ -291,6 +297,7 @@ class _ConnectDevicesPageState extends State<ConnectDevicesPage> {
               }),
             const SizedBox(height: 10),
             PlatformElevatedButton(
+              key: const ValueKey('ui.scan.again'),
               onPressed: _scanSnapshot.isScanning
                   ? null
                   : () => _startScanningIfAllowed(clearPrevious: true),
@@ -463,6 +470,7 @@ class _ConnectDevicesPageState extends State<ConnectDevicesPage> {
         Transform.scale(
           scale: 0.75,
           child: Switch.adaptive(
+            key: const ValueKey('ui.scan.openEarableFilter'),
             value: _showOnlyOpenEarableDevices,
             onChanged: (value) {
               setState(() {
@@ -530,6 +538,7 @@ class _ConnectDevicesPageState extends State<ConnectDevicesPage> {
                 ),
               )
             : PlatformTextButton(
+                key: ValueKey('ui.scan.connect.${device.id}'),
                 onPressed: onConnect,
                 child: const Text('Connect'),
               ),
diff --git a/open_wearable/lib/widgets/devices/device_detail/device_detail_page.dart b/open_wearable/lib/widgets/devices/device_detail/device_detail_page.dart
index 70c93c08b..c013fbeeb 100644
--- a/open_wearable/lib/widgets/devices/device_detail/device_detail_page.dart
+++ b/open_wearable/lib/widgets/devices/device_detail/device_detail_page.dart
@@ -307,6 +307,7 @@ class _DeviceDetailPageState extends State<DeviceDetailPage> {
     ];
 
     return PlatformScaffold(
+      key: ValueKey('ui.device.details.${widget.device.deviceId}'),
       appBar: PlatformAppBar(
         title: const Text('Device details'),
       ),
@@ -408,6 +409,11 @@ class _DeviceDetailPageState extends State<DeviceDetailPage> {
               children: [
                 Expanded(
                   child: OutlinedButton.icon(
+                    key: ValueKey(
+                      _canForgetDevice
+                          ? 'ui.device.forgetSystem'
+                          : 'ui.device.disconnect',
+                    ),
                     onPressed: _canForgetDevice
                         ? _showForgetDialog
                         : _disconnectDevice,
diff --git a/open_wearable/lib/widgets/devices/devices_page.dart b/open_wearable/lib/widgets/devices/devices_page.dart
index c340ef27f..b1fb5ed9c 100644
--- a/open_wearable/lib/widgets/devices/devices_page.dart
+++ b/open_wearable/lib/widgets/devices/devices_page.dart
@@ -5,6 +5,7 @@ import 'package:go_router/go_router.dart';
 import 'package:open_earable_flutter/open_earable_flutter.dart';
 import 'package:open_wearable/models/wearable_connector.dart';
 import 'package:open_wearable/models/wearable_display_group.dart';
+import 'package:open_wearable/models/this_device_wearable.dart';
 import 'package:open_wearable/view_models/wearables_provider.dart';
 import 'package:open_wearable/widgets/common/no_devices_prompt.dart';
 import 'package:open_wearable/widgets/connector_activity_indicator.dart';
@@ -67,6 +68,7 @@ class _DevicesPageState extends State<DevicesPage> {
           const AppBarRecordingIndicator(),
           const ConnectorActivityIndicator(),
           PlatformIconButton(
+            key: const ValueKey('ui.devices.connect'),
             icon: Icon(context.platformIcons.bluetooth),
             onPressed: () {
               context.push('/connect-devices');
@@ -280,6 +282,13 @@ class DeviceRow extends StatelessWidget {
     );
 
     return GestureDetector(
+      key: ValueKey(
+        primary is ThisDeviceWearable
+            ? 'ui.devices.thisDevice'
+            : group.isCombined
+                ? 'ui.devices.pair.$pairKey'
+                : 'ui.devices.device.${primary.deviceId}',
+      ),
       onTap: () => _openDetails(context),
       child: Card(
         margin: cardMargin,
@@ -514,6 +523,11 @@ class DeviceRow extends StatelessWidget {
               ),
             ),
             Switch.adaptive(
+              key: ValueKey(
+                group.isCombined
+                    ? 'ui.devices.pair.combine.$pairKey'
+                    : 'ui.devices.pair.combine.$pairKey.${group.primary.deviceId}',
+              ),
               materialTapTargetSize: MaterialTapTargetSize.shrinkWrap,
               value: combined,
               onChanged: enabled
diff --git a/open_wearable/lib/widgets/home_page.dart b/open_wearable/lib/widgets/home_page.dart
index 30c198bb0..2c32ad8a7 100644
--- a/open_wearable/lib/widgets/home_page.dart
+++ b/open_wearable/lib/widgets/home_page.dart
@@ -135,8 +135,14 @@ class _HomePageState extends State<HomePage> {
       items: _destinations
           .map(
             (destination) => BottomNavigationBarItem(
-              icon: Icon(destination.icon),
-              activeIcon: Icon(destination.selectedIcon),
+              icon: Icon(
+                destination.icon,
+                key: ValueKey('ui.nav.${destination.title.toLowerCase()}'),
+              ),
+              activeIcon: Icon(
+                destination.selectedIcon,
+                key: ValueKey('ui.nav.${destination.title.toLowerCase()}'),
+              ),
               label: destination.title,
             ),
           )
@@ -167,8 +173,18 @@ class _HomePageState extends State<HomePage> {
               destinations: _destinations
                   .map(
                     (destination) => NavigationRailDestination(
-                      icon: Icon(destination.icon),
-                      selectedIcon: Icon(destination.selectedIcon),
+                      icon: Icon(
+                        destination.icon,
+                        key: ValueKey(
+                          'ui.nav.${destination.title.toLowerCase()}',
+                        ),
+                      ),
+                      selectedIcon: Icon(
+                        destination.selectedIcon,
+                        key: ValueKey(
+                          'ui.nav.${destination.title.toLowerCase()}',
+                        ),
+                      ),
                       label: Text(destination.title),
                     ),
                   )
diff --git a/open_wearable/lib/widgets/home_page_overview.dart b/open_wearable/lib/widgets/home_page_overview.dart
index bae65049d..1b0b19fe3 100644
--- a/open_wearable/lib/widgets/home_page_overview.dart
+++ b/open_wearable/lib/widgets/home_page_overview.dart
@@ -131,6 +131,7 @@ class _OverviewWorkflowIntroCard extends StatelessWidget {
             ),
             const SizedBox(height: 12),
             _OverviewWorkflowStep(
+              actionKey: const ValueKey('ui.overview.connectDevices'),
               icon: Icons.bluetooth_connected,
               title: 'Connect devices',
               detail: 'Pair wearables and confirm connection.',
@@ -139,6 +140,7 @@ class _OverviewWorkflowIntroCard extends StatelessWidget {
               onTap: onConnectRequested,
             ),
             _OverviewWorkflowStep(
+              actionKey: const ValueKey('ui.overview.configureSensors'),
               icon: Icons.tune_outlined,
               title: 'Configure sensors',
               detail: 'Set required channels and sampling.',
@@ -147,6 +149,7 @@ class _OverviewWorkflowIntroCard extends StatelessWidget {
               onTap: () => onSensorTabRequested(0),
             ),
             _OverviewWorkflowStep(
+              actionKey: const ValueKey('ui.overview.viewSensorData'),
               icon: Icons.ssid_chart_outlined,
               title: 'View sensor data',
               detail: 'Check live signal quality before capture.',
@@ -155,6 +158,7 @@ class _OverviewWorkflowIntroCard extends StatelessWidget {
               onTap: () => onSensorTabRequested(1),
             ),
             _OverviewWorkflowStep(
+              actionKey: const ValueKey('ui.overview.record'),
               icon: Icons.fiber_smart_record,
               title: 'Record',
               detail: 'Start and monitor recording.',
@@ -170,6 +174,7 @@ class _OverviewWorkflowIntroCard extends StatelessWidget {
 }
 
 class _OverviewWorkflowStep extends StatelessWidget {
+  final Key actionKey;
   final IconData icon;
   final String title;
   final String detail;
@@ -178,6 +183,7 @@ class _OverviewWorkflowStep extends StatelessWidget {
   final VoidCallback onTap;
 
   const _OverviewWorkflowStep({
+    required this.actionKey,
     required this.icon,
     required this.title,
     required this.detail,
@@ -236,6 +242,7 @@ class _OverviewWorkflowStep extends StatelessWidget {
             const SizedBox(width: 10),
             Expanded(
               child: InkWell(
+                key: actionKey,
                 borderRadius: BorderRadius.circular(10),
                 onTap: onTap,
                 child: Padding(
diff --git a/open_wearable/lib/widgets/onboarding/permissions_onboarding_page.dart b/open_wearable/lib/widgets/onboarding/permissions_onboarding_page.dart
index 09f81a78f..3f299c815 100644
--- a/open_wearable/lib/widgets/onboarding/permissions_onboarding_page.dart
+++ b/open_wearable/lib/widgets/onboarding/permissions_onboarding_page.dart
@@ -86,6 +86,7 @@ class PermissionsWelcomePage extends StatelessWidget {
                         const Spacer(),
                         const SizedBox(height: 32),
                         PlatformElevatedButton(
+                          key: const ValueKey('ui.onboarding.getStarted'),
                           onPressed: () => _continue(context),
                           child: const Text('Get Started'),
                         ),
@@ -398,6 +399,7 @@ class _BluetoothPermissionsPageState extends State<BluetoothPermissionsPage>
               const Spacer(),
               const SizedBox(height: 32),
               PlatformElevatedButton(
+                key: const ValueKey('ui.onboarding.bluetooth'),
                 onPressed: _requestInProgress ? null : _request,
                 child: Text(
                   _requestInProgress
@@ -409,6 +411,7 @@ class _BluetoothPermissionsPageState extends State<BluetoothPermissionsPage>
               ),
               const SizedBox(height: 8),
               PlatformTextButton(
+                key: const ValueKey('ui.onboarding.skipBluetooth'),
                 onPressed: _requestInProgress ? null : _completeOnboarding,
                 child: const Text('Skip for now'),
               ),
@@ -536,6 +539,7 @@ class _MicrophonePermissionsPageState extends State<MicrophonePermissionsPage> {
               const Spacer(),
               const SizedBox(height: 32),
               PlatformElevatedButton(
+                key: const ValueKey('ui.onboarding.microphone'),
                 onPressed: _requestInProgress ? null : _request,
                 child: Text(
                   _requestInProgress ? 'Requesting...' : 'Enable Microphone',
@@ -543,6 +547,7 @@ class _MicrophonePermissionsPageState extends State<MicrophonePermissionsPage> {
               ),
               const SizedBox(height: 8),
               PlatformTextButton(
+                key: const ValueKey('ui.onboarding.skipMicrophone'),
                 onPressed: _requestInProgress ? null : _completeOnboarding,
                 child: const Text('Skip for now'),
               ),
diff --git a/open_wearable/lib/widgets/sensors/configuration/sensor_configuration_detail_view.dart b/open_wearable/lib/widgets/sensors/configuration/sensor_configuration_detail_view.dart
index 299c7a60e..a88cf0e39 100644
--- a/open_wearable/lib/widgets/sensors/configuration/sensor_configuration_detail_view.dart
+++ b/open_wearable/lib/widgets/sensors/configuration/sensor_configuration_detail_view.dart
@@ -91,6 +91,7 @@ class SensorConfigurationDetailView extends StatelessWidget {
             children: [
               for (var i = 0; i < targetOptions.length; i++) ...[
                 _OptionToggleTile(
+                  configurationName: sensorConfiguration.name,
                   option: targetOptions[i],
                   accentColor: accentColor,
                   selected: sensorConfigNotifier
@@ -143,6 +144,9 @@ class SensorConfigurationDetailView extends StatelessWidget {
                     ),
               )
             : DropdownButtonFormField<SensorConfigurationValue>(
+                key: ValueKey(
+                  'ui.sensor.rate.${sensorConfiguration.name}',
+                ),
                 initialValue: dropdownSelection,
                 isExpanded: true,
                 decoration: InputDecoration(
@@ -353,12 +357,14 @@ class SensorConfigurationDetailView extends StatelessWidget {
 }
 
 class _OptionToggleTile extends StatelessWidget {
+  final String configurationName;
   final SensorConfigurationOption option;
   final Color accentColor;
   final bool selected;
   final ValueChanged<bool> onChanged;
 
   const _OptionToggleTile({
+    required this.configurationName,
     required this.option,
     required this.accentColor,
     required this.selected,
@@ -422,6 +428,13 @@ class _OptionToggleTile extends StatelessWidget {
           ),
           const SizedBox(width: 8),
           Switch.adaptive(
+            key: ValueKey(
+              option is StreamSensorConfigOption
+                  ? 'ui.sensor.target.$configurationName.stream'
+                  : option is RecordSensorConfigOption
+                      ? 'ui.sensor.target.$configurationName.record'
+                      : 'ui.sensor.target.$configurationName.${option.name}',
+            ),
             value: selected,
             activeThumbColor: colorScheme.surface,
             activeTrackColor: accentColor,
diff --git a/open_wearable/lib/widgets/sensors/configuration/sensor_configuration_value_row.dart b/open_wearable/lib/widgets/sensors/configuration/sensor_configuration_value_row.dart
index ac41b416b..bd9147e48 100644
--- a/open_wearable/lib/widgets/sensors/configuration/sensor_configuration_value_row.dart
+++ b/open_wearable/lib/widgets/sensors/configuration/sensor_configuration_value_row.dart
@@ -98,6 +98,9 @@ class SensorConfigurationValueRow extends StatelessWidget {
       child: Material(
         color: Colors.transparent,
         child: InkWell(
+          key: ValueKey(
+            'ui.sensor.config.${sensorConfiguration.name}',
+          ),
           borderRadius: BorderRadius.circular(8),
           onTap: () => _openConfigurationSheet(context, primaryProvider),
           child: Padding(
@@ -233,6 +236,7 @@ class SensorConfigurationValueRow extends StatelessWidget {
                           ),
                           const SizedBox(width: 8),
                           IconButton(
+                            key: const ValueKey('ui.sensor.config.close'),
                             tooltip: 'Close',
                             onPressed: () => Navigator.of(modalContext).pop(),
                             icon: const Icon(Icons.close_rounded, size: 20),
diff --git a/open_wearable/lib/widgets/sensors/configuration/sensor_configuration_view.dart b/open_wearable/lib/widgets/sensors/configuration/sensor_configuration_view.dart
index b6a8084cc..377aac4ea 100644
--- a/open_wearable/lib/widgets/sensors/configuration/sensor_configuration_view.dart
+++ b/open_wearable/lib/widgets/sensors/configuration/sensor_configuration_view.dart
@@ -261,6 +261,7 @@ class SensorConfigurationView extends StatelessWidget {
     required List<_ConfigApplyTarget> targets,
   }) {
     return PlatformElevatedButton(
+      key: const ValueKey('ui.sensor.apply'),
       onPressed: () => _applyConfigurations(context, targets: targets),
       child: PlatformText('Apply Profiles'),
     );
diff --git a/open_wearable/lib/widgets/sensors/local_recorder/local_recorder_recording_card.dart b/open_wearable/lib/widgets/sensors/local_recorder/local_recorder_recording_card.dart
index 78cecf3c5..626395dbb 100644
--- a/open_wearable/lib/widgets/sensors/local_recorder/local_recorder_recording_card.dart
+++ b/open_wearable/lib/widgets/sensors/local_recorder/local_recorder_recording_card.dart
@@ -243,6 +243,7 @@ class _RecorderPrimaryButton extends StatelessWidget {
     return SizedBox(
       width: double.infinity,
       child: FilledButton.icon(
+        key: const ValueKey('ui.recorder.startStop'),
         style: isRecording
             ? FilledButton.styleFrom(
                 backgroundColor: colorScheme.error,
diff --git a/open_wearable/lib/widgets/sensors/local_recorder/local_recorder_recording_folder_card.dart b/open_wearable/lib/widgets/sensors/local_recorder/local_recorder_recording_folder_card.dart
index e368b8c73..f058db3e4 100644
--- a/open_wearable/lib/widgets/sensors/local_recorder/local_recorder_recording_folder_card.dart
+++ b/open_wearable/lib/widgets/sensors/local_recorder/local_recorder_recording_folder_card.dart
@@ -12,6 +12,7 @@ class LocalRecorderRecordingFolderCard extends StatelessWidget {
   final VoidCallback onToggleExpanded;
   final VoidCallback onShareFolder;
   final VoidCallback onDeleteFolder;
+  final Key? deleteButtonKey;
   final void Function(LocalRecorderRecordingFile file) onShareFile;
   final void Function(LocalRecorderRecordingFile file) onOpenFile;
   final String Function(int bytes) formatFileSize;
@@ -29,6 +30,7 @@ class LocalRecorderRecordingFolderCard extends StatelessWidget {
     required this.onToggleExpanded,
     required this.onShareFolder,
     required this.onDeleteFolder,
+    this.deleteButtonKey,
     required this.onShareFile,
     required this.onOpenFile,
     required this.formatFileSize,
@@ -76,6 +78,7 @@ class LocalRecorderRecordingFolderCard extends StatelessWidget {
                         icon: Icon(Icons.ios_share, color: colorScheme.primary),
                       ),
                       IconButton(
+                        key: deleteButtonKey,
                         tooltip: 'Delete folder',
                         onPressed: onDeleteFolder,
                         icon: Icon(
@@ -175,6 +178,7 @@ class _LocalRecorderRecordingFileTile extends StatelessWidget {
     final isCsv = file.name.toLowerCase().endsWith('.csv');
 
     return ListTile(
+      key: ValueKey('ui.recorder.file.${file.name}'),
       contentPadding: const EdgeInsets.fromLTRB(58, 2, 10, 2),
       dense: true,
       leading: Icon(
diff --git a/open_wearable/lib/widgets/sensors/local_recorder/local_recorder_view.dart b/open_wearable/lib/widgets/sensors/local_recorder/local_recorder_view.dart
index 78eb7bd5d..bb0671b22 100644
--- a/open_wearable/lib/widgets/sensors/local_recorder/local_recorder_view.dart
+++ b/open_wearable/lib/widgets/sensors/local_recorder/local_recorder_view.dart
@@ -102,6 +102,7 @@ class _LocalRecorderViewState extends State<LocalRecorderView> {
                 onPressed: () => Navigator.pop(context, false),
               ),
               PlatformDialogAction(
+                key: const ValueKey('ui.recorder.confirmDelete'),
                 cupertino: (_, __) => CupertinoDialogActionData(
                   isDestructiveAction: true,
                 ),
@@ -316,6 +317,7 @@ class _LocalRecorderViewState extends State<LocalRecorderView> {
           child: RefreshIndicator(
             onRefresh: _listRecordings,
             child: ListView(
+              key: const ValueKey('ui.sensors.recorder.content'),
               padding: SensorPageSpacing.pagePaddingWithBottomInset(context),
               children: [
                 LocalRecorderRecordingCard(
@@ -342,6 +344,7 @@ class _LocalRecorderViewState extends State<LocalRecorderView> {
                 if (!hasRecordings) const LocalRecorderEmptyStateCard(),
                 if (latestRecording != null)
                   LocalRecorderRecordingFolderCard(
+                    key: const ValueKey('ui.recorder.latestFolder'),
                     folder: latestRecording,
                     isCurrentRecording: isRecording,
                     isExpanded: _expandedFolders.contains(latestRecording.path),
@@ -381,6 +384,9 @@ class _LocalRecorderViewState extends State<LocalRecorderView> {
                       }
                     },
                     onShareFolder: () => _shareFolder(latestRecording),
+                    deleteButtonKey: const ValueKey(
+                      'ui.recorder.deleteLatest',
+                    ),
                     onDeleteFolder: () async {
                       final deleted =
                           await _confirmAndDeleteRecording(latestRecording);
diff --git a/open_wearable/lib/widgets/sensors/sensor_page.dart b/open_wearable/lib/widgets/sensors/sensor_page.dart
index 9fd9455e1..d85af9a9d 100644
--- a/open_wearable/lib/widgets/sensors/sensor_page.dart
+++ b/open_wearable/lib/widgets/sensors/sensor_page.dart
@@ -110,11 +110,14 @@ class _SensorPageState extends State<SensorPage>
     return Consumer<WearablesProvider>(
       builder: (context, wearablesProvider, child) {
         final hasConnectedDevices = wearablesProvider.wearables.isNotEmpty;
-        final noDevicesPrompt = Center(
-          child: NoDevicesPrompt(
-            onScanPressed: () => context.push('/connect-devices'),
-          ),
-        );
+        Widget noDevicesPrompt(String contentKey, String scanButtonKey) =>
+            Center(
+              key: ValueKey(contentKey),
+              child: NoDevicesPrompt(
+                scanButtonKey: ValueKey(scanButtonKey),
+                onScanPressed: () => context.push('/connect-devices'),
+              ),
+            );
 
         return PlatformScaffold(
           body: NestedScrollView(
@@ -140,9 +143,16 @@ class _SensorPageState extends State<SensorPage>
                   bottom: TabBar(
                     controller: _tabController,
                     tabs: [
-                      const Tab(text: 'Configure'),
-                      const Tab(text: 'Live Data'),
+                      const Tab(
+                        key: ValueKey('ui.sensors.configuration'),
+                        text: 'Configure',
+                      ),
+                      const Tab(
+                        key: ValueKey('ui.sensors.values'),
+                        text: 'Live Data',
+                      ),
                       Tab(
+                        key: const ValueKey('ui.sensors.recording'),
                         child: Row(
                           mainAxisSize: MainAxisSize.min,
                           children: [
@@ -166,12 +176,18 @@ class _SensorPageState extends State<SensorPage>
                           _tabController.animateTo(1);
                         },
                       )
-                    : noDevicesPrompt,
+                    : noDevicesPrompt(
+                        'ui.sensors.configure.empty',
+                        'ui.sensors.configure.scan',
+                      ),
                 hasConnectedDevices
                     ? SensorValuesPage(
                         sharedProviders: _sensorDataProviders,
                       )
-                    : noDevicesPrompt,
+                    : noDevicesPrompt(
+                        'ui.sensors.liveData.empty',
+                        'ui.sensors.liveData.scan',
+                      ),
                 const LocalRecorderView(),
               ],
             ),
diff --git a/open_wearable/lib/widgets/settings/general_settings_page.dart b/open_wearable/lib/widgets/settings/general_settings_page.dart
index 5a73bec4a..221c1f87d 100644
--- a/open_wearable/lib/widgets/settings/general_settings_page.dart
+++ b/open_wearable/lib/widgets/settings/general_settings_page.dart
@@ -175,6 +175,9 @@ class _GeneralSettingsPageState extends State<GeneralSettingsPage> {
                               _buildSettingGroup(
                                 [
                                   SwitchListTile.adaptive(
+                                    key: const ValueKey(
+                                      'ui.settings.autoConnect',
+                                    ),
                                     value: autoConnectEnabled,
                                     onChanged: _isSaving
                                         ? null
@@ -201,6 +204,9 @@ class _GeneralSettingsPageState extends State<GeneralSettingsPage> {
                               _buildSettingGroup(
                                 [
                                   SwitchListTile.adaptive(
+                                    key: const ValueKey(
+                                      'ui.settings.keepScreenAwake',
+                                    ),
                                     value: keepAppInForeground,
                                     onChanged: _isSaving
                                         ? null
@@ -227,6 +233,9 @@ class _GeneralSettingsPageState extends State<GeneralSettingsPage> {
                               _buildSettingGroup(
                                 [
                                   SwitchListTile.adaptive(
+                                    key: const ValueKey(
+                                      'ui.settings.disableSensorsOnClose',
+                                    ),
                                     value: shutOffOnCloseEnabled,
                                     onChanged: _isSaving
                                         ? null
@@ -253,6 +262,9 @@ class _GeneralSettingsPageState extends State<GeneralSettingsPage> {
                               _buildSettingGroup(
                                 [
                                   SwitchListTile.adaptive(
+                                    key: const ValueKey(
+                                      'ui.settings.disableLiveGraphs',
+                                    ),
                                     value: disableLiveGraphsEnabled,
                                     onChanged: _isSaving
                                         ? null
@@ -268,6 +280,9 @@ class _GeneralSettingsPageState extends State<GeneralSettingsPage> {
                                     ),
                                   ),
                                   SwitchListTile.adaptive(
+                                    key: const ValueKey(
+                                      'ui.settings.hideEmptyGraphs',
+                                    ),
                                     value: hideLiveGraphsWithoutDataEnabled,
                                     onChanged: _isSaving
                                         ? null
@@ -288,6 +303,9 @@ class _GeneralSettingsPageState extends State<GeneralSettingsPage> {
                                         .showSamplingRatesListenable,
                                     builder: (context, showSamplingRates, _) =>
                                         SwitchListTile.adaptive(
+                                      key: const ValueKey(
+                                        'ui.settings.showSamplingRates',
+                                      ),
                                       value: showSamplingRates,
                                       onChanged: _isSaving
                                           ? null
diff --git a/open_wearable/lib/widgets/settings/settings_page.dart b/open_wearable/lib/widgets/settings/settings_page.dart
index bb222f324..d4f94fe7b 100644
--- a/open_wearable/lib/widgets/settings/settings_page.dart
+++ b/open_wearable/lib/widgets/settings/settings_page.dart
@@ -45,12 +45,14 @@ class SettingsPage extends StatelessWidget {
         padding: SensorPageSpacing.pagePaddingWithBottomInset(context),
         children: [
           _QuickActionTile(
+            key: const ValueKey('ui.settings.general'),
             icon: Icons.tune_rounded,
             title: 'General settings',
             subtitle: 'Manage app-wide behavior',
             onTap: onGeneralSettingsRequested,
           ),
           _QuickActionTile(
+            key: const ValueKey('ui.settings.logs'),
             icon: Icons.receipt_long,
             title: 'Log files',
             subtitle: 'View, share, and remove diagnostic logs',
@@ -58,6 +60,7 @@ class SettingsPage extends StatelessWidget {
           ),
           if (AppUpgradeRegistry.latest != null)
             _QuickActionTile(
+              key: const ValueKey('ui.settings.releases'),
               icon: Icons.auto_awesome_rounded,
               title: 'Release history',
               subtitle: 'Browse app releases',
@@ -65,12 +68,14 @@ class SettingsPage extends StatelessWidget {
             ),
           if (!kIsWeb)
             _QuickActionTile(
+              key: const ValueKey('ui.settings.connectors'),
               icon: ConnectorBranding.icon,
               title: ConnectorBranding.pluralLabel,
               subtitle: 'Configure external API connectors',
               onTap: onConnectorsRequested,
             ),
           _QuickActionTile(
+            key: const ValueKey('ui.settings.about'),
             icon: Icons.info_outline_rounded,
             title: 'About',
             subtitle: 'App information, version, and licenses',
@@ -751,6 +756,7 @@ class _QuickActionTile extends StatelessWidget {
   final VoidCallback? onTap;
 
   const _QuickActionTile({
+    super.key,
     required this.icon,
     required this.title,
     required this.subtitle,
diff --git a/open_wearable/lib/widgets/updates/app_upgrade_page.dart b/open_wearable/lib/widgets/updates/app_upgrade_page.dart
index bb19f249c..11980ca9d 100644
--- a/open_wearable/lib/widgets/updates/app_upgrade_page.dart
+++ b/open_wearable/lib/widgets/updates/app_upgrade_page.dart
@@ -63,6 +63,7 @@ class AppUpgradePage extends StatelessWidget {
                       Align(
                         alignment: Alignment.centerRight,
                         child: IconButton(
+                          key: const ValueKey('ui.upgrade.close'),
                           tooltip: 'Close',
                           onPressed: dismiss,
                           icon: const Icon(Icons.close_rounded, size: 20),
diff --git a/open_wearable/macos/Flutter/GeneratedPluginRegistrant.swift b/open_wearable/macos/Flutter/GeneratedPluginRegistrant.swift
index 53279f2f9..92a099201 100644
--- a/open_wearable/macos/Flutter/GeneratedPluginRegistrant.swift
+++ b/open_wearable/macos/Flutter/GeneratedPluginRegistrant.swift
@@ -12,6 +12,7 @@ import flutter_archive
 import mcumgr_flutter
 import open_file_mac
 import package_info_plus
+import patrol
 import record_macos
 import share_plus
 import shared_preferences_foundation
@@ -27,6 +28,7 @@ func RegisterGeneratedPlugins(registry: FlutterPluginRegistry) {
   McumgrFlutterPlugin.register(with: registry.registrar(forPlugin: "McumgrFlutterPlugin"))
   OpenFilePlugin.register(with: registry.registrar(forPlugin: "OpenFilePlugin"))
   FPPPackageInfoPlusPlugin.register(with: registry.registrar(forPlugin: "FPPPackageInfoPlusPlugin"))
+  PatrolPlugin.register(with: registry.registrar(forPlugin: "PatrolPlugin"))
   RecordMacOsPlugin.register(with: registry.registrar(forPlugin: "RecordMacOsPlugin"))
   SharePlusMacosPlugin.register(with: registry.registrar(forPlugin: "SharePlusMacosPlugin"))
   SharedPreferencesPlugin.register(with: registry.registrar(forPlugin: "SharedPreferencesPlugin"))
diff --git a/open_wearable/patrol_test/general_settings_test.dart b/open_wearable/patrol_test/general_settings_test.dart
new file mode 100644
index 000000000..5afb5e842
--- /dev/null
+++ b/open_wearable/patrol_test/general_settings_test.dart
@@ -0,0 +1,100 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:patrol/patrol.dart';
+
+import 'support/app_driver.dart';
+
+const _settingKeys = <ValueKey<String>>[
+  UiTestKeys.settingsAutoConnect,
+  UiTestKeys.settingsKeepScreenAwake,
+  UiTestKeys.settingsDisableSensorsOnClose,
+  UiTestKeys.settingsDisableLiveGraphs,
+  UiTestKeys.settingsHideEmptyGraphs,
+  UiTestKeys.settingsShowSamplingRates,
+];
+
+void main() {
+  patrolTest(
+    'SET-01: every General setting changes, persists after reopening, and is restored',
+    ($) async {
+      await startProductionApp($);
+      await skipFirstRunPermissions($);
+      await _openGeneralSettings($);
+
+      final originalValues = <ValueKey<String>, bool>{};
+      for (final key in _settingKeys) {
+        await $(key).scrollTo();
+        final originalValue = _switchValue($, key);
+        originalValues[key] = originalValue;
+
+        await $(key).tap();
+        await _waitForSwitchValue($, key, !originalValue);
+      }
+
+      await $.tester.pageBack();
+      await $(UiTestKeys.settingsGeneral).waitUntilVisible();
+      await $(UiTestKeys.settingsGeneral).tap();
+
+      for (final key in _settingKeys) {
+        await $(key).scrollTo();
+        expect(_switchValue($, key), !originalValues[key]!);
+      }
+
+      // Restore every preference so repeated runs and manual use start cleanly.
+      for (final key in _settingKeys.reversed) {
+        await $(key).scrollTo();
+        await $(key).tap();
+        await _waitForSwitchValue($, key, originalValues[key]!);
+      }
+
+      await $.tester.pageBack();
+      await $(UiTestKeys.settingsGeneral).waitUntilVisible();
+      await $(UiTestKeys.settingsGeneral).tap();
+
+      for (final key in _settingKeys) {
+        await $(key).scrollTo();
+        expect(_switchValue($, key), originalValues[key]);
+      }
+
+      // Leave the lazily scrolled settings route before Patrol tears down the
+      // live test binding. This also proves Back remains usable after edits.
+      await $.tester.pageBack();
+      await $(UiTestKeys.settingsGeneral).waitUntilVisible();
+    },
+    // This journey reads Flutter widget values directly; platform semantics
+    // are unnecessary and can leak a handle in live Android tests.
+    semanticsEnabled: false,
+  );
+}
+
+Future<void> _openGeneralSettings(PatrolIntegrationTester $) async {
+  await $(UiTestKeys.navSettings).tap();
+  await $(UiTestKeys.settingsGeneral).waitUntilVisible();
+  await $(UiTestKeys.settingsGeneral).tap();
+  await $('General settings').waitUntilVisible();
+}
+
+bool _switchValue(
+  PatrolIntegrationTester $,
+  ValueKey<String> key,
+) {
+  return $.tester.widget<SwitchListTile>(find.byKey(key)).value;
+}
+
+Future<void> _waitForSwitchValue(
+  PatrolIntegrationTester $,
+  ValueKey<String> key,
+  bool expected,
+) async {
+  final deadline = DateTime.now().add(const Duration(seconds: 5));
+  while (DateTime.now().isBefore(deadline)) {
+    await $.pump(const Duration(milliseconds: 100));
+    if (_switchValue($, key) == expected) {
+      return;
+    }
+  }
+
+  throw TestFailure(
+    'Setting ${key.value} did not change to $expected within 5 seconds.',
+  );
+}
diff --git a/open_wearable/patrol_test/late_microphone_permission_test.dart b/open_wearable/patrol_test/late_microphone_permission_test.dart
new file mode 100644
index 000000000..8ee360972
--- /dev/null
+++ b/open_wearable/patrol_test/late_microphone_permission_test.dart
@@ -0,0 +1,47 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:patrol/patrol.dart';
+
+import 'support/app_driver.dart';
+
+void main() {
+  patrolTest(
+    'NAV-03: skip microphone onboarding and grant it from Connect Devices',
+    ($) async {
+      await startProductionApp($);
+      await grantBluetoothAndSkipMicrophone($);
+
+      await $(UiTestKeys.navDevices).tap();
+      await $(UiTestKeys.devicesConnect).waitUntilVisible();
+      await $(UiTestKeys.devicesConnect).tap();
+
+      await $(UiTestKeys.scanEnableMicrophone).waitUntilVisible(
+        timeout: const Duration(seconds: 10),
+      );
+      expect($(UiTestKeys.scanEnableBluetooth), findsNothing);
+
+      await $(UiTestKeys.scanEnableMicrophone).tap();
+      await grantVisibleAndroidPermissionDialogs($);
+      await _waitForMicrophoneCardToDisappear($);
+
+      expect($(UiTestKeys.scanEnableMicrophone), findsNothing);
+      expect($(UiTestKeys.scanEnableBluetooth), findsNothing);
+      expect($(UiTestKeys.scanStart), findsOneWidget);
+    },
+  );
+}
+
+Future<void> _waitForMicrophoneCardToDisappear(
+  PatrolIntegrationTester $,
+) async {
+  final deadline = DateTime.now().add(const Duration(seconds: 10));
+  while (DateTime.now().isBefore(deadline)) {
+    await $.pump(const Duration(milliseconds: 100));
+    if (find.byKey(UiTestKeys.scanEnableMicrophone).evaluate().isEmpty) {
+      return;
+    }
+  }
+
+  throw TestFailure(
+    'The microphone recovery card remained after permission was granted.',
+  );
+}
diff --git a/open_wearable/patrol_test/navigation_and_settings_test.dart b/open_wearable/patrol_test/navigation_and_settings_test.dart
new file mode 100644
index 000000000..7dea23874
--- /dev/null
+++ b/open_wearable/patrol_test/navigation_and_settings_test.dart
@@ -0,0 +1,62 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:patrol/patrol.dart';
+
+import 'support/app_driver.dart';
+
+void main() {
+  patrolTest(
+    'NAV-02 NAV-06(partial) SET-01(partial): onboarding, navigation, and a setting control',
+    ($) async {
+      await startProductionApp($);
+
+      await $(UiTestKeys.onboardingGetStarted).waitUntilVisible(
+        timeout: const Duration(seconds: 30),
+      );
+      expect($('Welcome to OpenWearables'), findsOneWidget);
+      await skipFirstRunPermissions($);
+
+      await $(UiTestKeys.navDevices).tap();
+      await $(UiTestKeys.devicesConnect).waitUntilVisible();
+      await $(UiTestKeys.devicesConnect).tap();
+      await $(UiTestKeys.scanEnableBluetooth).waitUntilVisible();
+      expect($('Enable Bluetooth & Location'), findsOneWidget);
+      expect(
+        $('Allow Bluetooth and Location so the app can find and connect to '
+            'your wearable.'),
+        findsOneWidget,
+      );
+      await $.tester.pageBack();
+      await $(UiTestKeys.navSensors).waitUntilVisible();
+
+      await $(UiTestKeys.navSensors).tap();
+      await $(UiTestKeys.sensorConfiguration).waitUntilVisible();
+
+      await $(UiTestKeys.navApps).tap();
+      await $('Posture Tracker').waitUntilVisible();
+
+      await $(UiTestKeys.navSettings).tap();
+      await $(UiTestKeys.settingsGeneral).waitUntilVisible();
+      await $(UiTestKeys.settingsGeneral).tap();
+      expect($('General settings'), findsOneWidget);
+
+      final switchFinder = find.byKey(UiTestKeys.settingsKeepScreenAwake);
+      final originalValue = $.tester.widget<SwitchListTile>(switchFinder).value;
+
+      await $(UiTestKeys.settingsKeepScreenAwake).tap();
+      await $.pump(const Duration(milliseconds: 250));
+      expect(
+        $.tester.widget<SwitchListTile>(switchFinder).value,
+        isNot(originalValue),
+      );
+
+      // Restore the user's original setting so this journey is repeatable.
+      await $(UiTestKeys.settingsKeepScreenAwake).tap();
+      await $.pump(const Duration(milliseconds: 250));
+      expect(
+        $.tester.widget<SwitchListTile>(switchFinder).value,
+        originalValue,
+      );
+    },
+  );
+}
diff --git a/open_wearable/patrol_test/onboarding_permissions_test.dart b/open_wearable/patrol_test/onboarding_permissions_test.dart
new file mode 100644
index 000000000..96a275f1b
--- /dev/null
+++ b/open_wearable/patrol_test/onboarding_permissions_test.dart
@@ -0,0 +1,50 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:patrol/patrol.dart';
+
+import 'support/app_driver.dart';
+
+void main() {
+  patrolTest(
+    'NAV-01: grant Bluetooth, location, and microphone during onboarding',
+    ($) async {
+      await startProductionApp($);
+
+      await $(UiTestKeys.onboardingGetStarted).waitUntilVisible(
+        timeout: const Duration(seconds: 30),
+      );
+      expect($('Welcome to OpenWearables'), findsOneWidget);
+
+      await grantFirstRunPermissions($);
+      expect($(UiTestKeys.navOverview), findsOneWidget);
+
+      await $(UiTestKeys.navDevices).tap();
+      await $(UiTestKeys.devicesConnect).waitUntilVisible();
+      await $(UiTestKeys.devicesConnect).tap();
+      await $(UiTestKeys.scanStart).waitUntilVisible();
+      await _waitForPermissionCardsToDisappear($);
+
+      expect($(UiTestKeys.scanEnableBluetooth), findsNothing);
+      expect($(UiTestKeys.scanEnableMicrophone), findsNothing);
+    },
+  );
+}
+
+Future<void> _waitForPermissionCardsToDisappear(
+  PatrolIntegrationTester $,
+) async {
+  final deadline = DateTime.now().add(const Duration(seconds: 10));
+  while (DateTime.now().isBefore(deadline)) {
+    await $.pump(const Duration(milliseconds: 100));
+    final bluetoothVisible =
+        find.byKey(UiTestKeys.scanEnableBluetooth).evaluate().isNotEmpty;
+    final microphoneVisible =
+        find.byKey(UiTestKeys.scanEnableMicrophone).evaluate().isNotEmpty;
+    if (!bluetoothVisible && !microphoneVisible) {
+      return;
+    }
+  }
+
+  throw TestFailure(
+    'The connection screen still requested a permission after onboarding.',
+  );
+}
diff --git a/open_wearable/patrol_test/open_earable_connection_test.dart b/open_wearable/patrol_test/open_earable_connection_test.dart
new file mode 100644
index 000000000..9c6a4443c
--- /dev/null
+++ b/open_wearable/patrol_test/open_earable_connection_test.dart
@@ -0,0 +1,68 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:patrol/patrol.dart';
+
+import 'support/app_driver.dart';
+
+const String _targetDeviceId = String.fromEnvironment(
+  'OPENEARABLE_DEVICE_ID',
+);
+
+void main() {
+  patrolTest(
+    'CON-01 CON-07 DEV-01(partial): connect and inspect a selected OpenEarable',
+    ($) async {
+      expect(
+        _targetDeviceId,
+        isNotEmpty,
+        reason: 'Pass the exact Android Bluetooth device ID with '
+            '--dart-define=OPENEARABLE_DEVICE_ID=<id>.',
+      );
+
+      await startProductionApp($);
+      await grantFirstRunPermissions($);
+
+      await $(UiTestKeys.navDevices).tap();
+      await $(UiTestKeys.devicesConnect).tap();
+      await startBleScan($);
+
+      final discoveredDevice = $(UiTestKeys.scannedDevice(_targetDeviceId));
+      await discoveredDevice.waitUntilVisible(
+        timeout: const Duration(seconds: 45),
+      );
+      await discoveredDevice.tap();
+
+      final connectedDevice = $(UiTestKeys.connectedDevice(_targetDeviceId));
+      await connectedDevice.waitUntilVisible(
+        timeout: const Duration(seconds: 45),
+      );
+      await connectedDevice.tap();
+
+      await $(UiTestKeys.deviceDetails(_targetDeviceId)).waitUntilVisible();
+      expect($('Device Information'), findsOneWidget);
+      expect($('Battery'), findsOneWidget);
+
+      await $(UiTestKeys.deviceDisconnect).scrollTo();
+      await $(UiTestKeys.deviceDisconnect).tap();
+      await startBleScan($);
+      await discoveredDevice.waitUntilVisible(
+        timeout: const Duration(seconds: 45),
+      );
+
+      // Reconnect and reopen details to verify that disconnect did not leave
+      // stale app state, then disconnect again so the fixture is reusable.
+      await discoveredDevice.tap();
+      await connectedDevice.waitUntilVisible(
+        timeout: const Duration(seconds: 45),
+      );
+      await connectedDevice.tap();
+      await $(UiTestKeys.deviceDetails(_targetDeviceId)).waitUntilVisible();
+      await $(UiTestKeys.deviceDisconnect).scrollTo();
+      await $(UiTestKeys.deviceDisconnect).tap();
+      await startBleScan($);
+      await discoveredDevice.waitUntilVisible(
+        timeout: const Duration(seconds: 45),
+      );
+    },
+    timeout: const Timeout(Duration(minutes: 6)),
+  );
+}
diff --git a/open_wearable/patrol_test/open_earable_pair_sample_rate_test.dart b/open_wearable/patrol_test/open_earable_pair_sample_rate_test.dart
new file mode 100644
index 000000000..fcda48269
--- /dev/null
+++ b/open_wearable/patrol_test/open_earable_pair_sample_rate_test.dart
@@ -0,0 +1,389 @@
+import 'dart:convert';
+
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:open_wearable/widgets/sensors/local_recorder/local_recorder_models.dart';
+import 'package:open_wearable/widgets/sensors/local_recorder/local_recorder_storage.dart';
+import 'package:patrol/patrol.dart';
+
+import 'support/app_driver.dart';
+import 'support/open_earable_pair_driver.dart';
+
+const _requestedRatesCsv = String.fromEnvironment(
+  'OPENEARABLE_SAMPLE_RATES_HZ',
+  defaultValue: '25',
+);
+const _recordingDurationSeconds = int.fromEnvironment(
+  'OPENEARABLE_SAMPLE_DURATION_SECONDS',
+  defaultValue: 12,
+);
+const _tolerancePercentText = String.fromEnvironment(
+  'OPENEARABLE_SAMPLE_TOLERANCE_PERCENT',
+  defaultValue: '15',
+);
+final _tolerancePercent = double.tryParse(_tolerancePercentText) ?? double.nan;
+
+const _imuConfigurationName = '9-Axis IMU';
+const _accelerometerSensorName = 'ACCELEROMETER';
+
+void main() {
+  patrolTest(
+    'RATE-01: requested pair sample rates match received left and right samples',
+    ($) async {
+      final requestedRates = _parseRequestedRates();
+      _validateTestParameters(requestedRates);
+
+      await startProductionApp($);
+      await grantFirstRunPermissions($);
+      final pair = await connectExactlyTwoOpenEarables($);
+
+      try {
+        for (final requestedRate in requestedRates) {
+          await _configurePairImuStreaming($, requestedRate);
+          await _recordAndVerifyRate($, requestedRate);
+        }
+      } finally {
+        await _stopRecordingIfNecessary($);
+        await cleanupConnectedPair($, pair);
+      }
+    },
+    timeout: const Timeout(Duration(minutes: 15)),
+  );
+}
+
+List<double> _parseRequestedRates() {
+  return _requestedRatesCsv
+      .split(',')
+      .map((value) => double.tryParse(value.trim()))
+      .whereType<double>()
+      .toList(growable: false);
+}
+
+void _validateTestParameters(List<double> requestedRates) {
+  if (requestedRates.isEmpty ||
+      requestedRates.any((rate) => !rate.isFinite || rate <= 0)) {
+    throw TestFailure(
+      'OPENEARABLE_SAMPLE_RATES_HZ must contain positive comma-separated '
+      'numbers. Received "$_requestedRatesCsv".',
+    );
+  }
+  if (_recordingDurationSeconds < 5) {
+    throw TestFailure(
+      'OPENEARABLE_SAMPLE_DURATION_SECONDS must be at least 5 seconds.',
+    );
+  }
+  if (!_tolerancePercent.isFinite ||
+      _tolerancePercent <= 0 ||
+      _tolerancePercent >= 100) {
+    throw TestFailure(
+      'OPENEARABLE_SAMPLE_TOLERANCE_PERCENT must be between 0 and 100.',
+    );
+  }
+}
+
+Future<void> _configurePairImuStreaming(
+  PatrolIntegrationTester $,
+  double requestedRate,
+) async {
+  await $(UiTestKeys.navSensors).tap();
+  await $(UiTestKeys.sensorConfiguration).tap();
+
+  final configuration = $(UiTestKeys.sensorConfig(_imuConfigurationName));
+  await configuration.scrollTo();
+  await configuration.waitUntilVisible(timeout: const Duration(seconds: 20));
+  await configuration.tap();
+
+  final streamTarget = UiTestKeys.sensorStreamTarget(_imuConfigurationName);
+  await $(streamTarget).waitUntilVisible();
+  final streamSwitch = $.tester.widget<Switch>(find.byKey(streamTarget));
+  if (!streamSwitch.value) {
+    await $(streamTarget).tap();
+  }
+
+  final rateDropdown = UiTestKeys.sensorRate(_imuConfigurationName);
+  await $(rateDropdown).waitUntilVisible();
+  await $(rateDropdown).tap();
+  final rateLabel = '${requestedRate.toStringAsFixed(2)} Hz';
+  if (!$(rateLabel).visible) {
+    throw TestFailure(
+      'The connected OpenEarable pair does not offer $rateLabel for '
+      '$_imuConfigurationName streaming.',
+    );
+  }
+  await $(rateLabel).tap();
+  await $(UiTestKeys.sensorConfigClose).tap();
+
+  await $(UiTestKeys.sensorApply).scrollTo();
+  await $(UiTestKeys.sensorApply).tap();
+  await $(_accelerometerSensorName).waitUntilVisible(
+    timeout: const Duration(seconds: 20),
+  );
+}
+
+Future<void> _recordAndVerifyRate(
+  PatrolIntegrationTester $,
+  double requestedRate,
+) async {
+  final foldersBefore = await listRecordingFolders();
+  final existingPaths = foldersBefore.map((folder) => folder.path).toSet();
+
+  await $(UiTestKeys.sensorRecording).tap();
+  await $(UiTestKeys.recorderStartStop).waitUntilVisible();
+  await $(UiTestKeys.recorderStartStop).tap();
+  await $('Recording in progress').waitUntilVisible();
+  await $.pump(Duration(seconds: _recordingDurationSeconds));
+  await $(UiTestKeys.recorderStartStop).tap();
+  await $('Ready to record').waitUntilVisible(
+    timeout: const Duration(seconds: 15),
+  );
+
+  final folder = await _waitForCompletedRecording(
+    $,
+    existingPaths: existingPaths,
+  );
+  final measurements = await _readSideMeasurements(folder);
+  _assertMeasurements(
+    measurements: measurements,
+    requestedRate: requestedRate,
+  );
+
+  await $(UiTestKeys.recorderLatestFolder).scrollTo();
+  await $(UiTestKeys.recorderLatestFolder).tap();
+  final leftFileKey = UiTestKeys.recordedFile(measurements['L']!.fileName);
+  await $(leftFileKey).scrollTo();
+  await $(leftFileKey).waitUntilVisible();
+  expect(
+    find.byKey(UiTestKeys.recordedFile(measurements['R']!.fileName)),
+    findsOneWidget,
+    reason: 'The expanded recording folder should list the right-side CSV.',
+  );
+  await $(UiTestKeys.recorderDeleteLatest).tap();
+  await $(UiTestKeys.recorderConfirmDelete).waitUntilVisible();
+  await $(UiTestKeys.recorderConfirmDelete).tap();
+  await _waitUntilFolderIsDeleted($, folder.path);
+}
+
+Future<LocalRecorderRecordingFolder> _waitForCompletedRecording(
+  PatrolIntegrationTester $, {
+  required Set<String> existingPaths,
+}) async {
+  LocalRecorderRecordingFolder? lastCandidate;
+  Map<String, int>? previousSizes;
+  var stableReads = 0;
+  final deadline = DateTime.now().add(const Duration(seconds: 20));
+
+  while (DateTime.now().isBefore(deadline)) {
+    final folders = await listRecordingFolders();
+    final candidates = folders
+        .where((folder) => !existingPaths.contains(folder.path))
+        .toList(growable: false);
+    if (candidates.isNotEmpty) {
+      lastCandidate = candidates.first;
+      final sizes = <String, int>{
+        for (final file in lastCandidate.files) file.path: file.sizeBytes,
+      };
+      final hasNonEmptyAccelerometers = lastCandidate.files
+              .where(_isAccelerometerCsv)
+              .where((file) => file.sizeBytes > 30)
+              .length >=
+          2;
+      if (hasNonEmptyAccelerometers && _mapsEqual(sizes, previousSizes)) {
+        stableReads++;
+        if (stableReads >= 2) {
+          return lastCandidate;
+        }
+      } else {
+        stableReads = 0;
+      }
+      previousSizes = sizes;
+    }
+    await $.pump(const Duration(milliseconds: 250));
+  }
+
+  throw TestFailure(
+    'The recording did not finish two non-empty accelerometer CSV files. '
+    'Latest folder: ${lastCandidate?.path ?? 'none'}.',
+  );
+}
+
+Future<Map<String, _RateMeasurement>> _readSideMeasurements(
+  LocalRecorderRecordingFolder folder,
+) async {
+  final result = <String, _RateMeasurement>{};
+  for (final file in folder.files.where(_isAccelerometerCsv)) {
+    final content = await readRecordingFileText(file);
+    final lines = const LineSplitter()
+        .convert(content)
+        .where((line) => line.trim().isNotEmpty)
+        .toList(growable: false);
+    if (lines.length <= 2) {
+      continue;
+    }
+
+    final side = _sideFromFilename(file.name);
+    if (side == null) {
+      continue;
+    }
+    if (result.containsKey(side)) {
+      throw TestFailure(
+        'More than one non-empty $_accelerometerSensorName CSV was found for '
+        'side $side in ${folder.name}.',
+      );
+    }
+
+    final timestamps = <int>[];
+    for (final line in lines.skip(1)) {
+      final firstColumn = line.split(',').first.trim();
+      final timestamp = int.tryParse(firstColumn);
+      if (timestamp == null) {
+        throw TestFailure(
+          'Invalid timestamp "$firstColumn" in ${file.name}.',
+        );
+      }
+      timestamps.add(timestamp);
+    }
+    result[side] = _RateMeasurement.fromTimestamps(
+      fileName: file.name,
+      timestamps: timestamps,
+    );
+  }
+  return result;
+}
+
+void _assertMeasurements({
+  required Map<String, _RateMeasurement> measurements,
+  required double requestedRate,
+}) {
+  expect(
+    measurements.keys.toSet(),
+    equals({'L', 'R'}),
+    reason: 'A non-empty accelerometer CSV is required for both pair sides.',
+  );
+
+  final toleranceFraction = _tolerancePercent / 100;
+  final minimum = requestedRate * (1 - toleranceFraction);
+  final maximum = requestedRate * (1 + toleranceFraction);
+  for (final entry in measurements.entries) {
+    final measurement = entry.value;
+    expect(
+      measurement.sampleCount,
+      greaterThanOrEqualTo(10),
+      reason: '${measurement.fileName} has too few received samples.',
+    );
+    expect(
+      measurement.durationSeconds,
+      greaterThanOrEqualTo(_recordingDurationSeconds * 0.6),
+      reason: '${measurement.fileName} covers too little recording time.',
+    );
+    expect(
+      measurement.observedRateHz,
+      inInclusiveRange(minimum, maximum),
+      reason:
+          'Side ${entry.key} received ${measurement.observedRateHz.toStringAsFixed(2)} '
+          'Hz for a requested ${requestedRate.toStringAsFixed(2)} Hz '
+          '(allowed ${minimum.toStringAsFixed(2)}-${maximum.toStringAsFixed(2)} Hz).',
+    );
+    debugPrint(
+      'PAIR_SAMPLE_RATE side=${entry.key} '
+      'requested_hz=${requestedRate.toStringAsFixed(2)} '
+      'observed_hz=${measurement.observedRateHz.toStringAsFixed(2)} '
+      'samples=${measurement.sampleCount} '
+      'duration_s=${measurement.durationSeconds.toStringAsFixed(3)} '
+      'file="${measurement.fileName}"',
+    );
+  }
+}
+
+bool _isAccelerometerCsv(LocalRecorderRecordingFile file) {
+  final upper = file.name.toUpperCase();
+  return upper.endsWith('.CSV') && upper.contains(_accelerometerSensorName);
+}
+
+String? _sideFromFilename(String name) {
+  if (name.contains('-L-')) return 'L';
+  if (name.contains('-R-')) return 'R';
+  return null;
+}
+
+bool _mapsEqual(Map<String, int> current, Map<String, int>? previous) {
+  if (previous == null || current.length != previous.length) {
+    return false;
+  }
+  for (final entry in current.entries) {
+    if (previous[entry.key] != entry.value) {
+      return false;
+    }
+  }
+  return true;
+}
+
+Future<void> _waitUntilFolderIsDeleted(
+  PatrolIntegrationTester $,
+  String path,
+) async {
+  final deadline = DateTime.now().add(const Duration(seconds: 10));
+  while (DateTime.now().isBefore(deadline)) {
+    final folders = await listRecordingFolders();
+    if (folders.every((folder) => folder.path != path)) {
+      return;
+    }
+    await $.pump(const Duration(milliseconds: 100));
+  }
+  throw TestFailure('The test recording was not deleted: $path');
+}
+
+Future<void> _stopRecordingIfNecessary(PatrolIntegrationTester $) async {
+  if ($('Recording in progress').visible &&
+      $(UiTestKeys.recorderStartStop).visible) {
+    await $(UiTestKeys.recorderStartStop).tap();
+    await $('Ready to record').waitUntilVisible(
+      timeout: const Duration(seconds: 15),
+    );
+  }
+}
+
+class _RateMeasurement {
+  const _RateMeasurement({
+    required this.fileName,
+    required this.sampleCount,
+    required this.durationSeconds,
+    required this.observedRateHz,
+  });
+
+  factory _RateMeasurement.fromTimestamps({
+    required String fileName,
+    required List<int> timestamps,
+  }) {
+    if (timestamps.length < 2) {
+      throw TestFailure('$fileName has fewer than two sensor timestamps.');
+    }
+    for (var index = 1; index < timestamps.length; index++) {
+      if (timestamps[index] <= timestamps[index - 1]) {
+        throw TestFailure(
+          '$fileName contains non-increasing timestamps at row ${index + 2}.',
+        );
+      }
+    }
+
+    // OpenEarable v2 declares timestampExponent = -6, so CSV timestamps are
+    // microseconds. Every timestamp used here belongs to a sample the app
+    // actually received and wrote.
+    final durationSeconds =
+        (timestamps.last - timestamps.first) / Duration.microsecondsPerSecond;
+    if (durationSeconds <= 0) {
+      throw TestFailure('$fileName has a non-positive timestamp span.');
+    }
+    final observedRate = (timestamps.length - 1) / durationSeconds;
+    return _RateMeasurement(
+      fileName: fileName,
+      sampleCount: timestamps.length,
+      durationSeconds: durationSeconds,
+      observedRateHz: observedRate,
+    );
+  }
+
+  final String fileName;
+  final int sampleCount;
+  final double durationSeconds;
+  final double observedRateHz;
+}
diff --git a/open_wearable/patrol_test/open_earable_pair_test.dart b/open_wearable/patrol_test/open_earable_pair_test.dart
new file mode 100644
index 000000000..563f7eef5
--- /dev/null
+++ b/open_wearable/patrol_test/open_earable_pair_test.dart
@@ -0,0 +1,49 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:patrol/patrol.dart';
+
+import 'support/app_driver.dart';
+import 'support/open_earable_pair_driver.dart';
+
+void main() {
+  patrolTest(
+    'PAIR-01 PAIR-02 PAIR-03: connect, identify, split, and recombine a stereo pair',
+    ($) async {
+      await startProductionApp($);
+      await grantFirstRunPermissions($);
+
+      final pairFixture = await connectExactlyTwoOpenEarables($);
+      final deviceId1 = pairFixture.deviceIds[0];
+      final deviceId2 = pairFixture.deviceIds[1];
+      final pairKey = pairFixture.pairKey;
+      try {
+        final pair = $(UiTestKeys.combinedPair(pairKey));
+
+        expect(
+          descendantText(UiTestKeys.combinedPair(pairKey), 'L'),
+          findsOneWidget,
+        );
+        expect(
+          descendantText(UiTestKeys.combinedPair(pairKey), 'R'),
+          findsOneWidget,
+        );
+
+        await $(UiTestKeys.combinedPairToggle(pairKey)).tap();
+        await $(UiTestKeys.connectedDevice(deviceId1)).waitUntilVisible();
+        await $(UiTestKeys.connectedDevice(deviceId2)).waitUntilVisible();
+
+        final side1 = sideForDevice($, deviceId1);
+        final side2 = sideForDevice($, deviceId2);
+        expect({side1, side2}, equals({'L', 'R'}));
+        debugPrint('PAIR_SIDE_MAPPING id="$deviceId1" side="$side1"');
+        debugPrint('PAIR_SIDE_MAPPING id="$deviceId2" side="$side2"');
+
+        await $(UiTestKeys.splitPairToggle(pairKey, deviceId1)).tap();
+        await pair.waitUntilVisible(timeout: const Duration(seconds: 30));
+      } finally {
+        await cleanupConnectedPair($, pairFixture);
+      }
+    },
+    timeout: const Timeout(Duration(minutes: 8)),
+  );
+}
diff --git a/open_wearable/patrol_test/overview_shortcuts_test.dart b/open_wearable/patrol_test/overview_shortcuts_test.dart
new file mode 100644
index 000000000..a38cb76ab
--- /dev/null
+++ b/open_wearable/patrol_test/overview_shortcuts_test.dart
@@ -0,0 +1,59 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:patrol/patrol.dart';
+
+import 'support/app_driver.dart';
+
+void main() {
+  patrolTest(
+    'NAV-07: Overview shortcuts open the correct empty-state destinations',
+    ($) async {
+      await startProductionApp($);
+      await skipFirstRunPermissions($);
+
+      expect($('No devices connected'), findsOneWidget);
+      expect($('DISCONNECTED'), findsOneWidget);
+
+      await _tapOverviewShortcut($, UiTestKeys.overviewConnectDevices);
+      await $(UiTestKeys.scanEnableBluetooth).waitUntilVisible();
+      expect($('Connect Devices'), findsOneWidget);
+      await $.tester.pageBack();
+      await $(UiTestKeys.navOverview).waitUntilVisible();
+
+      await _tapOverviewShortcut($, UiTestKeys.overviewConfigureSensors);
+      await $(UiTestKeys.sensorConfigureScan).waitUntilVisible();
+      expect(find.text('No devices connected').hitTestable(), findsOneWidget);
+      expect(find.text('Scan for devices').hitTestable(), findsOneWidget);
+
+      await $(UiTestKeys.navOverview).tap();
+      await _tapOverviewShortcut($, UiTestKeys.overviewViewSensorData);
+      await $(UiTestKeys.sensorLiveDataScan).waitUntilVisible();
+      expect(find.text('No devices connected').hitTestable(), findsOneWidget);
+      expect(find.text('Scan for devices').hitTestable(), findsOneWidget);
+
+      await $(UiTestKeys.navOverview).tap();
+      await _tapOverviewShortcut($, UiTestKeys.overviewRecord);
+      await $('Local Recorder').waitUntilVisible();
+      expect($('Local Recorder'), findsOneWidget);
+      expect($('No sensors connected'), findsOneWidget);
+
+      final startRecording = find.widgetWithText(
+        FilledButton,
+        'Start Recording',
+      );
+      expect(startRecording, findsOneWidget);
+      expect($.tester.widget<FilledButton>(startRecording).onPressed, isNull);
+
+      await $(UiTestKeys.navOverview).tap();
+      await $(UiTestKeys.navOverview).waitUntilVisible();
+    },
+  );
+}
+
+Future<void> _tapOverviewShortcut(
+  PatrolIntegrationTester $,
+  ValueKey<String> key,
+) async {
+  await $(key).scrollTo();
+  await $(key).tap();
+}
diff --git a/open_wearable/patrol_test/pair_discovery_test.dart b/open_wearable/patrol_test/pair_discovery_test.dart
new file mode 100644
index 000000000..3aecd6997
--- /dev/null
+++ b/open_wearable/patrol_test/pair_discovery_test.dart
@@ -0,0 +1,43 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:patrol/patrol.dart';
+
+import 'support/app_driver.dart';
+
+void main() {
+  patrolTest(
+    'PAIR-DISCOVERY: report two OpenEarable IDs without connecting',
+    ($) async {
+      await startProductionApp($);
+      await grantFirstRunPermissions($);
+
+      await $(UiTestKeys.navDevices).tap();
+      await $(UiTestKeys.devicesConnect).waitUntilVisible();
+      await $(UiTestKeys.devicesConnect).tap();
+      await $(UiTestKeys.scanOpenEarableFilter).waitUntilVisible();
+      await $(UiTestKeys.scanOpenEarableFilter).tap();
+      await startBleScan($);
+
+      // The app intentionally scans for eight seconds. Let that complete so
+      // the result represents the full visible discovery window.
+      await $.pump(const Duration(seconds: 9));
+      // The bottom "Scan Again" button is lazily built only after scrolling.
+      // The status at the top is visible throughout and changes when the
+      // timed scan has completed.
+      await $('Ready to scan').waitUntilVisible();
+
+      final filteredDeviceRows = find.byWidgetPredicate((widget) {
+        final key = widget.key;
+        return key is ValueKey<String> &&
+            key.value.startsWith('ui.scan.device.');
+      });
+      expect(
+        filteredDeviceRows,
+        findsAtLeastNWidgets(2),
+        reason: 'Two advertising OpenEarables must be visible before the '
+            'left/right pair test can be built safely.',
+      );
+      expect($(UiTestKeys.connectedThisDevice), findsNothing);
+    },
+  );
+}
diff --git a/open_wearable/patrol_test/support/app_driver.dart b/open_wearable/patrol_test/support/app_driver.dart
new file mode 100644
index 000000000..311858aee
--- /dev/null
+++ b/open_wearable/patrol_test/support/app_driver.dart
@@ -0,0 +1,305 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:open_wearable/main.dart' as app;
+import 'package:patrol/patrol.dart';
+
+/// Stable UI identifiers shared by the initial Patrol journeys.
+abstract final class UiTestKeys {
+  static const onboardingGetStarted = ValueKey<String>(
+    'ui.onboarding.getStarted',
+  );
+  static const onboardingBluetooth = ValueKey<String>(
+    'ui.onboarding.bluetooth',
+  );
+  static const onboardingSkipBluetooth = ValueKey<String>(
+    'ui.onboarding.skipBluetooth',
+  );
+  static const onboardingMicrophone = ValueKey<String>(
+    'ui.onboarding.microphone',
+  );
+  static const onboardingSkipMicrophone = ValueKey<String>(
+    'ui.onboarding.skipMicrophone',
+  );
+  static const upgradeClose = ValueKey<String>('ui.upgrade.close');
+  static const firmwareUpdateLater = ValueKey<String>(
+    'ui.firmwareUpdate.later',
+  );
+  static const permissionRequiredCancel = ValueKey<String>(
+    'ui.permissions.required.cancel',
+  );
+
+  static const navOverview = ValueKey<String>('ui.nav.overview');
+  static const navDevices = ValueKey<String>('ui.nav.devices');
+  static const navSensors = ValueKey<String>('ui.nav.sensors');
+  static const navApps = ValueKey<String>('ui.nav.apps');
+  static const navSettings = ValueKey<String>('ui.nav.settings');
+
+  static const overviewConnectDevices = ValueKey<String>(
+    'ui.overview.connectDevices',
+  );
+  static const overviewConfigureSensors = ValueKey<String>(
+    'ui.overview.configureSensors',
+  );
+  static const overviewViewSensorData = ValueKey<String>(
+    'ui.overview.viewSensorData',
+  );
+  static const overviewRecord = ValueKey<String>('ui.overview.record');
+
+  static const devicesConnect = ValueKey<String>('ui.devices.connect');
+  static const scanStart = ValueKey<String>('ui.scan.start');
+  static const scanAgain = ValueKey<String>('ui.scan.again');
+  static const scanOpenEarableFilter = ValueKey<String>(
+    'ui.scan.openEarableFilter',
+  );
+  static const scanEnableBluetooth = ValueKey<String>(
+    'ui.scan.enableBluetooth',
+  );
+  static const scanEnableMicrophone = ValueKey<String>(
+    'ui.scan.enableMicrophone',
+  );
+  static const scanThisDevice = ValueKey<String>('ui.scan.thisDevice');
+  static const connectedThisDevice = ValueKey<String>(
+    'ui.devices.thisDevice',
+  );
+  static const sensorConfiguration = ValueKey<String>(
+    'ui.sensors.configuration',
+  );
+  static const sensorConfigureEmpty = ValueKey<String>(
+    'ui.sensors.configure.empty',
+  );
+  static const sensorConfigureScan = ValueKey<String>(
+    'ui.sensors.configure.scan',
+  );
+  static const sensorLiveDataEmpty = ValueKey<String>(
+    'ui.sensors.liveData.empty',
+  );
+  static const sensorLiveDataScan = ValueKey<String>(
+    'ui.sensors.liveData.scan',
+  );
+  static const sensorRecorderContent = ValueKey<String>(
+    'ui.sensors.recorder.content',
+  );
+  static const sensorRecording = ValueKey<String>('ui.sensors.recording');
+  static const sensorConfigAccelerometer = ValueKey<String>(
+    'ui.sensor.config.Accelerometer',
+  );
+  static const sensorRateAccelerometer = ValueKey<String>(
+    'ui.sensor.rate.Accelerometer',
+  );
+  static const sensorConfigClose = ValueKey<String>(
+    'ui.sensor.config.close',
+  );
+  static const sensorApply = ValueKey<String>('ui.sensor.apply');
+  static const recorderStartStop = ValueKey<String>(
+    'ui.recorder.startStop',
+  );
+  static const recorderLatestFolder = ValueKey<String>(
+    'ui.recorder.latestFolder',
+  );
+  static const recorderDeleteLatest = ValueKey<String>(
+    'ui.recorder.deleteLatest',
+  );
+  static const recorderConfirmDelete = ValueKey<String>(
+    'ui.recorder.confirmDelete',
+  );
+  static const settingsGeneral = ValueKey<String>('ui.settings.general');
+  static const settingsKeepScreenAwake = ValueKey<String>(
+    'ui.settings.keepScreenAwake',
+  );
+  static const settingsAutoConnect = ValueKey<String>(
+    'ui.settings.autoConnect',
+  );
+  static const settingsDisableSensorsOnClose = ValueKey<String>(
+    'ui.settings.disableSensorsOnClose',
+  );
+  static const settingsDisableLiveGraphs = ValueKey<String>(
+    'ui.settings.disableLiveGraphs',
+  );
+  static const settingsHideEmptyGraphs = ValueKey<String>(
+    'ui.settings.hideEmptyGraphs',
+  );
+  static const settingsShowSamplingRates = ValueKey<String>(
+    'ui.settings.showSamplingRates',
+  );
+
+  static ValueKey<String> scannedDevice(String deviceId) =>
+      ValueKey<String>('ui.scan.device.$deviceId');
+  static ValueKey<String> connectedDevice(String deviceId) =>
+      ValueKey<String>('ui.devices.device.$deviceId');
+  static ValueKey<String> deviceDetails(String deviceId) =>
+      ValueKey<String>('ui.device.details.$deviceId');
+  static ValueKey<String> sensorConfig(String configurationName) =>
+      ValueKey<String>('ui.sensor.config.$configurationName');
+  static ValueKey<String> sensorRate(String configurationName) =>
+      ValueKey<String>('ui.sensor.rate.$configurationName');
+  static ValueKey<String> sensorStreamTarget(String configurationName) =>
+      ValueKey<String>('ui.sensor.target.$configurationName.stream');
+  static ValueKey<String> sensorRecordTarget(String configurationName) =>
+      ValueKey<String>('ui.sensor.target.$configurationName.record');
+  static ValueKey<String> recordedFile(String fileName) =>
+      ValueKey<String>('ui.recorder.file.$fileName');
+  static ValueKey<String> combinedPair(String pairKey) =>
+      ValueKey<String>('ui.devices.pair.$pairKey');
+  static ValueKey<String> combinedPairToggle(String pairKey) =>
+      ValueKey<String>('ui.devices.pair.combine.$pairKey');
+  static ValueKey<String> splitPairToggle(String pairKey, String deviceId) =>
+      ValueKey<String>('ui.devices.pair.combine.$pairKey.$deviceId');
+  static const deviceDisconnect = ValueKey<String>('ui.device.disconnect');
+}
+
+/// Mounts the same root widget and production services used by [app.main].
+Future<void> startProductionApp(PatrolIntegrationTester $) async {
+  await $.pumpWidget(await app.createApp());
+}
+
+/// Completes first-run onboarding through its visible skip action.
+Future<void> skipFirstRunPermissions(PatrolIntegrationTester $) async {
+  await $(UiTestKeys.onboardingGetStarted).waitUntilVisible(
+    timeout: const Duration(seconds: 30),
+  );
+  await $(UiTestKeys.onboardingGetStarted).tap();
+  await $(UiTestKeys.onboardingSkipBluetooth).tap();
+  await _closeUpgradeHighlightIfShown($);
+  await waitForHome($);
+}
+
+/// Grants Android permission dialogs as a user would during first-run setup.
+Future<void> grantFirstRunPermissions(PatrolIntegrationTester $) async {
+  await $.platform.mobile.enableBluetooth();
+  await $.platform.android.enableLocation();
+
+  await $(UiTestKeys.onboardingGetStarted).waitUntilVisible(
+    timeout: const Duration(seconds: 30),
+  );
+  await $(UiTestKeys.onboardingGetStarted).tap();
+  await $(UiTestKeys.onboardingBluetooth).tap();
+  await grantVisibleAndroidPermissionDialogs($);
+
+  await $(UiTestKeys.onboardingMicrophone).waitUntilVisible(
+    timeout: const Duration(seconds: 20),
+  );
+  await $(UiTestKeys.onboardingMicrophone).tap();
+  await grantVisibleAndroidPermissionDialogs($);
+
+  await _closeUpgradeHighlightIfShown($);
+  await waitForHome($);
+}
+
+/// Grants Bluetooth/location during onboarding but deliberately skips audio.
+Future<void> grantBluetoothAndSkipMicrophone(
+  PatrolIntegrationTester $,
+) async {
+  await $.platform.mobile.enableBluetooth();
+  await $.platform.android.enableLocation();
+
+  await $(UiTestKeys.onboardingGetStarted).waitUntilVisible(
+    timeout: const Duration(seconds: 30),
+  );
+  await $(UiTestKeys.onboardingGetStarted).tap();
+  await $(UiTestKeys.onboardingBluetooth).tap();
+  await grantVisibleAndroidPermissionDialogs($);
+
+  await $(UiTestKeys.onboardingSkipMicrophone).waitUntilVisible(
+    timeout: const Duration(seconds: 20),
+  );
+  await $(UiTestKeys.onboardingSkipMicrophone).tap();
+
+  await _closeUpgradeHighlightIfShown($);
+  await waitForHome($);
+}
+
+Future<void> waitForHome(PatrolIntegrationTester $) async {
+  await $(UiTestKeys.navOverview).waitUntilVisible(
+    timeout: const Duration(seconds: 30),
+  );
+}
+
+/// Starts a fresh BLE scan without waiting for the timed scan spinner to stop.
+Future<void> startBleScan(PatrolIntegrationTester $) async {
+  await $(UiTestKeys.scanStart).waitUntilVisible();
+  await $(UiTestKeys.scanStart).tap(
+    settlePolicy: SettlePolicy.noSettle,
+  );
+}
+
+/// Dismisses a background firmware notice that can arrive after BLE connects.
+Future<void> dismissFirmwareUpdateNoticeIfShown(
+  PatrolIntegrationTester $,
+) async {
+  final later = $(UiTestKeys.firmwareUpdateLater);
+  if (later.visible) {
+    await later.tap();
+    await $.pump(const Duration(milliseconds: 250));
+  }
+}
+
+/// Connects the phone itself through the same visible discovery row a user taps.
+Future<void> connectThisDevice(PatrolIntegrationTester $) async {
+  await $(UiTestKeys.navDevices).tap();
+  await $(UiTestKeys.devicesConnect).waitUntilVisible();
+  await $(UiTestKeys.devicesConnect).tap();
+  await $(UiTestKeys.scanThisDevice).waitUntilVisible(
+    timeout: const Duration(seconds: 15),
+  );
+  await $(UiTestKeys.scanThisDevice).tap();
+  await $(UiTestKeys.connectedThisDevice).waitUntilVisible(
+    timeout: const Duration(seconds: 20),
+  );
+}
+
+Future<void> _closeUpgradeHighlightIfShown(
+  PatrolIntegrationTester $,
+) async {
+  final deadline = DateTime.now().add(const Duration(seconds: 30));
+  while (DateTime.now().isBefore(deadline)) {
+    await $.pump(const Duration(milliseconds: 100));
+
+    if ($(UiTestKeys.permissionRequiredCancel).visible) {
+      await $(UiTestKeys.permissionRequiredCancel).tap();
+      continue;
+    }
+    if ($(UiTestKeys.upgradeClose).visible) {
+      await $(UiTestKeys.upgradeClose).tap();
+      continue;
+    }
+    if ($(UiTestKeys.navOverview).visible) {
+      // Auto-connect performs its permission check asynchronously. Give that
+      // check a moment to surface before treating the home screen as ready.
+      await $.pump(const Duration(milliseconds: 500));
+      if (!$(UiTestKeys.permissionRequiredCancel).visible &&
+          !$(UiTestKeys.upgradeClose).visible) {
+        return;
+      }
+    }
+  }
+
+  throw TestFailure(
+    'The first-run overlays did not settle within 30 seconds.',
+  );
+}
+
+Future<void> grantVisibleAndroidPermissionDialogs(
+  PatrolIntegrationTester $,
+) async {
+  for (var index = 0; index < 4; index++) {
+    final isVisible = await $.platform.android.isPermissionDialogVisible(
+      timeout: const Duration(seconds: 2),
+    );
+    if (!isVisible) {
+      return;
+    }
+
+    try {
+      await $.platform.android.grantPermissionWhenInUse();
+    } catch (_) {
+      await $.platform.android.allowPermission();
+    }
+    await $.pump(const Duration(milliseconds: 250));
+  }
+
+  if (await $.platform.android.isPermissionDialogVisible()) {
+    throw TestFailure(
+      'Android permission dialogs did not finish after 4 grants.',
+    );
+  }
+}
diff --git a/open_wearable/patrol_test/support/open_earable_pair_driver.dart b/open_wearable/patrol_test/support/open_earable_pair_driver.dart
new file mode 100644
index 000000000..e25596a6a
--- /dev/null
+++ b/open_wearable/patrol_test/support/open_earable_pair_driver.dart
@@ -0,0 +1,223 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:open_wearable/models/wearable_display_group.dart';
+import 'package:patrol/patrol.dart';
+
+import 'app_driver.dart';
+
+/// The two runtime Bluetooth IDs discovered for a stereo OpenEarable pair.
+class ConnectedOpenEarablePair {
+  const ConnectedOpenEarablePair({
+    required this.deviceIds,
+    required this.pairKey,
+  });
+
+  final List<String> deviceIds;
+  final String pairKey;
+}
+
+/// Discovers exactly two filtered OpenEarables and connects both of them.
+///
+/// Bluetooth IDs are intentionally discovered at runtime because Android can
+/// expose rotating addresses for these devices.
+Future<ConnectedOpenEarablePair> connectExactlyTwoOpenEarables(
+  PatrolIntegrationTester $,
+) async {
+  await $(UiTestKeys.navDevices).tap();
+  await $(UiTestKeys.devicesConnect).waitUntilVisible();
+  await $(UiTestKeys.devicesConnect).tap();
+  await $(UiTestKeys.scanOpenEarableFilter).waitUntilVisible();
+  await $(UiTestKeys.scanOpenEarableFilter).tap();
+
+  final deviceIds = await _discoverExactlyTwoOpenEarables($);
+  final pairKey = WearableDisplayGroup.stereoPairKeyForIds(
+    deviceIds[0],
+    deviceIds[1],
+  );
+  final pair = ConnectedOpenEarablePair(
+    deviceIds: List.unmodifiable(deviceIds),
+    pairKey: pairKey,
+  );
+
+  try {
+    for (final deviceId in deviceIds) {
+      debugPrint('PAIR_RUNTIME_DEVICE id="$deviceId"');
+      await _connectExactDevice($, deviceId);
+    }
+  } catch (_) {
+    // Do not leave a half-connected fixture behind when an app overlay or
+    // transient BLE issue interrupts the user journey.
+    await cleanupConnectedPair($, pair);
+    rethrow;
+  }
+
+  await openMainDevicesPage($);
+  await $(UiTestKeys.combinedPair(pair.pairKey)).waitUntilVisible(
+    timeout: const Duration(seconds: 45),
+  );
+
+  return pair;
+}
+
+Future<void> openMainDevicesPage(PatrolIntegrationTester $) async {
+  if ($(UiTestKeys.devicesConnect).visible) {
+    return;
+  }
+  await $.platform.android.pressBack();
+  await $(UiTestKeys.devicesConnect).waitUntilVisible(
+    timeout: const Duration(seconds: 20),
+  );
+}
+
+/// Splits a combined pair if necessary and disconnects both exact devices.
+Future<void> cleanupConnectedPair(
+  PatrolIntegrationTester $,
+  ConnectedOpenEarablePair pair,
+) async {
+  await dismissFirmwareUpdateNoticeIfShown($);
+  await $(UiTestKeys.navDevices).tap();
+  await openMainDevicesPage($);
+
+  final combinedPair = $(UiTestKeys.combinedPair(pair.pairKey));
+  if (combinedPair.visible) {
+    await $(UiTestKeys.combinedPairToggle(pair.pairKey)).tap();
+    await $(UiTestKeys.connectedDevice(pair.deviceIds.first)).waitUntilVisible(
+      timeout: const Duration(seconds: 20),
+    );
+  }
+
+  for (final deviceId in pair.deviceIds) {
+    await dismissFirmwareUpdateNoticeIfShown($);
+    if ($(UiTestKeys.connectedDevice(deviceId)).visible) {
+      await _disconnectExactDevice($, deviceId);
+    }
+  }
+}
+
+String sideForDevice(PatrolIntegrationTester $, String deviceId) {
+  final rowKey = UiTestKeys.connectedDevice(deviceId);
+  final hasLeft = $.tester.any(descendantText(rowKey, 'L'));
+  final hasRight = $.tester.any(descendantText(rowKey, 'R'));
+  expect(hasLeft || hasRight, isTrue, reason: '$deviceId has no side label.');
+  expect(
+    hasLeft && hasRight,
+    isFalse,
+    reason: '$deviceId has both side labels.',
+  );
+  return hasLeft ? 'L' : 'R';
+}
+
+Finder descendantText(Key parentKey, String text) => find.descendant(
+      of: find.byKey(parentKey),
+      matching: find.text(text),
+    );
+
+Future<List<String>> _discoverExactlyTwoOpenEarables(
+  PatrolIntegrationTester $,
+) async {
+  for (var attempt = 1; attempt <= 3; attempt++) {
+    await startBleScan($);
+    await $.pump(const Duration(seconds: 9));
+
+    final ids = _visibleFilteredDeviceIds();
+    if (ids.length == 2) {
+      return ids;
+    }
+    if (ids.length > 2) {
+      throw TestFailure(
+        'Expected exactly two filtered OpenEarables, but found ${ids.length}: '
+        '${ids.join(', ')}. Refusing to choose a device ambiguously.',
+      );
+    }
+  }
+
+  throw TestFailure(
+    'Expected exactly two advertising OpenEarables after three scans.',
+  );
+}
+
+List<String> _visibleFilteredDeviceIds() {
+  final rows = find.byWidgetPredicate((widget) {
+    final key = widget.key;
+    return key is ValueKey<String> && key.value.startsWith('ui.scan.device.');
+  });
+
+  return rows
+      .evaluate()
+      .map((element) => element.widget.key)
+      .whereType<ValueKey<String>>()
+      .map((key) => key.value.substring('ui.scan.device.'.length))
+      .toSet()
+      .toList(growable: false);
+}
+
+Future<void> _connectExactDevice(
+  PatrolIntegrationTester $,
+  String deviceId,
+) async {
+  await dismissFirmwareUpdateNoticeIfShown($);
+  final discovered = $(UiTestKeys.scannedDevice(deviceId));
+  if (discovered.visible) {
+    await _tapDiscoveredAndWaitForConnection($, discovered, deviceId);
+    return;
+  }
+
+  for (var attempt = 1; attempt <= 3; attempt++) {
+    await startBleScan($);
+    final deadline = DateTime.now().add(const Duration(seconds: 12));
+    while (DateTime.now().isBefore(deadline)) {
+      if (discovered.visible) {
+        await _tapDiscoveredAndWaitForConnection($, discovered, deviceId);
+        return;
+      }
+      await $.pump(const Duration(milliseconds: 250));
+    }
+  }
+
+  throw TestFailure(
+    'OpenEarable $deviceId was not discovered in three BLE scans.',
+  );
+}
+
+Future<void> _tapDiscoveredAndWaitForConnection(
+  PatrolIntegrationTester $,
+  PatrolFinder discovered,
+  String deviceId,
+) async {
+  await discovered.tap();
+  final connected = $(UiTestKeys.connectedDevice(deviceId));
+  final deadline = DateTime.now().add(const Duration(seconds: 60));
+  while (DateTime.now().isBefore(deadline)) {
+    await dismissFirmwareUpdateNoticeIfShown($);
+    if (connected.visible) return;
+    await $.pump(const Duration(milliseconds: 250));
+  }
+  throw TestFailure(
+    'OpenEarable $deviceId did not become visible as connected within 60 seconds.',
+  );
+}
+
+Future<void> _disconnectExactDevice(
+  PatrolIntegrationTester $,
+  String deviceId,
+) async {
+  await $(UiTestKeys.connectedDevice(deviceId)).tap();
+  await $(UiTestKeys.deviceDetails(deviceId)).waitUntilVisible();
+  await $(UiTestKeys.deviceDisconnect).scrollTo();
+  await $(UiTestKeys.deviceDisconnect).tap();
+  await _waitUntilAbsent($, UiTestKeys.connectedDevice(deviceId));
+}
+
+Future<void> _waitUntilAbsent(
+  PatrolIntegrationTester $,
+  Key key,
+) async {
+  final deadline = DateTime.now().add(const Duration(seconds: 45));
+  while (DateTime.now().isBefore(deadline)) {
+    if (!$.tester.any(find.byKey(key))) {
+      return;
+    }
+    await $.pump(const Duration(milliseconds: 250));
+  }
+  throw TestFailure('Widget with key $key did not disappear after disconnect.');
+}
diff --git a/open_wearable/patrol_test/this_device_connection_test.dart b/open_wearable/patrol_test/this_device_connection_test.dart
new file mode 100644
index 000000000..29a87924e
--- /dev/null
+++ b/open_wearable/patrol_test/this_device_connection_test.dart
@@ -0,0 +1,42 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:patrol/patrol.dart';
+
+import 'support/app_driver.dart';
+
+void main() {
+  patrolTest(
+    'CON-13: connect, inspect, and disconnect the phone as a sensor device',
+    ($) async {
+      await startProductionApp($);
+      await grantFirstRunPermissions($);
+
+      await connectThisDevice($);
+      expect(
+        find.textContaining('(this device)').hitTestable(),
+        findsNothing,
+      );
+      expect($(UiTestKeys.scanThisDevice), findsNothing);
+
+      await $.tester.pageBack();
+      await $(UiTestKeys.connectedThisDevice).waitUntilVisible();
+
+      await $(UiTestKeys.navOverview).tap();
+      await $('Connected Devices (1)').waitUntilVisible();
+      expect($('No devices connected.'), findsNothing);
+
+      await $(UiTestKeys.navDevices).tap();
+      await $(UiTestKeys.connectedThisDevice).tap();
+      await $(UiTestKeys.deviceDisconnect).waitUntilVisible();
+      await $(UiTestKeys.deviceDisconnect).scrollTo();
+      await $(UiTestKeys.deviceDisconnect).tap();
+
+      await $(UiTestKeys.devicesConnect).waitUntilVisible(
+        timeout: const Duration(seconds: 10),
+      );
+      expect($(UiTestKeys.connectedThisDevice), findsNothing);
+    },
+    // This journey asserts the Flutter widget tree directly. The production
+    // phone-device flow can leave Patrol's semantics handle active on Android.
+    semanticsEnabled: false,
+  );
+}
diff --git a/open_wearable/patrol_test/this_device_recording_test.dart b/open_wearable/patrol_test/this_device_recording_test.dart
new file mode 100644
index 000000000..ef99265dc
--- /dev/null
+++ b/open_wearable/patrol_test/this_device_recording_test.dart
@@ -0,0 +1,97 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:patrol/patrol.dart';
+
+import 'support/app_driver.dart';
+
+void main() {
+  patrolTest(
+    'CFG-02 CFG-03 LIVE-01 REC-02 REC-08(partial): phone sensor data loop',
+    ($) async {
+      await startProductionApp($);
+      await grantFirstRunPermissions($);
+      await connectThisDevice($);
+
+      await $.tester.pageBack();
+      await $(UiTestKeys.navSensors).tap();
+      await $(UiTestKeys.sensorConfigAccelerometer).waitUntilVisible(
+        timeout: const Duration(seconds: 15),
+      );
+      await $(UiTestKeys.sensorConfigAccelerometer).tap();
+
+      await $(UiTestKeys.sensorRateAccelerometer).waitUntilVisible();
+      await $(UiTestKeys.sensorRateAccelerometer).tap();
+      await $('5.00 Hz').waitUntilVisible();
+      await $('5.00 Hz').tap();
+      await $(UiTestKeys.sensorConfigClose).tap();
+
+      await $(UiTestKeys.sensorApply).scrollTo();
+      await $(UiTestKeys.sensorApply).tap();
+      await $('Accelerometer').waitUntilVisible(
+        timeout: const Duration(seconds: 10),
+      );
+      expect($('Waiting for live sensor data'), findsNothing);
+
+      await $(const ValueKey<String>('ui.sensors.recording')).tap();
+      await $(UiTestKeys.recorderStartStop).waitUntilVisible();
+      final recorderButton = find.byKey(UiTestKeys.recorderStartStop);
+      expect(
+        $.tester.widget<FilledButton>(recorderButton).onPressed,
+        isNotNull,
+      );
+
+      await $(UiTestKeys.recorderStartStop).tap();
+      await $('Recording in progress').waitUntilVisible();
+      await $.pump(const Duration(seconds: 2));
+      await $(UiTestKeys.recorderStartStop).tap();
+      await $('Ready to record').waitUntilVisible(
+        timeout: const Duration(seconds: 10),
+      );
+
+      await $(UiTestKeys.recorderLatestFolder).scrollTo();
+      await $(UiTestKeys.recorderLatestFolder).tap();
+      await _waitForCsvFile($);
+      _expectRecordedCsvHasContent($);
+
+      await $(UiTestKeys.recorderDeleteLatest).tap();
+      await $(UiTestKeys.recorderConfirmDelete).waitUntilVisible();
+      await $(UiTestKeys.recorderConfirmDelete).tap();
+      await $('No recordings yet').waitUntilVisible();
+
+      await $(UiTestKeys.navDevices).tap();
+      await $(UiTestKeys.connectedThisDevice).tap();
+      await $(UiTestKeys.deviceDisconnect).scrollTo();
+      await $(UiTestKeys.deviceDisconnect).tap();
+      await $(UiTestKeys.devicesConnect).waitUntilVisible();
+    },
+    // This journey asserts Flutter widgets directly; it does not need Android
+    // semantics, which can remain active after the phone-device flow.
+    semanticsEnabled: false,
+  );
+}
+
+void _expectRecordedCsvHasContent(PatrolIntegrationTester $) {
+  final nonEmptyFileSize = find
+      .byWidgetPredicate(
+        (widget) =>
+            widget is Text &&
+            widget.data != null &&
+            RegExp(
+              r'^(?:[1-9][0-9]* B|[0-9]+\.[0-9]+ (?:KB|MB))$',
+            ).hasMatch(widget.data!),
+      )
+      .hitTestable();
+  expect(nonEmptyFileSize, findsAtLeastNWidgets(1));
+  expect(find.text('0 B').hitTestable(), findsNothing);
+}
+
+Future<void> _waitForCsvFile(PatrolIntegrationTester $) async {
+  final deadline = DateTime.now().add(const Duration(seconds: 10));
+  while (DateTime.now().isBefore(deadline)) {
+    await $.pump(const Duration(milliseconds: 100));
+    if (find.textContaining('.csv').hitTestable().evaluate().isNotEmpty) {
+      return;
+    }
+  }
+  throw TestFailure('The completed recording did not expose a CSV file.');
+}
diff --git a/open_wearable/pubspec.lock b/open_wearable/pubspec.lock
index c42d3920e..44529b8ba 100644
--- a/open_wearable/pubspec.lock
+++ b/open_wearable/pubspec.lock
@@ -217,6 +217,14 @@ packages:
       url: "https://pub.dev"
     source: hosted
     version: "8.1.0"
+  dispose_scope:
+    dependency: transitive
+    description:
+      name: dispose_scope
+      sha256: "48ec38ca2631c53c4f8fa96b294c801e55c335db5e3fb9f82cede150cfe5a2af"
+      url: "https://pub.dev"
+    source: hosted
+    version: "2.1.0"
   equatable:
     dependency: transitive
     description:
@@ -424,6 +432,14 @@ packages:
       url: "https://pub.dev"
     source: hosted
     version: "1.6.0"
+  http_multi_server:
+    dependency: transitive
+    description:
+      name: http_multi_server
+      sha256: aa6199f908078bb1c5efb8d8638d4ae191aac11b311132c3ef48ce352fb52ef8
+      url: "https://pub.dev"
+    source: hosted
+    version: "3.2.2"
   http_parser:
     dependency: transitive
     description:
@@ -524,10 +540,10 @@ packages:
     dependency: transitive
     description:
       name: matcher
-      sha256: "31bd099b47c10cd1aeb55146a2d46ce0277630ecef3f7dae54ad7873f36696cd"
+      sha256: dc0b7dc7651697ea4ff3e69ef44b0407ea32c487a39fff6a4004fa585e901861
       url: "https://pub.dev"
     source: hosted
-    version: "0.12.20"
+    version: "0.12.19"
   material_color_utilities:
     dependency: transitive
     description:
@@ -549,10 +565,10 @@ packages:
     dependency: transitive
     description:
       name: meta
-      sha256: "307249ce4ff29d58a18e97f6345f539382eb9c9c29ecda628900f31de0443dd9"
+      sha256: "1741988757a65eb6b36abe716829688cf01910bbf91c34354ff7ec1c3de2b349"
       url: "https://pub.dev"
     source: hosted
-    version: "1.19.0"
+    version: "1.18.0"
   mime:
     dependency: transitive
     description:
@@ -745,6 +761,30 @@ packages:
       url: "https://pub.dev"
     source: hosted
     version: "2.3.0"
+  patrol:
+    dependency: "direct dev"
+    description:
+      name: patrol
+      sha256: "662c50d517b2f159fedbc359a7fb8d0d30cbefea6d5c2a08392a0593079d64d1"
+      url: "https://pub.dev"
+    source: hosted
+    version: "4.10.0"
+  patrol_finders:
+    dependency: transitive
+    description:
+      name: patrol_finders
+      sha256: "8608cdacaab90a3b00ecd7b09df11f13a62b01dea13c211b9f13fd86854e103a"
+      url: "https://pub.dev"
+    source: hosted
+    version: "3.6.0"
+  patrol_log:
+    dependency: transitive
+    description:
+      name: patrol_log
+      sha256: "3d91c93e8d0ed19cb12d4b27aa24eca7294e0a48d9d8445505c9775feb5fde2d"
+      url: "https://pub.dev"
+    source: hosted
+    version: "0.10.1"
   permission_handler:
     dependency: "direct main"
     description:
@@ -1017,6 +1057,14 @@ packages:
       url: "https://pub.dev"
     source: hosted
     version: "2.4.1"
+  shelf:
+    dependency: transitive
+    description:
+      name: shelf
+      sha256: e7dd780a7ffb623c57850b33f43309312fc863fb6aa3d276a754bb299839ef12
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.4.2"
   sky_engine:
     dependency: transitive
     description: flutter
@@ -1074,10 +1122,10 @@ packages:
     dependency: transitive
     description:
       name: test_api
-      sha256: "2a122cbe059f8b610d3a5415f42e255b6c17b1f21eee1d960f31080237fb4f11"
+      sha256: "949a932224383300f01be9221c39180316445ecb8e7547f70a41a35bf421fb9e"
       url: "https://pub.dev"
     source: hosted
-    version: "0.7.12"
+    version: "0.7.11"
   tuple:
     dependency: transitive
     description:
@@ -1203,10 +1251,10 @@ packages:
     dependency: transitive
     description:
       name: vector_math
-      sha256: "92b9910f66ed1057fd4da7b040ae7c74cafacf885bdc81be496928d5049b032d"
+      sha256: d530bd74fea330e6e364cda7a85019c434070188383e1cd8d9777ee586914c5b
       url: "https://pub.dev"
     source: hosted
-    version: "2.4.3"
+    version: "2.2.0"
   vm_service:
     dependency: transitive
     description:
diff --git a/open_wearable/pubspec.yaml b/open_wearable/pubspec.yaml
index bf476f350..0c91c7c39 100644
--- a/open_wearable/pubspec.yaml
+++ b/open_wearable/pubspec.yaml
@@ -68,6 +68,7 @@ dependencies:
 dev_dependencies:
   flutter_test:
     sdk: flutter
+  patrol: 4.10.0
 
   # The "flutter_lints" package below contains a set of recommended lints to
   # encourage good coding practices. The lint set provided by the package is
@@ -89,6 +90,15 @@ dependency_overrides:
       url: https://github.com/TobiasRoeddiger/Flutter-nRF-Connect-Device-Manager.git
       ref: 93f17ded1fc2462a2cbcaa21ece781399253bf4a
 
+# Android Patrol runs use the isolated debug application ID configured in
+# android/app/build.gradle. The regular release app keeps its production ID.
+patrol:
+  app_name: OpenWearables Test
+  test_directory: patrol_test
+  screenshot_on_failure: true
+  android:
+    package_name: edu.kit.teco.openWearable.patrol
+
 # For information on the generic Dart part of this file, see the
 # following page: https://dart.dev/tools/pub/pubspec
 
diff --git a/open_wearable/tool/ui_tests/build_android.ps1 b/open_wearable/tool/ui_tests/build_android.ps1
new file mode 100644
index 000000000..a134827f7
--- /dev/null
+++ b/open_wearable/tool/ui_tests/build_android.ps1
@@ -0,0 +1,164 @@
+[CmdletBinding()]
+param(
+    [ValidateSet('Navigation', 'Permissions', 'PermissionRecovery', 'Overview', 'Settings', 'ThisDevice', 'ThisDeviceData', 'PairDiscovery', 'PairHardware', 'PairSampleRate', 'Hardware')]
+    [string] $Suite = 'Navigation',
+
+    [string] $OpenEarableDeviceId,
+
+    [double[]] $SampleRatesHz = @(25),
+
+    [ValidateRange(5, 600)]
+    [int] $SampleDurationSeconds = 12,
+
+    [ValidateRange(0.1, 99.9)]
+    [double] $SampleTolerancePercent = 15,
+
+    [switch] $ListSuites
+)
+
+Set-StrictMode -Version Latest
+$ErrorActionPreference = 'Stop'
+
+$suiteDescriptions = [ordered]@{
+    Navigation         = 'Open every main tab and verify the empty states and Settings entry.'
+    Permissions        = 'Complete first-run Android Bluetooth and microphone permissions.'
+    PermissionRecovery = 'Recover after microphone permission was skipped during onboarding.'
+    Overview           = 'Check every Overview shortcut reaches its intended screen.'
+    Settings           = 'Toggle, reopen, verify, and restore all six General settings.'
+    ThisDevice         = 'Connect the phone as a sensor device, inspect details, and disconnect.'
+    ThisDeviceData     = 'Set phone Accelerometer to 5 Hz, stream, record CSV, and delete it.'
+    PairDiscovery      = 'Exercise the OpenEarable-only scan filter without connecting hardware.'
+    PairHardware       = 'Discover two OpenEarables, connect, verify L/R pair, split/recombine, and disconnect.'
+    PairSampleRate     = 'For two OpenEarables, set requested IMU rate(s) and verify received L/R CSV rates; live graph labels are not asserted.'
+    Hardware           = 'Connect one exact Bluetooth device ID, inspect it, and disconnect.'
+}
+
+if ($ListSuites) {
+    $suiteDescriptions.GetEnumerator() | ForEach-Object {
+        [PSCustomObject]@{ Suite = $_.Key; Checks = $_.Value }
+    } | Format-Table -AutoSize -Wrap
+    return
+}
+
+function Resolve-PatrolExecutable {
+    param([string] $ProjectRoot)
+
+    $command = Get-Command patrol -ErrorAction SilentlyContinue
+    if ($null -ne $command) {
+        return $command.Source
+    }
+
+    $candidates = @(
+        (Join-Path $ProjectRoot '..\..\.pub-cache\bin\patrol.bat'),
+        (Join-Path $env:LOCALAPPDATA 'Pub\Cache\bin\patrol.bat')
+    )
+    if (-not [string]::IsNullOrWhiteSpace($env:PUB_CACHE)) {
+        $candidates = @((Join-Path $env:PUB_CACHE 'bin\patrol.bat')) + $candidates
+    }
+
+    foreach ($candidate in $candidates) {
+        if (Test-Path -LiteralPath $candidate) {
+            return (Resolve-Path -LiteralPath $candidate).Path
+        }
+    }
+
+    throw 'Patrol CLI 4.8.0 is required. Run: dart pub global activate patrol_cli 4.8.0'
+}
+
+function Initialize-AndroidSdkEnvironment {
+    param([string] $ProjectRoot)
+
+    if ([string]::IsNullOrWhiteSpace($env:ANDROID_HOME)) {
+        $propertiesPath = Join-Path $ProjectRoot 'android\local.properties'
+        if (Test-Path -LiteralPath $propertiesPath) {
+            $sdkLine = Get-Content -LiteralPath $propertiesPath |
+                Where-Object { $_ -match '^sdk\.dir=' } |
+                Select-Object -First 1
+            if ($null -ne $sdkLine) {
+                $env:ANDROID_HOME = $sdkLine.Substring('sdk.dir='.Length).Replace('\\', '\')
+            }
+        }
+    }
+
+    if ([string]::IsNullOrWhiteSpace($env:ANDROID_HOME) -or
+        -not (Test-Path -LiteralPath $env:ANDROID_HOME)) {
+        throw 'Android SDK was not found. Set ANDROID_HOME or run flutter pub get to generate android/local.properties.'
+    }
+
+    $env:ANDROID_SDK_ROOT = $env:ANDROID_HOME
+    $platformTools = Join-Path $env:ANDROID_HOME 'platform-tools'
+    if (Test-Path -LiteralPath $platformTools) {
+        $env:Path = "$platformTools;$env:Path"
+    }
+
+    # Pub-generated Windows launchers call `dart` by name. Put dart.exe ahead
+    # of Flutter's extensionless Unix launcher so patrol.bat is reliable.
+    $propertiesPath = Join-Path $ProjectRoot 'android\local.properties'
+    if (Test-Path -LiteralPath $propertiesPath) {
+        $flutterLine = Get-Content -LiteralPath $propertiesPath |
+            Where-Object { $_ -match '^flutter\.sdk=' } |
+            Select-Object -First 1
+        if ($null -ne $flutterLine) {
+            $flutterSdk = $flutterLine.Substring('flutter.sdk='.Length).Replace('\\', '\')
+            $dartSdkBin = Join-Path $flutterSdk 'bin\cache\dart-sdk\bin'
+            if (Test-Path -LiteralPath $dartSdkBin) {
+                $env:Path = "$dartSdkBin;$env:Path"
+            }
+        }
+    }
+}
+
+if ($Suite -eq 'Hardware' -and [string]::IsNullOrWhiteSpace($OpenEarableDeviceId)) {
+    throw 'Hardware builds require -OpenEarableDeviceId with the exact Android Bluetooth device ID.'
+}
+if ($Suite -eq 'PairSampleRate' -and
+    ($SampleRatesHz.Count -eq 0 -or @($SampleRatesHz | Where-Object { $_ -le 0 }).Count -gt 0)) {
+    throw 'PairSampleRate requires one or more positive -SampleRatesHz values.'
+}
+
+$projectRoot = (Resolve-Path -LiteralPath (Join-Path $PSScriptRoot '..\..')).Path
+$workspacePubCache = Join-Path $projectRoot '..\..\.pub-cache'
+if (Test-Path -LiteralPath $workspacePubCache) {
+    $env:PUB_CACHE = (Resolve-Path -LiteralPath $workspacePubCache).Path
+}
+$patrolExecutable = Resolve-PatrolExecutable -ProjectRoot $projectRoot
+Initialize-AndroidSdkEnvironment -ProjectRoot $projectRoot
+$target = switch ($Suite) {
+    'Hardware' { 'patrol_test/open_earable_connection_test.dart' }
+    'Permissions' { 'patrol_test/onboarding_permissions_test.dart' }
+    'PermissionRecovery' { 'patrol_test/late_microphone_permission_test.dart' }
+    'Overview' { 'patrol_test/overview_shortcuts_test.dart' }
+    'Settings' { 'patrol_test/general_settings_test.dart' }
+    'ThisDevice' { 'patrol_test/this_device_connection_test.dart' }
+    'ThisDeviceData' { 'patrol_test/this_device_recording_test.dart' }
+    'PairDiscovery' { 'patrol_test/pair_discovery_test.dart' }
+    'PairHardware' { 'patrol_test/open_earable_pair_test.dart' }
+    'PairSampleRate' { 'patrol_test/open_earable_pair_sample_rate_test.dart' }
+    default { 'patrol_test/navigation_and_settings_test.dart' }
+}
+
+$patrolArguments = @('build', 'android', '--debug', '--target', $target)
+if ($Suite -eq 'Hardware') {
+    $patrolArguments += "--dart-define=OPENEARABLE_DEVICE_ID=$OpenEarableDeviceId"
+}
+if ($Suite -eq 'PairSampleRate') {
+    $invariantRates = ($SampleRatesHz | ForEach-Object {
+        $_.ToString([Globalization.CultureInfo]::InvariantCulture)
+    }) -join ','
+    $invariantTolerance = $SampleTolerancePercent.ToString(
+        [Globalization.CultureInfo]::InvariantCulture
+    )
+    $patrolArguments += "--dart-define=OPENEARABLE_SAMPLE_RATES_HZ=$invariantRates"
+    $patrolArguments += "--dart-define=OPENEARABLE_SAMPLE_DURATION_SECONDS=$SampleDurationSeconds"
+    $patrolArguments += "--dart-define=OPENEARABLE_SAMPLE_TOLERANCE_PERCENT=$invariantTolerance"
+}
+
+Push-Location -LiteralPath $projectRoot
+try {
+    & $patrolExecutable @patrolArguments
+    if ($LASTEXITCODE -ne 0) {
+        throw "Patrol Android build failed with exit code $LASTEXITCODE."
+    }
+} finally {
+    Pop-Location
+}
diff --git a/open_wearable/tool/ui_tests/choose_android_test.ps1 b/open_wearable/tool/ui_tests/choose_android_test.ps1
new file mode 100644
index 000000000..b3ec5ef3d
--- /dev/null
+++ b/open_wearable/tool/ui_tests/choose_android_test.ps1
@@ -0,0 +1,85 @@
+[CmdletBinding()]
+param(
+    [string] $AndroidDevice
+)
+
+Set-StrictMode -Version Latest
+$ErrorActionPreference = 'Stop'
+
+$choices = @(
+    [PSCustomObject]@{ Suite = 'Navigation';         Description = 'Main navigation and empty states' }
+    [PSCustomObject]@{ Suite = 'Permissions';        Description = 'First-run Android permissions' }
+    [PSCustomObject]@{ Suite = 'PermissionRecovery'; Description = 'Skipped microphone permission recovery' }
+    [PSCustomObject]@{ Suite = 'Overview';           Description = 'Overview shortcuts' }
+    [PSCustomObject]@{ Suite = 'Settings';           Description = 'All General settings' }
+    [PSCustomObject]@{ Suite = 'ThisDevice';         Description = 'Phone-as-device connection' }
+    [PSCustomObject]@{ Suite = 'ThisDeviceData';     Description = 'Phone sensor stream and recording' }
+    [PSCustomObject]@{ Suite = 'PairDiscovery';      Description = 'OpenEarable scan filtering' }
+    [PSCustomObject]@{ Suite = 'PairHardware';       Description = 'Two-device L/R pairing lifecycle' }
+    [PSCustomObject]@{ Suite = 'PairSampleRate';     Description = 'Two-device requested versus received sample rates' }
+    [PSCustomObject]@{ Suite = 'Hardware';           Description = 'One exact OpenEarable connection' }
+)
+
+Write-Host ''
+Write-Host 'Choose one Patrol test to run:'
+for ($index = 0; $index -lt $choices.Count; $index++) {
+    Write-Host ('  {0,2}. {1,-18} {2}' -f ($index + 1), $choices[$index].Suite, $choices[$index].Description)
+}
+Write-Host '   Q. Quit'
+
+$selection = (Read-Host 'Test number').Trim()
+if ($selection -match '^[qQ]$') {
+    return
+}
+
+$number = 0
+if (-not [int]::TryParse($selection, [ref] $number) -or
+    $number -lt 1 -or
+    $number -gt $choices.Count) {
+    throw "Choose a number from 1 to $($choices.Count), or Q."
+}
+
+$suite = $choices[$number - 1].Suite
+$arguments = @{
+    Suite = $suite
+}
+if (-not [string]::IsNullOrWhiteSpace($AndroidDevice)) {
+    $arguments.AndroidDevice = $AndroidDevice
+}
+
+if ($suite -eq 'Hardware') {
+    $deviceId = (Read-Host 'Exact Android Bluetooth device ID').Trim()
+    if ([string]::IsNullOrWhiteSpace($deviceId)) {
+        throw 'The Hardware test requires a Bluetooth device ID.'
+    }
+    $arguments.OpenEarableDeviceId = $deviceId
+}
+
+if ($suite -eq 'PairSampleRate') {
+    $rateText = (Read-Host 'Sample rates in Hz, comma-separated [25]').Trim()
+    if ([string]::IsNullOrWhiteSpace($rateText)) {
+        $rateText = '25'
+    }
+    try {
+        $arguments.SampleRatesHz = [double[]] ($rateText -split ',' | ForEach-Object {
+            [double]::Parse($_.Trim(), [Globalization.CultureInfo]::InvariantCulture)
+        })
+    } catch {
+        throw 'Sample rates must be numbers separated by commas, for example 25,50,100.'
+    }
+
+    $durationText = (Read-Host 'Recording seconds per rate [12]').Trim()
+    if (-not [string]::IsNullOrWhiteSpace($durationText)) {
+        $arguments.SampleDurationSeconds = [int] $durationText
+    }
+
+    $toleranceText = (Read-Host 'Allowed deviation percent [15]').Trim()
+    if (-not [string]::IsNullOrWhiteSpace($toleranceText)) {
+        $arguments.SampleTolerancePercent = [double]::Parse(
+            $toleranceText,
+            [Globalization.CultureInfo]::InvariantCulture
+        )
+    }
+}
+
+& (Join-Path $PSScriptRoot 'run_android.ps1') @arguments
diff --git a/open_wearable/tool/ui_tests/run_android.ps1 b/open_wearable/tool/ui_tests/run_android.ps1
new file mode 100644
index 000000000..037d4f523
--- /dev/null
+++ b/open_wearable/tool/ui_tests/run_android.ps1
@@ -0,0 +1,169 @@
+[CmdletBinding()]
+param(
+    [ValidateSet('Navigation', 'Permissions', 'PermissionRecovery', 'Overview', 'Settings', 'ThisDevice', 'ThisDeviceData', 'PairDiscovery', 'PairHardware', 'PairSampleRate', 'Hardware')]
+    [string] $Suite = 'Navigation',
+
+    [string] $AndroidDevice,
+
+    [string] $OpenEarableDeviceId,
+
+    [double[]] $SampleRatesHz = @(25),
+
+    [ValidateRange(5, 600)]
+    [int] $SampleDurationSeconds = 12,
+
+    [ValidateRange(0.1, 99.9)]
+    [double] $SampleTolerancePercent = 15,
+
+    [switch] $ListSuites
+)
+
+Set-StrictMode -Version Latest
+$ErrorActionPreference = 'Stop'
+
+$suiteDescriptions = [ordered]@{
+    Navigation         = 'Open every main tab and verify the empty states and Settings entry.'
+    Permissions        = 'Complete first-run Android Bluetooth and microphone permissions.'
+    PermissionRecovery = 'Recover after microphone permission was skipped during onboarding.'
+    Overview           = 'Check every Overview shortcut reaches its intended screen.'
+    Settings           = 'Toggle, reopen, verify, and restore all six General settings.'
+    ThisDevice         = 'Connect the phone as a sensor device, inspect details, and disconnect.'
+    ThisDeviceData     = 'Set phone Accelerometer to 5 Hz, stream, record CSV, and delete it.'
+    PairDiscovery      = 'Exercise the OpenEarable-only scan filter without connecting hardware.'
+    PairHardware       = 'Discover two OpenEarables, connect, verify L/R pair, split/recombine, and disconnect.'
+    PairSampleRate     = 'For two OpenEarables, set requested IMU rate(s) and verify received L/R CSV rates; live graph labels are not asserted.'
+    Hardware           = 'Connect one exact Bluetooth device ID, inspect it, and disconnect.'
+}
+
+if ($ListSuites) {
+    $suiteDescriptions.GetEnumerator() | ForEach-Object {
+        [PSCustomObject]@{ Suite = $_.Key; Checks = $_.Value }
+    } | Format-Table -AutoSize -Wrap
+    return
+}
+
+function Resolve-PatrolExecutable {
+    param([string] $ProjectRoot)
+
+    $command = Get-Command patrol -ErrorAction SilentlyContinue
+    if ($null -ne $command) {
+        return $command.Source
+    }
+
+    $candidates = @(
+        (Join-Path $ProjectRoot '..\..\.pub-cache\bin\patrol.bat'),
+        (Join-Path $env:LOCALAPPDATA 'Pub\Cache\bin\patrol.bat')
+    )
+    if (-not [string]::IsNullOrWhiteSpace($env:PUB_CACHE)) {
+        $candidates = @((Join-Path $env:PUB_CACHE 'bin\patrol.bat')) + $candidates
+    }
+
+    foreach ($candidate in $candidates) {
+        if (Test-Path -LiteralPath $candidate) {
+            return (Resolve-Path -LiteralPath $candidate).Path
+        }
+    }
+
+    throw 'Patrol CLI 4.8.0 is required. Run: dart pub global activate patrol_cli 4.8.0'
+}
+
+function Initialize-AndroidSdkEnvironment {
+    param([string] $ProjectRoot)
+
+    if ([string]::IsNullOrWhiteSpace($env:ANDROID_HOME)) {
+        $propertiesPath = Join-Path $ProjectRoot 'android\local.properties'
+        if (Test-Path -LiteralPath $propertiesPath) {
+            $sdkLine = Get-Content -LiteralPath $propertiesPath |
+                Where-Object { $_ -match '^sdk\.dir=' } |
+                Select-Object -First 1
+            if ($null -ne $sdkLine) {
+                $env:ANDROID_HOME = $sdkLine.Substring('sdk.dir='.Length).Replace('\\', '\')
+            }
+        }
+    }
+
+    if ([string]::IsNullOrWhiteSpace($env:ANDROID_HOME) -or
+        -not (Test-Path -LiteralPath $env:ANDROID_HOME)) {
+        throw 'Android SDK was not found. Set ANDROID_HOME or run flutter pub get to generate android/local.properties.'
+    }
+
+    $env:ANDROID_SDK_ROOT = $env:ANDROID_HOME
+    $platformTools = Join-Path $env:ANDROID_HOME 'platform-tools'
+    if (Test-Path -LiteralPath $platformTools) {
+        $env:Path = "$platformTools;$env:Path"
+    }
+
+    # Pub-generated Windows launchers call `dart` by name. Put dart.exe ahead
+    # of Flutter's extensionless Unix launcher so patrol.bat is reliable.
+    $propertiesPath = Join-Path $ProjectRoot 'android\local.properties'
+    if (Test-Path -LiteralPath $propertiesPath) {
+        $flutterLine = Get-Content -LiteralPath $propertiesPath |
+            Where-Object { $_ -match '^flutter\.sdk=' } |
+            Select-Object -First 1
+        if ($null -ne $flutterLine) {
+            $flutterSdk = $flutterLine.Substring('flutter.sdk='.Length).Replace('\\', '\')
+            $dartSdkBin = Join-Path $flutterSdk 'bin\cache\dart-sdk\bin'
+            if (Test-Path -LiteralPath $dartSdkBin) {
+                $env:Path = "$dartSdkBin;$env:Path"
+            }
+        }
+    }
+}
+
+if ($Suite -eq 'Hardware' -and [string]::IsNullOrWhiteSpace($OpenEarableDeviceId)) {
+    throw 'Hardware runs require -OpenEarableDeviceId with the exact Android Bluetooth device ID.'
+}
+if ($Suite -eq 'PairSampleRate' -and
+    ($SampleRatesHz.Count -eq 0 -or @($SampleRatesHz | Where-Object { $_ -le 0 }).Count -gt 0)) {
+    throw 'PairSampleRate requires one or more positive -SampleRatesHz values.'
+}
+
+$projectRoot = (Resolve-Path -LiteralPath (Join-Path $PSScriptRoot '..\..')).Path
+$workspacePubCache = Join-Path $projectRoot '..\..\.pub-cache'
+if (Test-Path -LiteralPath $workspacePubCache) {
+    $env:PUB_CACHE = (Resolve-Path -LiteralPath $workspacePubCache).Path
+}
+$patrolExecutable = Resolve-PatrolExecutable -ProjectRoot $projectRoot
+Initialize-AndroidSdkEnvironment -ProjectRoot $projectRoot
+$target = switch ($Suite) {
+    'Hardware' { 'patrol_test/open_earable_connection_test.dart' }
+    'Permissions' { 'patrol_test/onboarding_permissions_test.dart' }
+    'PermissionRecovery' { 'patrol_test/late_microphone_permission_test.dart' }
+    'Overview' { 'patrol_test/overview_shortcuts_test.dart' }
+    'Settings' { 'patrol_test/general_settings_test.dart' }
+    'ThisDevice' { 'patrol_test/this_device_connection_test.dart' }
+    'ThisDeviceData' { 'patrol_test/this_device_recording_test.dart' }
+    'PairDiscovery' { 'patrol_test/pair_discovery_test.dart' }
+    'PairHardware' { 'patrol_test/open_earable_pair_test.dart' }
+    'PairSampleRate' { 'patrol_test/open_earable_pair_sample_rate_test.dart' }
+    default { 'patrol_test/navigation_and_settings_test.dart' }
+}
+
+$patrolArguments = @('test', '--debug', '--target', $target)
+if (-not [string]::IsNullOrWhiteSpace($AndroidDevice)) {
+    $patrolArguments += @('--device', $AndroidDevice)
+}
+if ($Suite -eq 'Hardware') {
+    $patrolArguments += "--dart-define=OPENEARABLE_DEVICE_ID=$OpenEarableDeviceId"
+}
+if ($Suite -eq 'PairSampleRate') {
+    $invariantRates = ($SampleRatesHz | ForEach-Object {
+        $_.ToString([Globalization.CultureInfo]::InvariantCulture)
+    }) -join ','
+    $invariantTolerance = $SampleTolerancePercent.ToString(
+        [Globalization.CultureInfo]::InvariantCulture
+    )
+    $patrolArguments += "--dart-define=OPENEARABLE_SAMPLE_RATES_HZ=$invariantRates"
+    $patrolArguments += "--dart-define=OPENEARABLE_SAMPLE_DURATION_SECONDS=$SampleDurationSeconds"
+    $patrolArguments += "--dart-define=OPENEARABLE_SAMPLE_TOLERANCE_PERCENT=$invariantTolerance"
+}
+
+Push-Location -LiteralPath $projectRoot
+try {
+    & $patrolExecutable @patrolArguments
+    if ($LASTEXITCODE -ne 0) {
+        throw "Patrol Android test failed with exit code $LASTEXITCODE."
+    }
+} finally {
+    Pop-Location
+}