diff --git a/open_wearable/lib/main.dart b/open_wearable/lib/main.dart
index 7abab9c5..0b5979ec 100644
--- a/open_wearable/lib/main.dart
+++ b/open_wearable/lib/main.dart
@@ -14,6 +14,7 @@ import 'package:open_wearable/models/app_upgrade_coordinator.dart';
 import 'package:open_wearable/models/app_upgrade_highlight.dart';
 import 'package:open_wearable/models/auto_connect_preferences.dart';
 import 'package:open_wearable/models/connector_settings.dart';
+import 'package:open_wearable/models/labels/label_sensor.dart';
 import 'package:open_wearable/models/log_file_manager.dart';
 import 'package:open_wearable/models/fota_post_update_verification.dart';
 import 'package:open_wearable/models/permissions_helper.dart';
@@ -35,6 +36,8 @@ import 'package:open_wearable/widgets/onboarding/permissions_onboarding_page.dar
 import 'models/bluetooth_auto_connector.dart';
 import 'models/logger.dart';
 import 'view_models/app_banner_controller.dart';
+import 'view_models/label_provider.dart';
+import 'view_models/label_set_provider.dart';
 import 'view_models/wearables_provider.dart';
 
 void main() async {
@@ -54,12 +57,42 @@ void main() async {
         ChangeNotifierProvider(
           create: (context) => FirmwareUpdateRequestProvider(),
         ),
-        ChangeNotifierProxyProvider<WearablesProvider, SensorRecorderProvider>(
+        ChangeNotifierProvider(
+          create: (context) => LabelSetProvider(),
+        ),
+        ChangeNotifierProxyProvider<LabelSetProvider, LabelProvider>(
+          create: (context) => LabelProvider(null),
+          update: (context, labelSetProvider, labelProvider) {
+            labelProvider?.setLabelSet(labelSetProvider.selectedLabelSet);
+            return labelProvider!;
+          },
+        ),
+        ChangeNotifierProxyProvider2<WearablesProvider, LabelSetProvider,
+            SensorRecorderProvider>(
           create: (context) => SensorRecorderProvider(),
-          update: (context, wearablesProvider, recorderProvider) {
+          update: (
+            context,
+            wearablesProvider,
+            labelSetProvider,
+            recorderProvider,
+          ) {
             final provider = recorderProvider ?? SensorRecorderProvider();
+            final labelSet = labelSetProvider.selectedLabelSet;
+            final wearables = [...wearablesProvider.wearables];
+            if (labelSet != null) {
+              final labelProvider = context.read<LabelProvider>();
+              wearables.add(
+                LabelWearable(
+                  labelSet: labelSet,
+                  labelStream: labelProvider.activeLabelStream,
+                ),
+              );
+            }
+            logger.t(
+              'Updating SensorRecorderProvider with label set: $labelSet',
+            );
             provider.synchronizeConnectedWearables(
-              wearablesProvider.wearables,
+              wearables,
             );
             return provider;
           },
diff --git a/open_wearable/lib/models/app_upgrade_registry.dart b/open_wearable/lib/models/app_upgrade_registry.dart
index d5d04ab8..a72f88da 100644
--- a/open_wearable/lib/models/app_upgrade_registry.dart
+++ b/open_wearable/lib/models/app_upgrade_registry.dart
@@ -179,6 +179,44 @@ class AppUpgradeRegistry {
         ),
       ],
     ),
+    AppUpgradeHighlight(
+      version: '1.5.0',
+      eyebrow: 'OpenWearables 1.5.0',
+      title: 'Add labels while\nyou record',
+      summary:
+          'Mark important moments in local recordings and find devices faster.',
+      heroDescription:
+          'OpenWearables 1.5.0 brings reusable recording labels to the local recorder. '
+          'Create label sets, choose one before recording, and tap labels during a session so key events are saved with your sensor data.',
+      accentColor: Color(0xFF8F6A67),
+      useHeroGradient: false,
+      features: <AppUpgradeFeatureHighlight>[
+        AppUpgradeFeatureHighlight(
+          icon: Icons.label_rounded,
+          title: 'Recording labels',
+          description:
+              'Create reusable label sets and mark events while recording. Label states are saved alongside sensor data with timestamps for easier review and analysis.',
+        ),
+        AppUpgradeFeatureHighlight(
+          icon: Icons.filter_alt_rounded,
+          title: 'Device name filter',
+          description:
+              'Filter the available device list by name, starting with OpenEarable, so nearby Bluetooth devices are easier to scan and connect.',
+        ),
+        AppUpgradeFeatureHighlight(
+          icon: Icons.verified_rounded,
+          title: 'Smarter firmware matching',
+          description:
+              'Firmware lists and post-update checks now better recognize installed versions, including beta and pull-request builds.',
+        ),
+        AppUpgradeFeatureHighlight(
+          icon: Icons.auto_fix_high_rounded,
+          title: 'Workflow polish',
+          description:
+              'Small fixes make label-set editing, delete confirmations, selected dropdowns, color indicators, and update verification feel more predictable.',
+        ),
+      ],
+    ),
   ];
 
   /// Returns the configured highlight for [version], if any.
diff --git a/open_wearable/lib/models/beta_firmware_title_resolver.dart b/open_wearable/lib/models/beta_firmware_title_resolver.dart
new file mode 100644
index 00000000..73efcc21
--- /dev/null
+++ b/open_wearable/lib/models/beta_firmware_title_resolver.dart
@@ -0,0 +1,147 @@
+import 'dart:convert';
+import 'dart:io';
+
+import 'package:open_earable_flutter/open_earable_flutter.dart';
+
+typedef PullRequestTitleFetcher = Future<Map<int, String>> Function(
+  Set<int> pullRequestNumbers,
+);
+
+class BetaFirmwareTitleResolver {
+  final PullRequestTitleFetcher _fetchTitles;
+
+  BetaFirmwareTitleResolver({
+    PullRequestTitleFetcher? fetchTitles,
+  }) : _fetchTitles = fetchTitles ?? fetchGitHubPullRequestTitles;
+
+  Future<List<FirmwareEntry>> resolve(List<FirmwareEntry> entries) async {
+    final pullRequestNumbers = <int>{
+      for (final entry in entries)
+        if (entry.isBeta) ...[
+          if (_pullRequestNumberFor(entry.firmware) case final number?) number,
+        ],
+    };
+
+    if (pullRequestNumbers.isEmpty) {
+      return entries;
+    }
+
+    final titles = await _fetchTitlesSafely(pullRequestNumbers);
+    if (titles.isEmpty) {
+      return entries;
+    }
+
+    return [
+      for (final entry in entries) _entryWithResolvedTitle(entry, titles),
+    ];
+  }
+
+  Future<Map<int, String>> _fetchTitlesSafely(
+    Set<int> pullRequestNumbers,
+  ) async {
+    try {
+      return await _fetchTitles(pullRequestNumbers);
+    } catch (_) {
+      return const {};
+    }
+  }
+
+  FirmwareEntry _entryWithResolvedTitle(
+    FirmwareEntry entry,
+    Map<int, String> titles,
+  ) {
+    if (!entry.isBeta) {
+      return entry;
+    }
+
+    final pullRequestNumber = _pullRequestNumberFor(entry.firmware);
+    final title = titles[pullRequestNumber]?.trim();
+    if (title == null || title.isEmpty || title == entry.firmware.name) {
+      return entry;
+    }
+
+    final firmware = entry.firmware;
+    return FirmwareEntry(
+      firmware: RemoteFirmware(
+        name: title,
+        version: firmware.version,
+        url: firmware.url,
+        type: firmware.type,
+      ),
+      source: entry.source,
+    );
+  }
+}
+
+Future<Map<int, String>> fetchGitHubPullRequestTitles(
+  Set<int> pullRequestNumbers,
+) async {
+  if (pullRequestNumbers.isEmpty) {
+    return const {};
+  }
+
+  final client = HttpClient();
+  try {
+    final entries = await Future.wait(
+      pullRequestNumbers.map(
+        (number) => _fetchGitHubPullRequestTitle(client, number),
+      ),
+    );
+    return {
+      for (final entry in entries)
+        if (entry != null) entry.key: entry.value,
+    };
+  } finally {
+    client.close(force: true);
+  }
+}
+
+Future<MapEntry<int, String>?> _fetchGitHubPullRequestTitle(
+  HttpClient client,
+  int pullRequestNumber,
+) async {
+  try {
+    final request = await client.getUrl(
+      Uri.https(
+        'api.github.com',
+        '/repos/OpenEarable/open-earable-2/pulls/$pullRequestNumber',
+      ),
+    );
+    request.headers.set(
+      HttpHeaders.acceptHeader,
+      'application/vnd.github+json',
+    );
+    request.headers.set(HttpHeaders.userAgentHeader, 'OpenWearable');
+
+    final response = await request.close();
+    if (response.statusCode != HttpStatus.ok) {
+      await response.drain<void>();
+      return null;
+    }
+
+    final body = await utf8.decodeStream(response);
+    final json = jsonDecode(body) as Map<String, dynamic>;
+    final title = (json['title'] as String?)?.trim();
+    if (title == null || title.isEmpty) {
+      return null;
+    }
+
+    return MapEntry(pullRequestNumber, title);
+  } catch (_) {
+    return null;
+  }
+}
+
+int? _pullRequestNumberFor(RemoteFirmware firmware) {
+  return _pullRequestNumberFrom(firmware.version) ??
+      _pullRequestNumberFrom(firmware.url) ??
+      _pullRequestNumberFrom(firmware.name);
+}
+
+int? _pullRequestNumberFrom(String value) {
+  final match = RegExp(
+    r'(?:^|[^a-z0-9])pr\s*[-#]?\s*(\d+)(?=$|[^a-z0-9])',
+    caseSensitive: false,
+  ).firstMatch(value);
+  return int.tryParse(match?.group(1) ?? '');
+}
diff --git a/open_wearable/lib/models/firmware_version_matcher.dart b/open_wearable/lib/models/firmware_version_matcher.dart
new file mode 100644
index 00000000..fdf6c6ad
--- /dev/null
+++ b/open_wearable/lib/models/firmware_version_matcher.dart
@@ -0,0 +1,49 @@
+String? normalizeFirmwareVersion(String? value) {
+  final cleaned = value?.replaceAll('\x00', '').trim();
+  if (cleaned == null || cleaned.isEmpty) {
+    return null;
+  }
+  return cleaned;
+}
+
+bool firmwareVersionsMatch(String? expected, String? actual) {
+  final normalizedExpected = normalizeFirmwareVersion(expected);
+  final normalizedActual = normalizeFirmwareVersion(actual);
+  if (normalizedExpected == null || normalizedActual == null) {
+    return false;
+  }
+
+  final expectedComparison = _comparisonValue(normalizedExpected);
+  final actualComparison = _comparisonValue(normalizedActual);
+  if (expectedComparison == actualComparison) {
+    return true;
+  }
+
+  final expectedPrNumber = _extractPullRequestNumber(expectedComparison);
+  final actualPrNumber = _extractPullRequestNumber(actualComparison);
+  if (expectedPrNumber != null && actualPrNumber != null) {
+    return expectedPrNumber == actualPrNumber;
+  }
+
+  return actualComparison.contains(expectedComparison) ||
+      expectedComparison.contains(actualComparison);
+}
+
+String _comparisonValue(String value) {
+  return value.toLowerCase().replaceAll(RegExp(r'\s+'), ' ');
+}
+
+String? _extractPullRequestNumber(String value) {
+  for (final pattern in _pullRequestPatterns) {
+    final match = pattern.firstMatch(value);
+    if (match != null) {
+      return match.group(1);
+    }
+  }
+  return null;
+}
+
+final _pullRequestPatterns = <RegExp>[
+  RegExp(r'(?:^|[^a-z0-9])pr\s*[-#]?\s*(\d+)(?=$|[^a-z0-9])'),
+  RegExp(r'(?:^|[^a-z0-9])pull\s*request\s*#?\s*(\d+)(?=$|[^a-z0-9])'),
+];
diff --git a/open_wearable/lib/models/fota_post_update_verification.dart b/open_wearable/lib/models/fota_post_update_verification.dart
index 6e04526b..54dac842 100644
--- a/open_wearable/lib/models/fota_post_update_verification.dart
+++ b/open_wearable/lib/models/fota_post_update_verification.dart
@@ -2,6 +2,7 @@ import 'dart:async';
 
 import 'package:open_earable_flutter/open_earable_flutter.dart';
 import 'package:open_wearable/models/device_name_formatter.dart';
+import 'package:open_wearable/models/firmware_version_matcher.dart';
 
 /// Metadata returned when a post-update verification check is armed.
 class ArmedFotaPostUpdateVerification {
@@ -323,7 +324,7 @@ class FotaPostUpdateVerificationCoordinator {
         final version = await firmwareCap
             .readDeviceFirmwareVersion()
             .timeout(const Duration(seconds: 4));
-        final normalized = _normalizeVersion(version);
+        final normalized = normalizeFirmwareVersion(version);
         if (normalized != null) {
           return normalized;
         }
@@ -450,23 +451,20 @@ class FotaPostUpdateVerificationCoordinator {
 
   String? _extractExpectedFirmwareVersion(SelectedFirmware? firmware) {
     if (firmware is RemoteFirmware) {
-      return _normalizeVersion(firmware.version);
+      return normalizeFirmwareVersion(firmware.version);
     }
 
     if (firmware is LocalFirmware) {
       final match =
           RegExp(r'(\d+\.\d+\.\d+(?:[-+][\w.-]+)?)').firstMatch(firmware.name);
-      return _normalizeVersion(match?.group(1));
+      return normalizeFirmwareVersion(match?.group(1));
     }
 
     return null;
   }
 
   bool _firmwareVersionsMatch(String expected, String actual) {
-    if (actual == expected) {
-      return true;
-    }
-    return actual.contains(expected) || expected.contains(actual);
+    return firmwareVersionsMatch(expected, actual);
   }
 
   String _buildMessage({
@@ -533,14 +531,6 @@ class FotaPostUpdateVerificationCoordinator {
     return trimmed.toLowerCase();
   }
 
-  String? _normalizeVersion(String? value) {
-    final cleaned = value?.replaceAll('\x00', '').trim();
-    if (cleaned == null || cleaned.isEmpty) {
-      return null;
-    }
-    return cleaned;
-  }
-
   String? _normalizeSideLabel(String? sideLabel) {
     if (sideLabel == null || sideLabel.isEmpty) {
       return null;
diff --git a/open_wearable/lib/models/labels/file_label_set_storage.dart b/open_wearable/lib/models/labels/file_label_set_storage.dart
new file mode 100644
index 00000000..34613b67
--- /dev/null
+++ b/open_wearable/lib/models/labels/file_label_set_storage.dart
@@ -0,0 +1,51 @@
+import 'dart:convert';
+import 'dart:io';
+
+import 'package:path/path.dart' as p;
+import 'package:path_provider/path_provider.dart';
+
+import 'label_set.dart';
+import 'label_set_storage.dart';
+
+class FileLabelSetStorage implements LabelSetStorage {
+  FileLabelSetStorage({this.fileName = 'label_sets.json'});
+
+  final String fileName;
+
+  Future<File> _getFile() async {
+    final Directory dir = await getApplicationDocumentsDirectory();
+    return File(p.join(dir.path, fileName));
+  }
+
+  @override
+  Future<List<LabelSet>> loadLabelSets() async {
+    try {
+      final file = await _getFile();
+      if (!await file.exists()) {
+        return [];
+      }
+      final content = await file.readAsString();
+      if (content.trim().isEmpty) {
+        return [];
+      }
+      final jsonList = jsonDecode(content) as List<dynamic>;
+      return jsonList
+          .map((e) => LabelSet.fromJson(e as Map<String, dynamic>))
+          .toList();
+    } catch (e) {
+      // In case of any error, return empty list instead of crashing.
+      return [];
+    }
+  }
+
+  @override
+  Future<void> saveLabelSets(List<LabelSet> sets) async {
+    final file = await _getFile();
+    final jsonList = sets.map((s) => s.toJson()).toList();
+    final content = jsonEncode(jsonList);
+    await file.writeAsString(content);
+  }
+}
+
+/// Factory used by conditional import.
+LabelSetStorage createLabelSetStorage() => FileLabelSetStorage();
diff --git a/open_wearable/lib/models/labels/label.dart b/open_wearable/lib/models/labels/label.dart
new file mode 100644
index 00000000..90a06996
--- /dev/null
+++ b/open_wearable/lib/models/labels/label.dart
@@ -0,0 +1,39 @@
+import 'package:flutter/material.dart';
+
+/// A single label with a name and a color.
+class Label {
+  final String name;
+  final Color color;
+
+  const Label({
+    required this.name,
+    required this.color,
+  });
+
+  /// Create a modified copy (useful for editing).
+  Label copyWith({
+    String? name,
+    Color? color,
+  }) {
+    return Label(
+      name: name ?? this.name,
+      color: color ?? this.color,
+    );
+  }
+
+  /// JSON -> Label
+  factory Label.fromJson(Map<String, dynamic> json) {
+    return Label(
+      name: json['name'] as String,
+      color: Color(int.parse(json['color'] as String)),
+    );
+  }
+
+  /// Label -> JSON
+  Map<String, dynamic> toJson() {
+    return {
+      'name': name,
+      'color': '0x${color.toARGB32().toRadixString(16)}',
+    };
+  }
+}
diff --git a/open_wearable/lib/models/labels/label_sensor.dart b/open_wearable/lib/models/labels/label_sensor.dart
new file mode 100644
index 00000000..b8f908e0
--- /dev/null
+++ b/open_wearable/lib/models/labels/label_sensor.dart
@@ -0,0 +1,111 @@
+import 'package:open_earable_flutter/open_earable_flutter.dart';
+import 'package:open_wearable/models/labels/label_set.dart';
+
+import 'label.dart';
+
+/// A wearable that provides labeling functionality.
+///
+/// This is used as an Adapter for the RecorderProvider to record labels
+/// alongside sensor data.
+class LabelWearable extends Wearable implements SensorManager {
+  LabelWearable({
+    required this.labelSet,
+    required Stream<(int, List<Label>)> labelStream,
+  })  : _labelStream = labelStream,
+        super(
+          name: "Label",
+          disconnectNotifier: WearableDisconnectNotifier(),
+        );
+
+  final LabelSet labelSet;
+  final Stream<(int, List<Label>)> _labelStream;
+
+  @override
+  List<Sensor> get sensors => [
+        LabelSensor(
+          labelSet: labelSet,
+          labelStream: _labelStream,
+        ),
+      ];
+
+  @override
+  String get deviceId => "label";
+
+  @override
+  Future<void> disconnect() {
+    throw UnimplementedError();
+  }
+}
+
+class LabelSensor extends Sensor<SensorLabelValue> {
+  LabelSensor({
+    required this.labelSet,
+    required Stream<(int, List<Label>)> labelStream,
+  })  : _labelStream = labelStream,
+        super(
+          sensorName: "Label_${labelSet.name}",
+          chartTitle: "",
+          shortChartTitle: "",
+        );
+
+  final LabelSet labelSet;
+  final Stream<(int, List<Label>)> _labelStream;
+
+  @override
+  List<String> get axisNames =>
+      labelSet.labels.map((label) => label.name).toList()
+        ..sort((a, b) => a.compareTo(b));
+
+  @override
+  List<String> get axisUnits => labelSet.labels.map((_) => "isActive").toList();
+
+  @override
+  Stream<SensorLabelValue> get sensorStream => _labelStream.map(
+        (data) => SensorLabelValue(
+          set: labelSet,
+          selectedLabels: data.$2,
+          timestamp: data.$1,
+        ),
+      );
+}
+
+class SensorLabelValue extends SensorValue {
+  /// Maps each label to whether it is active.
+  /// Labels are guaranteed to be sorted alphabetically by name.
+  final Map<Label, bool> labelStates;
+
+  SensorLabelValue({
+    required LabelSet set,
+    required List<Label> selectedLabels,
+    required super.timestamp,
+  })  : labelStates = _buildLabelStates(set, selectedLabels),
+        super(
+          valueStrings: _buildValueStrings(set, selectedLabels),
+        );
+
+  /// Builds the sorted label -> active map.
+  static Map<Label, bool> _buildLabelStates(
+    LabelSet set,
+    List<Label> selectedLabels,
+  ) {
+    final sortedLabels = [...set.labels]
+      ..sort((a, b) => a.name.compareTo(b.name));
+
+    return {
+      for (final label in sortedLabels) label: selectedLabels.contains(label),
+    };
+  }
+
+  /// Builds the valueStrings in the same deterministic order.
+  static List<String> _buildValueStrings(
+    LabelSet set,
+    List<Label> selectedLabels,
+  ) {
+    final sortedLabels = [...set.labels]
+      ..sort((a, b) => a.name.compareTo(b.name));
+
+    return sortedLabels
+        .map((label) => selectedLabels.contains(label).toString())
+        .toList();
+  }
+}
diff --git a/open_wearable/lib/models/labels/label_set.dart b/open_wearable/lib/models/labels/label_set.dart
new file mode 100644
index 00000000..a4f58b47
--- /dev/null
+++ b/open_wearable/lib/models/labels/label_set.dart
@@ -0,0 +1,42 @@
+// A set of labels, identified by a name.
+import 'label.dart';
+
+class LabelSet {
+  final String name;
+  final List<Label> labels;
+
+  const LabelSet({
+    required this.name,
+    required this.labels,
+  });
+
+  /// Create a modified copy (e.g., renamed set, updated labels list).
+  LabelSet copyWith({
+    String? name,
+    List<Label>? labels,
+  }) {
+    return LabelSet(
+      name: name ?? this.name,
+      labels: labels ?? this.labels,
+    );
+  }
+
+  /// JSON -> LabelSet
+  factory LabelSet.fromJson(Map<String, dynamic> json) {
+    final labelsJson = json['labels'] as List<dynamic>? ?? [];
+    return LabelSet(
+      name: json['name'] as String,
+      labels: labelsJson
+          .map((e) => Label.fromJson(e as Map<String, dynamic>))
+          .toList(),
+    );
+  }
+
+  /// LabelSet -> JSON
+  Map<String, dynamic> toJson() {
+    return {
+      'name': name,
+      'labels': labels.map((l) => l.toJson()).toList(),
+    };
+  }
+}
diff --git a/open_wearable/lib/models/labels/label_set_manager.dart b/open_wearable/lib/models/labels/label_set_manager.dart
new file mode 100644
index 00000000..ada34352
--- /dev/null
+++ b/open_wearable/lib/models/labels/label_set_manager.dart
@@ -0,0 +1,69 @@
+import 'package:flutter/foundation.dart';
+
+import 'label_set.dart';
+
+import 'label_set_storage.dart';
+import 'file_label_set_storage.dart'
+    if (dart.library.html) 'web_label_set_storage.dart';
+
+class LabelSetManager extends ChangeNotifier {
+  LabelSetManager({LabelSetStorage? storage})
+      : _storage = storage ?? createLabelSetStorage();
+
+  final LabelSetStorage _storage;
+
+  final List<LabelSet> _labelSets = [];
+
+  List<LabelSet> get labelSets => List.unmodifiable(_labelSets);
+
+  /// Load label sets from persistent storage.
+  Future<void> load() async {
+    final loaded = await _storage.loadLabelSets();
+    _labelSets
+      ..clear()
+      ..addAll(loaded);
+    notifyListeners();
+  }
+
+  /// Persist current state.
+  Future<void> _save() => _storage.saveLabelSets(_labelSets);
+
+  /// Add a new label set (or replace one with the same name).
+  Future<void> upsertLabelSet(LabelSet set) async {
+    final index = _labelSets.indexWhere((s) => s.name == set.name);
+    if (index >= 0) {
+      _labelSets[index] = set;
+    } else {
+      _labelSets.add(set);
+    }
+    await _save();
+    notifyListeners();
+  }
+
+  /// Remove a label set.
+  Future<void> removeLabelSet(LabelSet set) async {
+    _labelSets.removeWhere((s) => s.name == set.name);
+    await _save();
+    notifyListeners();
+  }
+
+  /// Replace one specific set with an updated instance.
+  Future<void> replaceLabelSet(LabelSet oldSet, LabelSet newSet) async {
+    var index = _labelSets.indexOf(oldSet);
+    if (index < 0) {
+      index = _labelSets.indexWhere((set) => set.name == oldSet.name);
+    }
+    if (index >= 0) {
+      _labelSets[index] = newSet;
+      await _save();
+      notifyListeners();
+    }
+  }
+
+  /// Remove all label sets.
+  Future<void> clear() async {
+    _labelSets.clear();
+    await _save();
+    notifyListeners();
+  }
+}
diff --git a/open_wearable/lib/models/labels/label_set_storage.dart b/open_wearable/lib/models/labels/label_set_storage.dart
new file mode 100644
index 00000000..f743510b
--- /dev/null
+++ b/open_wearable/lib/models/labels/label_set_storage.dart
@@ -0,0 +1,9 @@
+import 'dart:async';
+
+import 'label_set.dart';
+
+/// Interface for persisting label sets.
+abstract class LabelSetStorage {
+  Future<List<LabelSet>> loadLabelSets();
+  Future<void> saveLabelSets(List<LabelSet> sets);
+}
diff --git a/open_wearable/lib/models/labels/web_label_set_storage.dart b/open_wearable/lib/models/labels/web_label_set_storage.dart
new file mode 100644
index 00000000..a78a32f1
--- /dev/null
+++ b/open_wearable/lib/models/labels/web_label_set_storage.dart
@@ -0,0 +1,38 @@
+// Only used on web.
+import 'dart:convert';
+import 'package:web/web.dart' as web;
+
+import 'label_set.dart';
+import 'label_set_storage.dart';
+
+class WebLabelSetStorage implements LabelSetStorage {
+  WebLabelSetStorage({this.storageKey = 'openwearable_label_sets'});
+
+  final String storageKey;
+
+  @override
+  Future<List<LabelSet>> loadLabelSets() async {
+    try {
+      final stored = web.window.localStorage.getItem(storageKey);
+      if (stored == null || stored.trim().isEmpty) {
+        return [];
+      }
+      final jsonList = jsonDecode(stored) as List<dynamic>;
+      return jsonList
+          .map((e) => LabelSet.fromJson(e as Map<String, dynamic>))
+          .toList();
+    } catch (_) {
+      return [];
+    }
+  }
+
+  @override
+  Future<void> saveLabelSets(List<LabelSet> sets) async {
+    final jsonList = sets.map((s) => s.toJson()).toList();
+    final encoded = jsonEncode(jsonList);
+    web.window.localStorage.setItem(storageKey, encoded);
+  }
+}
+
+/// Factory used by conditional import.
+LabelSetStorage createLabelSetStorage() => WebLabelSetStorage();
diff --git a/open_wearable/lib/view_models/label_provider.dart b/open_wearable/lib/view_models/label_provider.dart
new file mode 100644
index 00000000..a7e578b0
--- /dev/null
+++ b/open_wearable/lib/view_models/label_provider.dart
@@ -0,0 +1,63 @@
+import 'dart:async';
+
+import 'package:flutter/foundation.dart';
+
+import '../models/labels/label.dart';
+import '../models/labels/label_set.dart';
+
+class LabelProvider with ChangeNotifier {
+  LabelSet? labelSet;
+
+  LabelProvider(this.labelSet);
+
+  Label? _activeLabel;
+  Label? get activeLabel => _activeLabel;
+
+  /// Unix timestamp (milliseconds since epoch) when the active label was last set.
+  int? _activeLabelSetAtUnixMs;
+  int? get activeLabelSetAtUnixMs => _activeLabelSetAtUnixMs;
+
+  final StreamController<(int, List<Label>)> _activeLabelController =
+      StreamController<(int, List<Label>)>.broadcast();
+
+  /// Emits a tuple of (unixTimeMs, activeLabel) whenever [setActiveLabel] is called.
+  Stream<(int, List<Label>)> get activeLabelStream =>
+      _activeLabelController.stream;
+
+  /// Sets the active label and records the unix time (ms) the label was set.
+  ///
+  /// This will:
+  ///  - update [activeLabel] and [activeLabelSetAtUnixMs]
+  ///  - notify listeners
+  ///  - emit (timestamp, label) on [activeLabelStream]
+  void setActiveLabel(Label? label, {int? unixTimeMs}) {
+    final int ts = unixTimeMs ?? DateTime.now().millisecondsSinceEpoch;
+
+    _activeLabel = label;
+    _activeLabelSetAtUnixMs = ts;
+
+    // Emit first so stream consumers can react immediately, then notify UI.
+    if (!_activeLabelController.isClosed) {
+      _activeLabelController.add((ts, [if (label != null) label]));
+    }
+
+    notifyListeners();
+  }
+
+  void setLabelSet(LabelSet? newLabelSet) {
+    labelSet = newLabelSet;
+    if (_activeLabel != null &&
+        (labelSet == null || !labelSet!.labels.contains(_activeLabel))) {
+      // Clear active label if it's not in the new label set.
+      _activeLabel = null;
+      _activeLabelSetAtUnixMs = null;
+    }
+    notifyListeners();
+  }
+
+  @override
+  void dispose() {
+    _activeLabelController.close();
+    super.dispose();
+  }
+}
diff --git a/open_wearable/lib/view_models/label_set_provider.dart b/open_wearable/lib/view_models/label_set_provider.dart
new file mode 100644
index 00000000..a803c294
--- /dev/null
+++ b/open_wearable/lib/view_models/label_set_provider.dart
@@ -0,0 +1,78 @@
+import 'package:flutter/foundation.dart';
+
+import '../models/labels/label_set.dart';
+import '../models/labels/label_set_manager.dart';
+
+class LabelSetProvider extends ChangeNotifier {
+  LabelSetProvider({LabelSetManager? manager})
+      : _manager = manager ?? LabelSetManager() {
+    _init();
+  }
+
+  final LabelSetManager _manager;
+
+  bool _loaded = false;
+  bool get isLoaded => _loaded;
+
+  LabelSet? _selectedLabelSet;
+  LabelSet? get selectedLabelSet => _resolveSet(_selectedLabelSet);
+
+  List<LabelSet> get labelSets => _manager.labelSets;
+
+  Future<void> _init() async {
+    await _manager.load();
+    _selectedLabelSet = _resolveSet(_selectedLabelSet);
+    _loaded = true;
+    notifyListeners();
+  }
+
+  Future<void> refresh() async {
+    await _manager.load();
+    _selectedLabelSet = _resolveSet(_selectedLabelSet);
+    notifyListeners();
+  }
+
+  Future<void> addOrUpdateSet(LabelSet set) async {
+    await _manager.upsertLabelSet(set);
+    if (_selectedLabelSet?.name == set.name) {
+      _selectedLabelSet = set;
+    }
+    notifyListeners();
+  }
+
+  Future<void> deleteSet(LabelSet set) async {
+    await _manager.removeLabelSet(set);
+    if (_selectedLabelSet?.name == set.name) {
+      _selectedLabelSet = null;
+    }
+    notifyListeners();
+  }
+
+  Future<void> replaceSet(LabelSet oldSet, LabelSet newSet) async {
+    await _manager.replaceLabelSet(oldSet, newSet);
+    if (_selectedLabelSet == oldSet || _selectedLabelSet?.name == oldSet.name) {
+      _selectedLabelSet = newSet;
+    }
+    notifyListeners();
+  }
+
+  Future<void> clear() async {
+    await _manager.clear();
+    notifyListeners();
+  }
+
+  void selectLabelSet(LabelSet? set) {
+    _selectedLabelSet = _resolveSet(set);
+    notifyListeners();
+  }
+
+  LabelSet? _resolveSet(LabelSet? set) {
+    if (set == null) return null;
+    for (final candidate in _manager.labelSets) {
+      if (candidate == set || candidate.name == set.name) {
+        return candidate;
+      }
+    }
+    return null;
+  }
+}
diff --git a/open_wearable/lib/view_models/sensor_recorder_provider_io.dart b/open_wearable/lib/view_models/sensor_recorder_provider_io.dart
index f9884544..859762de 100644
--- a/open_wearable/lib/view_models/sensor_recorder_provider_io.dart
+++ b/open_wearable/lib/view_models/sensor_recorder_provider_io.dart
@@ -7,6 +7,7 @@ import 'package:path_provider/path_provider.dart';
 import 'package:record/record.dart';
 
 import '../models/audio_input_source.dart';
+import '../models/labels/label_sensor.dart';
 import '../models/logger.dart';
 import '../models/sensor_streams.dart';
 import '../widgets/sensors/local_recorder/local_recorder_models.dart';
@@ -270,8 +271,9 @@ class SensorRecorderProvider with ChangeNotifier {
   }
 
   void _updateConnected() {
-    _hasSensorsConnected = !(_recorders.isEmpty ||
-        _recorders.values.every((sensors) => sensors.isEmpty));
+    _hasSensorsConnected = _recorders.entries.any(
+      (entry) => entry.key is! LabelWearable && entry.value.isNotEmpty,
+    );
     logger.i('Has sensors connected: $_hasSensorsConnected');
     notifyListeners();
   }
diff --git a/open_wearable/lib/view_models/sensor_recorder_provider_web.dart b/open_wearable/lib/view_models/sensor_recorder_provider_web.dart
index 99181f5a..a064e9ec 100644
--- a/open_wearable/lib/view_models/sensor_recorder_provider_web.dart
+++ b/open_wearable/lib/view_models/sensor_recorder_provider_web.dart
@@ -9,6 +9,7 @@ import 'package:open_wearable/widgets/sensors/local_recorder/local_recorder_mode
 import 'package:open_wearable/widgets/sensors/local_recorder/local_recorder_storage_web.dart';
 
 import '../models/audio_input_source.dart';
+import '../models/labels/label_sensor.dart';
 import '../models/logger.dart';
 import '../models/sensor_streams.dart';
 import 'audio_input_controller.dart';
@@ -201,7 +202,12 @@ class SensorRecorderProvider with ChangeNotifier {
   }
 
   void _updateConnected() {
-    _hasSensorsConnected = _wearablesById.isNotEmpty;
+    _hasSensorsConnected = _wearablesById.values.any(
+      (wearable) =>
+          wearable is! LabelWearable &&
+          wearable.hasCapability<SensorManager>() &&
+          wearable.requireCapability<SensorManager>().sensors.isNotEmpty,
+    );
     logger.i('Has sensors connected: $_hasSensorsConnected');
     _notifyListenersIfActive();
   }
diff --git a/open_wearable/lib/widgets/devices/connect_devices_page.dart b/open_wearable/lib/widgets/devices/connect_devices_page.dart
index 7608a9f0..8cd02c25 100644
--- a/open_wearable/lib/widgets/devices/connect_devices_page.dart
+++ b/open_wearable/lib/widgets/devices/connect_devices_page.dart
@@ -34,6 +34,8 @@ class ConnectDevicesPage extends StatefulWidget {
 class _ConnectDevicesPageState extends State<ConnectDevicesPage> {
   bool _hasBlePermissions = false;
   bool _hasMicPermission = true;
+  bool _showOnlyOpenEarableDevices = false;
+  String _deviceNameFilterText = 'OpenEarable';
   final Map<String, bool> _connectingDevices = {};
 
   late ConnectDevicesScanSnapshot _scanSnapshot;
@@ -134,12 +136,17 @@ class _ConnectDevicesPageState extends State<ConnectDevicesPage> {
         .where((device) => !connectedDeviceIds.contains(device.id))
         .toList();
     final thisDeviceEntry = _thisDeviceEntry;
-    final availableDevices = [
+    final allAvailableDevices = [
       if (thisDeviceEntry != null &&
           !connectedDeviceIds.contains(thisDeviceEntry.id))
         thisDeviceEntry,
       ...scannedDevices.where((device) => device.id != thisDeviceEntry?.id),
     ];
+    final availableDevices = _showOnlyOpenEarableDevices
+        ? allAvailableDevices
+            .where((device) => device.name.contains(_deviceNameFilterText))
+            .toList()
+        : allAvailableDevices;
 
     return PlatformScaffold(
       appBar: PlatformAppBar(
@@ -249,16 +256,15 @@ class _ConnectDevicesPageState extends State<ConnectDevicesPage> {
               context,
               title: 'Available',
               count: availableDevices.length,
+              trailing: _buildOpenEarableFilterToggle(context),
             ),
             if (availableDevices.isEmpty)
               _buildEmptyCard(
                 context,
                 title: _scanSnapshot.isScanning
                     ? 'Scanning for devices...'
-                    : 'No devices found yet',
-                subtitle: _scanSnapshot.isScanning
-                    ? 'Make sure your wearable is turned on and nearby.'
-                    : 'Press scan again or pull to refresh.',
+                    : 'No devices found',
+                subtitle: _emptyAvailableDevicesMessage(),
               )
             else
               ...availableDevices.map((device) {
@@ -368,6 +374,7 @@ class _ConnectDevicesPageState extends State<ConnectDevicesPage> {
     BuildContext context, {
     required String title,
     required int count,
+    Widget? trailing,
   }) {
     return Padding(
       padding: const EdgeInsets.fromLTRB(4, 0, 4, 8),
@@ -381,6 +388,18 @@ class _ConnectDevicesPageState extends State<ConnectDevicesPage> {
           ),
           const SizedBox(width: 8),
           _StatusPill(label: '$count'),
+          if (trailing != null) ...[
+            const SizedBox(width: 8),
+            Expanded(
+              child: Align(
+                alignment: Alignment.centerRight,
+                child: FittedBox(
+                  fit: BoxFit.scaleDown,
+                  child: trailing,
+                ),
+              ),
+            ),
+          ],
         ],
       ),
     );
@@ -401,6 +420,98 @@ class _ConnectDevicesPageState extends State<ConnectDevicesPage> {
     );
   }
 
+  Widget _buildOpenEarableFilterToggle(BuildContext context) {
+    final theme = Theme.of(context);
+    final colorScheme = theme.colorScheme;
+
+    return Row(
+      mainAxisSize: MainAxisSize.min,
+      children: [
+        Text(
+          'Device name filter',
+          style: theme.textTheme.labelSmall?.copyWith(
+            fontWeight: FontWeight.w600,
+          ),
+        ),
+        const SizedBox(width: 6),
+        InkWell(
+          borderRadius: BorderRadius.circular(999),
+          onTap: _editDeviceNameFilterText,
+          child: Container(
+            constraints: const BoxConstraints(minWidth: 78, maxWidth: 128),
+            padding: const EdgeInsets.symmetric(horizontal: 10, vertical: 4),
+            decoration: BoxDecoration(
+              color: Colors.transparent,
+              borderRadius: BorderRadius.circular(999),
+              border: Border.all(
+                color: colorScheme.outlineVariant.withValues(alpha: 0.9),
+              ),
+            ),
+            child: Text(
+              _deviceNameFilterText,
+              maxLines: 1,
+              overflow: TextOverflow.ellipsis,
+              textAlign: TextAlign.center,
+              style: theme.textTheme.labelSmall?.copyWith(
+                color: colorScheme.onSurface,
+                fontWeight: FontWeight.w700,
+              ),
+            ),
+          ),
+        ),
+        const SizedBox(width: 2),
+        Transform.scale(
+          scale: 0.75,
+          child: Switch.adaptive(
+            value: _showOnlyOpenEarableDevices,
+            onChanged: (value) {
+              setState(() {
+                _showOnlyOpenEarableDevices = value;
+              });
+            },
+          ),
+        ),
+      ],
+    );
+  }
+
+  Future<void> _editDeviceNameFilterText() async {
+    var editedText = _deviceNameFilterText;
+    final nextText = await showPlatformDialog<String>(
+      context: context,
+      builder: (dialogContext) => PlatformAlertDialog(
+        title: const Text('Device name filter'),
+        content: TextFormField(
+          initialValue: editedText,
+          autofocus: true,
+          decoration: const InputDecoration(labelText: 'Name contains'),
+          textInputAction: TextInputAction.done,
+          onChanged: (value) => editedText = value,
+          onFieldSubmitted: (value) => Navigator.of(dialogContext).pop(value),
+        ),
+        actions: [
+          PlatformDialogAction(
+            onPressed: () => Navigator.of(dialogContext).pop(),
+            child: const Text('Cancel'),
+          ),
+          PlatformDialogAction(
+            onPressed: () => Navigator.of(dialogContext).pop(editedText),
+            child: const Text('Apply'),
+          ),
+        ],
+      ),
+    );
+
+    final trimmedText = nextText?.trim();
+    if (trimmedText == null || trimmedText.isEmpty || !mounted) {
+      return;
+    }
+
+    setState(() {
+      _deviceNameFilterText = trimmedText;
+    });
+  }
+
   Widget _buildTrailingWidget(
     DiscoveredDevice device, {
     required VoidCallback onConnect,
@@ -446,6 +557,15 @@ class _ConnectDevicesPageState extends State<ConnectDevicesPage> {
     return '${elapsed.inHours}h ago';
   }
 
+  String _emptyAvailableDevicesMessage() {
+    if (_showOnlyOpenEarableDevices) {
+      return 'No devices match "$_deviceNameFilterText".';
+    }
+    return _scanSnapshot.isScanning
+        ? 'Make sure your wearable is turned on and nearby.'
+        : 'Press scan again or pull to refresh.';
+  }
+
   Future<void> _addThisDeviceToDiscovered() async {
     if (_thisDeviceEntry != null) return;
     final profile = await DeviceProfile.fetch();
diff --git a/open_wearable/lib/widgets/fota/firmware_select/firmware_list.dart b/open_wearable/lib/widgets/fota/firmware_select/firmware_list.dart
index 628a1711..fcb41681 100644
--- a/open_wearable/lib/widgets/fota/firmware_select/firmware_list.dart
+++ b/open_wearable/lib/widgets/fota/firmware_select/firmware_list.dart
@@ -4,6 +4,8 @@ import 'package:file_picker/file_picker.dart';
 import 'package:flutter/material.dart';
 import 'package:flutter_platform_widgets/flutter_platform_widgets.dart';
 import 'package:open_earable_flutter/open_earable_flutter.dart';
+import 'package:open_wearable/models/beta_firmware_title_resolver.dart';
+import 'package:open_wearable/models/firmware_version_matcher.dart';
 import 'package:open_wearable/widgets/sensors/sensor_page_spacing.dart';
 import 'package:provider/provider.dart';
 
@@ -17,6 +19,7 @@ class FirmwareList extends StatefulWidget {
 class _FirmwareListState extends State<FirmwareList> {
   late Future<List<FirmwareEntry>> _firmwareFuture;
   final _repository = UnifiedFirmwareRepository();
+  final _betaTitleResolver = BetaFirmwareTitleResolver();
   String? firmwareVersion;
   bool _expanded = false;
 
@@ -45,7 +48,9 @@ class _FirmwareListState extends State<FirmwareList> {
     }
 
     try {
-      beta = await _repository.getBetaFirmwares();
+      beta = await _betaTitleResolver.resolve(
+        await _repository.getBetaFirmwares(),
+      );
     } catch (error) {
       betaError = error;
       // Beta feed is optional. Ignore failures.
@@ -453,7 +458,7 @@ class _FirmwareListState extends State<FirmwareList> {
           const SizedBox(width: 8),
           Expanded(
             child: Text(
-              'Beta firmware is experimental and is not recommended to be used. Use at your own risk.',
+              'Beta firmware is experimental. Use at your own risk.',
               style: Theme.of(context).textTheme.bodySmall?.copyWith(
                     color: colorScheme.onSurface,
                     fontWeight: FontWeight.w600,
@@ -691,7 +696,7 @@ class _FirmwareListState extends State<FirmwareList> {
     if (version == null) {
       return false;
     }
-    return firmware.version == version || firmware.version.contains(version);
+    return firmwareVersionsMatch(firmware.version, version);
   }
 
   FirmwareEntry? _findCurrentEntry(List<FirmwareEntry> orderedEntries) {
@@ -702,7 +707,7 @@ class _FirmwareListState extends State<FirmwareList> {
 
     for (final entry in orderedEntries) {
       final fwVersion = entry.firmware.version;
-      if (fwVersion == version || fwVersion.contains(version)) {
+      if (firmwareVersionsMatch(fwVersion, version)) {
         return entry;
       }
     }
@@ -710,11 +715,7 @@ class _FirmwareListState extends State<FirmwareList> {
   }
 
   String? get _normalizedDeviceVersion {
-    final version = firmwareVersion?.replaceAll('\x00', '').trim();
-    if (version == null || version.isEmpty) {
-      return null;
-    }
-    return version;
+    return normalizeFirmwareVersion(firmwareVersion);
   }
 
   void _installFirmware(RemoteFirmware firmware) {
diff --git a/open_wearable/lib/widgets/recording_activity_indicator.dart b/open_wearable/lib/widgets/recording_activity_indicator.dart
index fef3c391..a8268e6a 100644
--- a/open_wearable/lib/widgets/recording_activity_indicator.dart
+++ b/open_wearable/lib/widgets/recording_activity_indicator.dart
@@ -1,8 +1,10 @@
+import 'dart:async';
 import 'dart:math' as math;
 
 import 'package:flutter/material.dart';
 import 'package:provider/provider.dart';
 
+import '../view_models/label_provider.dart';
 import '../view_models/sensor_recorder_provider_facade.dart';
 
 /// Shared pulse ticker so every recording indicator stays in sync.
@@ -11,9 +13,27 @@ class _RecordingPulseTicker {
 
   static const int _periodMs = 900;
   static const Duration tick = Duration(milliseconds: 40);
-  static final Stream<DateTime> stream =
-      Stream<DateTime>.periodic(tick, (_) => DateTime.now())
-          .asBroadcastStream();
+  static Timer? _timer;
+  static final StreamController<DateTime> _controller =
+      StreamController<DateTime>.broadcast(
+    onListen: _start,
+    onCancel: _stop,
+  );
+
+  static Stream<DateTime> get stream => _controller.stream;
+
+  static void _start() {
+    _timer ??= Timer.periodic(tick, (_) {
+      if (!_controller.isClosed) {
+        _controller.add(DateTime.now());
+      }
+    });
+  }
+
+  static void _stop() {
+    _timer?.cancel();
+    _timer = null;
+  }
 
   static double opacityAt(DateTime now, DateTime origin) {
     final elapsedMs = now.difference(origin).inMilliseconds;
@@ -44,6 +64,9 @@ class RecordingActivityIndicator extends StatelessWidget {
     final recordingStart = context.select<SensorRecorderProvider, DateTime?>(
       (provider) => provider.recordingStart,
     );
+    final activeLabelColor = context.select<LabelProvider, Color?>(
+      (provider) => provider.activeLabel?.color,
+    );
 
     final colorScheme = Theme.of(context).colorScheme;
     final color = isRecording
@@ -74,9 +97,13 @@ class RecordingActivityIndicator extends StatelessWidget {
         builder: (context, snapshot) {
           final now = snapshot.data ?? DateTime.now();
           final opacity = _RecordingPulseTicker.opacityAt(now, anchor);
-          return Opacity(
-            opacity: opacity,
-            child: icon,
+          return _RecordingDotWithLabelBorder(
+            size: size,
+            borderColor: activeLabelColor,
+            child: Opacity(
+              opacity: opacity,
+              child: icon,
+            ),
           );
         },
       ),
@@ -84,6 +111,42 @@ class RecordingActivityIndicator extends StatelessWidget {
   }
 }
 
+class _RecordingDotWithLabelBorder extends StatelessWidget {
+  const _RecordingDotWithLabelBorder({
+    required this.size,
+    required this.borderColor,
+    required this.child,
+  });
+
+  final double size;
+  final Color? borderColor;
+  final Widget child;
+
+  @override
+  Widget build(BuildContext context) {
+    final outerSize = size + 8;
+    final borderWidth = (size * 0.12).clamp(1.5, 2.5).toDouble();
+    final color = borderColor;
+
+    return SizedBox.square(
+      key: const ValueKey('recording-label-border'),
+      dimension: outerSize,
+      child: DecoratedBox(
+        decoration: BoxDecoration(
+          shape: BoxShape.circle,
+          border: color == null
+              ? null
+              : Border.all(
+                  color: color,
+                  width: borderWidth,
+                ),
+        ),
+        child: Center(child: child),
+      ),
+    );
+  }
+}
+
 class AppBarRecordingIndicator extends StatelessWidget {
   const AppBarRecordingIndicator({super.key});
 
diff --git a/open_wearable/lib/widgets/sensors/configuration/edge_recorder_prefix_row.dart b/open_wearable/lib/widgets/sensors/configuration/edge_recorder_prefix_row.dart
index 7537ad99..e3f15c65 100644
--- a/open_wearable/lib/widgets/sensors/configuration/edge_recorder_prefix_row.dart
+++ b/open_wearable/lib/widgets/sensors/configuration/edge_recorder_prefix_row.dart
@@ -6,9 +6,14 @@ import 'package:open_earable_flutter/open_earable_flutter.dart';
 /// Row that shows the current file prefix of an [EdgeRecorderManager]
 /// and lets the user change it.
 class EdgeRecorderPrefixRow extends StatefulWidget {
-  const EdgeRecorderPrefixRow({super.key, required this.manager});
+  const EdgeRecorderPrefixRow({
+    super.key,
+    required this.manager,
+    this.pairedManager,
+  });
 
   final EdgeRecorderManager manager;
+  final EdgeRecorderManager? pairedManager;
 
   @override
   State<EdgeRecorderPrefixRow> createState() => _RecorderPrefixRowState();
@@ -83,7 +88,12 @@ class _RecorderPrefixRowState extends State<EdgeRecorderPrefixRow> {
     );
 
     if (result == true) {
-      await widget.manager.setFilePrefix(_editPrefixController.text.trim());
+      final prefix = _editPrefixController.text.trim();
+      await Future.wait([
+        widget.manager.setFilePrefix(prefix),
+        if (widget.pairedManager != null)
+          widget.pairedManager!.setFilePrefix(prefix),
+      ]);
       if (!mounted) {
         return;
       }
diff --git a/open_wearable/lib/widgets/sensors/configuration/sensor_configuration_device_row.dart b/open_wearable/lib/widgets/sensors/configuration/sensor_configuration_device_row.dart
index 4845f87a..71ff57d4 100644
--- a/open_wearable/lib/widgets/sensors/configuration/sensor_configuration_device_row.dart
+++ b/open_wearable/lib/widgets/sensors/configuration/sensor_configuration_device_row.dart
@@ -384,10 +384,15 @@ class _SensorConfigurationDeviceRowState
     ];
 
     if (device.hasCapability<EdgeRecorderManager>()) {
+      final pairedEdgeRecorderManager = widget.pairedDevice != null &&
+              widget.pairedDevice!.hasCapability<EdgeRecorderManager>()
+          ? widget.pairedDevice!.requireCapability<EdgeRecorderManager>()
+          : null;
       content.addAll([
         const InsetSectionDivider(),
         EdgeRecorderPrefixRow(
           manager: device.requireCapability<EdgeRecorderManager>(),
+          pairedManager: pairedEdgeRecorderManager,
         ),
       ]);
     }
diff --git a/open_wearable/lib/widgets/sensors/local_recorder/labels/active_label_bar.dart b/open_wearable/lib/widgets/sensors/local_recorder/labels/active_label_bar.dart
new file mode 100644
index 00000000..08fd94d3
--- /dev/null
+++ b/open_wearable/lib/widgets/sensors/local_recorder/labels/active_label_bar.dart
@@ -0,0 +1,184 @@
+import 'package:flutter/material.dart';
+import 'package:flutter/widget_previews.dart';
+import 'package:provider/provider.dart';
+
+import '../../../../models/labels/label.dart';
+import '../../../../models/labels/label_set.dart';
+import '../../../../view_models/label_provider.dart';
+
+/// A bar displaying the active label and allowing selection.
+class ActiveLabelBar extends StatelessWidget {
+  const ActiveLabelBar({
+    super.key,
+    required this.labelSet,
+    required this.selectionEnabled,
+    this.showNoLabelOption = false,
+  });
+
+  final LabelSet labelSet;
+  final bool selectionEnabled;
+  final bool showNoLabelOption;
+
+  @override
+  Widget build(BuildContext context) {
+    final labelProvider = context.watch<LabelProvider>();
+
+    return LayoutBuilder(
+      builder: (context, constraints) {
+        return Wrap(
+          spacing: 8,
+          runSpacing: 8,
+          children: [
+            if (showNoLabelOption)
+              _LabelChip(
+                name: 'No Label',
+                color: null,
+                selected: selectionEnabled && labelProvider.activeLabel == null,
+                enabled: selectionEnabled,
+                onTap: () => labelProvider.setActiveLabel(null),
+              ),
+            ...labelSet.labels.map((label) {
+              final bool isActive = label == labelProvider.activeLabel;
+              return _LabelChip(
+                name: label.name,
+                color: label.color,
+                selected: selectionEnabled && isActive,
+                enabled: selectionEnabled,
+                onTap: () => labelProvider.setActiveLabel(
+                  isActive ? null : label,
+                ),
+              );
+            }),
+          ],
+        );
+      },
+    );
+  }
+}
+
+class _LabelChip extends StatelessWidget {
+  const _LabelChip({
+    required this.name,
+    required this.color,
+    required this.selected,
+    required this.enabled,
+    required this.onTap,
+  });
+
+  final String name;
+  final Color? color;
+  final bool selected;
+  final bool enabled;
+  final VoidCallback onTap;
+
+  @override
+  Widget build(BuildContext context) {
+    final colorScheme = Theme.of(context).colorScheme;
+    final labelColor = color;
+    final contrastColor = labelColor == null
+        ? colorScheme.onSecondaryContainer
+        : labelColor.computeLuminance() > 0.5
+            ? Colors.black
+            : Colors.white;
+    final backgroundColor = selected
+        ? labelColor ?? colorScheme.secondaryContainer
+        : labelColor?.withValues(alpha: 0.14) ??
+            colorScheme.surfaceContainerHighest;
+    final foregroundColor = selected ? contrastColor : colorScheme.onSurface;
+    final borderColor = selected
+        ? labelColor ?? colorScheme.secondary
+        : labelColor?.withValues(alpha: 0.72) ?? colorScheme.outlineVariant;
+
+    return Material(
+      color: Colors.transparent,
+      shape: const StadiumBorder(),
+      clipBehavior: Clip.antiAlias,
+      child: InkWell(
+        customBorder: const StadiumBorder(),
+        onTap: enabled ? onTap : null,
+        child: AnimatedContainer(
+          duration: const Duration(milliseconds: 140),
+          curve: Curves.easeOut,
+          padding: const EdgeInsets.symmetric(horizontal: 10, vertical: 7),
+          decoration: ShapeDecoration(
+            color: backgroundColor,
+            shape: StadiumBorder(
+              side: BorderSide(color: borderColor),
+            ),
+          ),
+          child: Row(
+            mainAxisSize: MainAxisSize.min,
+            children: [
+              SizedBox(
+                width: 18,
+                height: 18,
+                child: AnimatedSwitcher(
+                  duration: const Duration(milliseconds: 140),
+                  child: selected
+                      ? Icon(
+                          key: const ValueKey('selected'),
+                          Icons.check_rounded,
+                          size: 17,
+                          color: contrastColor,
+                        )
+                      : Center(
+                          key: const ValueKey('idle'),
+                          child: Container(
+                            width: 9,
+                            height: 9,
+                            decoration: BoxDecoration(
+                              color: labelColor ??
+                                  colorScheme.onSurfaceVariant
+                                      .withValues(alpha: 0.72),
+                              shape: BoxShape.circle,
+                              border: Border.all(
+                                color:
+                                    colorScheme.surface.withValues(alpha: 0.8),
+                              ),
+                            ),
+                          ),
+                        ),
+                ),
+              ),
+              const SizedBox(width: 4),
+              Text(
+                name,
+                style: Theme.of(context).textTheme.labelLarge?.copyWith(
+                      color: foregroundColor,
+                    ),
+              ),
+            ],
+          ),
+        ),
+      ),
+    );
+  }
+}
+
+@Preview(name: "ActiveLabelBar")
+Widget activeLabelBarPreview() {
+  final labelSet = LabelSet(
+    name: 'Activity Labels',
+    labels: [
+      Label(name: 'Walking', color: Colors.green),
+      Label(name: 'Running', color: Colors.red),
+      Label(name: 'Sitting', color: Colors.blue),
+      Label(name: 'Standing', color: Colors.orange),
+      Label(name: 'Lying Down', color: Colors.purple),
+      Label(name: 'Cycling', color: Colors.cyan),
+    ],
+  );
+
+  return Scaffold(
+    body: Center(
+      child: ChangeNotifierProvider(
+        create: (_) =>
+            LabelProvider(labelSet)..setActiveLabel(labelSet.labels[1]),
+        child: ActiveLabelBar(
+          labelSet: labelSet,
+          selectionEnabled: true,
+        ),
+      ),
+    ),
+  );
+}
diff --git a/open_wearable/lib/widgets/sensors/local_recorder/labels/label_set_selector.dart b/open_wearable/lib/widgets/sensors/local_recorder/labels/label_set_selector.dart
new file mode 100644
index 00000000..eab5c544
--- /dev/null
+++ b/open_wearable/lib/widgets/sensors/local_recorder/labels/label_set_selector.dart
@@ -0,0 +1,72 @@
+import 'package:flutter/material.dart';
+import 'package:flutter/widget_previews.dart';
+import 'package:flutter_platform_widgets/flutter_platform_widgets.dart';
+import 'package:open_wearable/widgets/sensors/local_recorder/labels/label_sets_page.dart';
+import 'package:open_wearable/widgets/sensors/local_recorder/labels/labelset_dropdown.dart';
+import 'package:provider/provider.dart';
+
+import '../../../../view_models/label_set_provider.dart';
+
+class LabelSetSelector extends StatelessWidget {
+  const LabelSetSelector({
+    super.key,
+    this.showHelperText = true,
+  });
+
+  final bool showHelperText;
+
+  @override
+  Widget build(BuildContext context) {
+    final colorScheme = Theme.of(context).colorScheme;
+
+    return Column(
+      crossAxisAlignment: CrossAxisAlignment.start,
+      children: [
+        Row(
+          children: [
+            Expanded(
+              child: LabelSetDropdown(),
+            ),
+            const SizedBox(width: 8),
+            IconButton(
+              tooltip: 'Manage label sets',
+              icon: Icon(
+                Icons.edit_outlined,
+                color: colorScheme.primary,
+              ),
+              onPressed: () {
+                Navigator.push(
+                  context,
+                  platformPageRoute(
+                    context: context,
+                    builder: (context) => LabelSetsPage(),
+                  ),
+                );
+              },
+            ),
+          ],
+        ),
+        if (showHelperText) ...[
+          const SizedBox(height: 6),
+          Text(
+            'Pick a label set to add labels while recording.',
+            style: Theme.of(context).textTheme.bodySmall,
+          ),
+        ],
+      ],
+    );
+  }
+}
+
+@Preview(name: "LabelSetSelector")
+Widget labelSetSelectorPreview() {
+  return ChangeNotifierProvider<LabelSetProvider>(
+    create: (_) => LabelSetProvider(),
+    child: Scaffold(
+      body: Padding(
+        padding: const EdgeInsets.all(16),
+        child: LabelSetSelector(),
+      ),
+    ),
+  );
+}
diff --git a/open_wearable/lib/widgets/sensors/local_recorder/labels/label_sets_page.dart b/open_wearable/lib/widgets/sensors/local_recorder/labels/label_sets_page.dart
new file mode 100644
index 00000000..e0d92f83
--- /dev/null
+++ b/open_wearable/lib/widgets/sensors/local_recorder/labels/label_sets_page.dart
@@ -0,0 +1,146 @@
+import 'package:flutter/material.dart';
+import 'package:flutter/widget_previews.dart';
+import 'package:provider/provider.dart';
+
+import 'package:open_wearable/view_models/label_set_provider.dart';
+
+import '../../../../models/labels/label.dart';
+import '../../../../models/labels/label_set.dart';
+import 'labelset_editor_page.dart';
+
+/// A page that lists all label sets and allows managing them.
+class LabelSetsPage extends StatelessWidget {
+  const LabelSetsPage({super.key});
+
+  @override
+  Widget build(BuildContext context) {
+    final provider = context.watch<LabelSetProvider>();
+    final sets = provider.labelSets;
+    final colorScheme = Theme.of(context).colorScheme;
+
+    return Scaffold(
+      appBar: AppBar(
+        title: const Text('Label Sets'),
+        actions: [
+          IconButton(
+            tooltip: 'Create',
+            icon: const Icon(Icons.add),
+            onPressed: () async {
+              await Navigator.of(context).push(
+                MaterialPageRoute(
+                  builder: (_) => const LabelSetEditorPage(),
+                ),
+              );
+            },
+          ),
+        ],
+      ),
+      body: sets.isEmpty
+          ? const Center(
+              child: Text('No label sets yet. Tap + to create one.'),
+            )
+          : ListView.separated(
+              itemCount: sets.length,
+              separatorBuilder: (_, __) => const Divider(height: 1),
+              itemBuilder: (context, index) {
+                final set = sets[index];
+                return ListTile(
+                  title: Text(set.name),
+                  subtitle: Text('${set.labels.length} labels'),
+                  trailing: Row(
+                    mainAxisSize: MainAxisSize.min,
+                    children: [
+                      IconButton(
+                        tooltip: 'Edit',
+                        icon: const Icon(Icons.edit_outlined),
+                        onPressed: () async {
+                          await Navigator.of(context).push(
+                            MaterialPageRoute(
+                              builder: (_) =>
+                                  LabelSetEditorPage(initialSet: set),
+                            ),
+                          );
+                        },
+                      ),
+                      IconButton(
+                        tooltip: 'Delete',
+                        icon: Icon(
+                          Icons.delete_outline,
+                          color: colorScheme.error,
+                        ),
+                        onPressed: () async {
+                          final ok = await showDialog<bool>(
+                                context: context,
+                                builder: (_) => AlertDialog(
+                                  title: const Text('Delete label set?'),
+                                  content: Text(
+                                    'Delete "${set.name}"? This cannot be undone.',
+                                  ),
+                                  actions: [
+                                    TextButton(
+                                      onPressed: () =>
+                                          Navigator.pop(context, false),
+                                      child: const Text('Cancel'),
+                                    ),
+                                    TextButton(
+                                      style: TextButton.styleFrom(
+                                        foregroundColor: colorScheme.error,
+                                      ),
+                                      onPressed: () =>
+                                          Navigator.pop(context, true),
+                                      child: const Text('Delete'),
+                                    ),
+                                  ],
+                                ),
+                              ) ??
+                              false;
+
+                          if (!ok) return;
+                          if (!context.mounted) return;
+                          await context.read<LabelSetProvider>().deleteSet(set);
+                        },
+                      ),
+                    ],
+                  ),
+                  onTap: () async {
+                    await Navigator.of(context).push(
+                      MaterialPageRoute(
+                        builder: (_) => LabelSetEditorPage(initialSet: set),
+                      ),
+                    );
+                  },
+                );
+              },
+            ),
+    );
+  }
+}
+
+@Preview(name: 'LabelSetsPage')
+Widget labelSetsPagePreview() {
+  final provider = LabelSetProvider();
+  provider.addOrUpdateSet(
+    LabelSet(
+      name: 'Activities',
+      labels: [
+        Label(name: 'Walking', color: Colors.green),
+        Label(name: 'Running', color: Colors.red),
+      ],
+    ),
+  );
+  provider.addOrUpdateSet(
+    LabelSet(
+      name: 'Postures',
+      labels: [
+        Label(name: 'Sitting', color: Colors.blue),
+        Label(name: 'Standing', color: Colors.orange),
+      ],
+    ),
+  );
+  return ChangeNotifierProvider<LabelSetProvider>.value(
+    value: provider,
+    child: const Scaffold(
+      body: LabelSetsPage(),
+    ),
+  );
+}
diff --git a/open_wearable/lib/widgets/sensors/local_recorder/labels/labelset_dropdown.dart b/open_wearable/lib/widgets/sensors/local_recorder/labels/labelset_dropdown.dart
new file mode 100644
index 00000000..2853306d
--- /dev/null
+++ b/open_wearable/lib/widgets/sensors/local_recorder/labels/labelset_dropdown.dart
@@ -0,0 +1,78 @@
+import 'package:flutter/material.dart';
+import 'package:flutter/widget_previews.dart';
+import 'package:provider/provider.dart';
+
+import '../../../../models/labels/label.dart';
+import '../../../../models/labels/label_set.dart';
+import '../../../../view_models/label_set_provider.dart';
+
+class LabelSetDropdown extends StatelessWidget {
+  const LabelSetDropdown({super.key});
+
+  @override
+  Widget build(BuildContext context) {
+    return Consumer<LabelSetProvider>(
+      builder: (context, provider, _) {
+        final sets = provider.labelSets;
+        final selectedSet = provider.selectedLabelSet;
+
+        return DropdownButtonFormField<LabelSet?>(
+          key: ValueKey(selectedSet?.name ?? 'no-label-set'),
+          initialValue: selectedSet,
+          decoration: const InputDecoration(
+            hintText: 'Label set',
+            border: OutlineInputBorder(),
+          ),
+          items: [
+            const DropdownMenuItem(
+              value: null,
+              child: Text('No Labels'),
+            ),
+            ...sets.map(
+              (set) => DropdownMenuItem(
+                value: set,
+                child: Text(set.name),
+              ),
+            ),
+          ],
+          onChanged: (value) async {
+            provider.selectLabelSet(value);
+          },
+        );
+      },
+    );
+  }
+}
+
+@Preview(name: 'LabelSetDropdown')
+Widget labelSetDropdownPreview() {
+  final labelSet1 = LabelSet(
+    name: 'Activities',
+    labels: [
+      Label(name: 'Walking', color: Colors.green),
+      Label(name: 'Running', color: Colors.red),
+    ],
+  );
+
+  final labelSet2 = LabelSet(
+    name: 'Postures',
+    labels: [
+      Label(name: 'Sitting', color: Colors.blue),
+      Label(name: 'Standing', color: Colors.orange),
+    ],
+  );
+
+  return ChangeNotifierProvider(
+    create: (_) => LabelSetProvider()
+      ..addOrUpdateSet(labelSet1)
+      ..addOrUpdateSet(labelSet2),
+    child: MaterialApp(
+      home: Scaffold(
+        body: Padding(
+          padding: const EdgeInsets.all(16.0),
+          child: LabelSetDropdown(),
+        ),
+      ),
+    ),
+  );
+}
diff --git a/open_wearable/lib/widgets/sensors/local_recorder/labels/labelset_editor_page.dart b/open_wearable/lib/widgets/sensors/local_recorder/labels/labelset_editor_page.dart
new file mode 100644
index 00000000..227c4957
--- /dev/null
+++ b/open_wearable/lib/widgets/sensors/local_recorder/labels/labelset_editor_page.dart
@@ -0,0 +1,575 @@
+import 'package:flutter/material.dart';
+import 'package:flutter/widget_previews.dart';
+import 'package:provider/provider.dart';
+
+import 'package:open_wearable/models/labels/label.dart';
+import 'package:open_wearable/models/labels/label_set.dart';
+import 'package:open_wearable/view_models/label_set_provider.dart';
+
+const _labelColors = <Color>[
+  Colors.red,
+  Colors.pink,
+  Colors.purple,
+  Colors.deepPurple,
+  Colors.indigo,
+  Colors.blue,
+  Colors.lightBlue,
+  Colors.cyan,
+  Colors.teal,
+  Colors.green,
+  Colors.lightGreen,
+  Colors.lime,
+  Colors.yellow,
+  Colors.amber,
+  Colors.orange,
+  Colors.deepOrange,
+  Colors.brown,
+  Colors.grey,
+  Colors.blueGrey,
+  Colors.black,
+];
+
+/// A page for creating or editing a label set.
+class LabelSetEditorPage extends StatefulWidget {
+  const LabelSetEditorPage({
+    super.key,
+    this.initialSet,
+  }) : isCreate = initialSet == null;
+
+  final LabelSet? initialSet;
+  final bool isCreate;
+
+  @override
+  State<LabelSetEditorPage> createState() => _LabelSetEditorPageState();
+}
+
+class _LabelSetEditorPageState extends State<LabelSetEditorPage> {
+  late final TextEditingController _nameController;
+  final List<Label> _labels = [];
+  LabelSet? _persistedSet;
+  Future<void> _persistQueue = Future<void>.value();
+  late LabelSetProvider _labelSetProvider;
+  late bool _isCreateMode;
+
+  @override
+  void initState() {
+    super.initState();
+    _isCreateMode = widget.isCreate;
+    _persistedSet = widget.initialSet;
+    _nameController =
+        TextEditingController(text: widget.initialSet?.name ?? '');
+    _nameController.addListener(_handleNameChanged);
+    _labels.addAll(widget.initialSet?.labels ?? const []);
+  }
+
+  @override
+  void didChangeDependencies() {
+    super.didChangeDependencies();
+    _labelSetProvider = context.read<LabelSetProvider>();
+  }
+
+  @override
+  void dispose() {
+    _nameController.removeListener(_handleNameChanged);
+    _nameController.dispose();
+    super.dispose();
+  }
+
+  void _handleNameChanged() {
+    _persistCurrentSet();
+    setState(() {});
+  }
+
+  bool get _hasNewSetWithoutLabels =>
+      _isCreateMode &&
+      _nameController.text.trim().isNotEmpty &&
+      _labels.isEmpty;
+
+  bool get _hasLabelsWithoutSetName =>
+      _nameController.text.trim().isEmpty && _labels.isNotEmpty;
+
+  bool get _requiresLeaveConfirmation =>
+      _hasNewSetWithoutLabels || _hasLabelsWithoutSetName;
+
+  LabelSet? _currentSet() {
+    final name = _nameController.text.trim();
+    if (name.isEmpty || (_isCreateMode && _labels.isEmpty)) {
+      return null;
+    }
+
+    return LabelSet(
+      name: name,
+      labels: List<Label>.unmodifiable(_labels),
+    );
+  }
+
+  Future<void> _persistCurrentSet() {
+    final set = _currentSet();
+    if (set == null) {
+      if (_isCreateMode && _persistedSet != null) {
+        return _deletePersistedDraft();
+      }
+      return _persistQueue;
+    }
+
+    _persistQueue = _persistQueue.then((_) async {
+      final previousSet = _persistedSet;
+      if (previousSet == null) {
+        await _labelSetProvider.addOrUpdateSet(set);
+      } else {
+        await _labelSetProvider.replaceSet(previousSet, set);
+      }
+      _persistedSet = set;
+    }).catchError((Object error, StackTrace stackTrace) {
+      _reportAutosaveError(error, stackTrace);
+      return null;
+    });
+
+    return _persistQueue;
+  }
+
+  Future<void> _deletePersistedDraft() {
+    _persistQueue = _persistQueue.then((_) async {
+      final previousSet = _persistedSet;
+      if (previousSet == null) return;
+
+      await _labelSetProvider.deleteSet(previousSet);
+      _persistedSet = null;
+    }).catchError((Object error, StackTrace stackTrace) {
+      _reportAutosaveError(error, stackTrace);
+      return null;
+    });
+
+    return _persistQueue;
+  }
+
+  void _reportAutosaveError(Object error, StackTrace stackTrace) {
+    FlutterError.reportError(
+      FlutterErrorDetails(
+        exception: error,
+        stack: stackTrace,
+        library: 'label set editor',
+        context: ErrorDescription('while autosaving a label set'),
+      ),
+    );
+  }
+
+  Future<void> _confirmCreateSet() async {
+    if (_currentSet() == null) return;
+
+    await _persistCurrentSet();
+    if (!mounted || _persistedSet == null) return;
+
+    setState(() {
+      _isCreateMode = false;
+    });
+  }
+
+  Future<void> _handlePopInvoked(bool didPop) async {
+    if (didPop) return;
+
+    final shouldLeave = await _confirmLeaveUnsavableSet();
+    if (!mounted || !shouldLeave) return;
+
+    Navigator.of(context).pop();
+  }
+
+  Future<bool> _confirmLeaveUnsavableSet() async {
+    if (!_requiresLeaveConfirmation) {
+      return true;
+    }
+
+    final title = _hasLabelsWithoutSetName
+        ? 'Leave without set name?'
+        : 'Leave without labels?';
+    final message = _hasLabelsWithoutSetName
+        ? 'This label set cannot be saved because no set name was given. Leave anyway?'
+        : 'No labels have been added to this label set, so no set will be created. Leave anyway?';
+
+    return await showDialog<bool>(
+          context: context,
+          builder: (_) => AlertDialog(
+            title: Text(title),
+            content: Text(message),
+            actions: [
+              TextButton(
+                onPressed: () => Navigator.pop(context, false),
+                child: const Text('Stay'),
+              ),
+              TextButton(
+                onPressed: () => Navigator.pop(context, true),
+                child: const Text('Leave'),
+              ),
+            ],
+          ),
+        ) ??
+        false;
+  }
+
+  Future<void> _addOrEditLabel({Label? existing, int? index}) async {
+    final unavailableColorValues = _labels
+        .asMap()
+        .entries
+        .where((entry) => entry.key != index)
+        .map((entry) => entry.value.color.toARGB32())
+        .toSet();
+    final result = await showDialog<_LabelDialogResult>(
+      context: context,
+      builder: (_) => _LabelDialog(
+        existing: existing,
+        unavailableColorValues: unavailableColorValues,
+      ),
+    );
+
+    if (result == null) return;
+
+    setState(() {
+      final updated = Label(name: result.name, color: result.color);
+      if (existing == null) {
+        _labels.add(updated);
+      } else if (index != null) {
+        _labels[index] = updated;
+      }
+    });
+    _persistCurrentSet();
+  }
+
+  Future<void> _confirmAndDeleteLabel({
+    required Label label,
+    required int index,
+  }) async {
+    final colorScheme = Theme.of(context).colorScheme;
+    final shouldDelete = await showDialog<bool>(
+          context: context,
+          builder: (_) => AlertDialog(
+            title: const Text('Delete label?'),
+            content: Text(
+              'Delete "${label.name}" from this label set?',
+            ),
+            actions: [
+              TextButton(
+                onPressed: () => Navigator.pop(context, false),
+                child: const Text('Cancel'),
+              ),
+              TextButton(
+                style: TextButton.styleFrom(
+                  foregroundColor: colorScheme.error,
+                ),
+                onPressed: () => Navigator.pop(context, true),
+                child: const Text('Delete'),
+              ),
+            ],
+          ),
+        ) ??
+        false;
+
+    if (!mounted || !shouldDelete) return;
+    if (index >= _labels.length || _labels[index] != label) return;
+
+    setState(() => _labels.removeAt(index));
+    _persistCurrentSet();
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final title = _isCreateMode ? 'Create label set' : 'Edit label set';
+    final canConfirmCreate = _isCreateMode && _currentSet() != null;
+
+    return PopScope(
+      canPop: !_requiresLeaveConfirmation,
+      onPopInvokedWithResult: (didPop, _) => _handlePopInvoked(didPop),
+      child: Scaffold(
+        appBar: AppBar(
+          title: Text(title),
+          actions: [
+            if (_isCreateMode)
+              IconButton(
+                tooltip: 'Save',
+                icon: const Icon(Icons.check),
+                onPressed: canConfirmCreate ? _confirmCreateSet : null,
+              ),
+          ],
+        ),
+        body: ListView(
+          padding: const EdgeInsets.all(16),
+          children: [
+            TextField(
+              controller: _nameController,
+              decoration: const InputDecoration(
+                labelText: 'Set name',
+                border: OutlineInputBorder(),
+              ),
+            ),
+            const SizedBox(height: 16),
+            Row(
+              children: [
+                Expanded(
+                  child: Text(
+                    'Labels',
+                    style: Theme.of(context).textTheme.titleMedium,
+                  ),
+                ),
+                ElevatedButton.icon(
+                  icon: const Icon(Icons.add),
+                  label: const Text('Add'),
+                  onPressed: _addOrEditLabel,
+                ),
+              ],
+            ),
+            const SizedBox(height: 8),
+            if (_labels.isEmpty)
+              const Padding(
+                padding: EdgeInsets.only(top: 12),
+                child: Text('No labels yet. Tap “Add”.'),
+              )
+            else
+              ..._labels.asMap().entries.map((entry) {
+                final idx = entry.key;
+                final label = entry.value;
+                return Card(
+                  child: ListTile(
+                    leading: CircleAvatar(
+                      backgroundColor: label.color,
+                      child: const SizedBox.shrink(),
+                    ),
+                    title: Text(label.name),
+                    trailing: Row(
+                      mainAxisSize: MainAxisSize.min,
+                      children: [
+                        IconButton(
+                          tooltip: 'Edit',
+                          icon: const Icon(Icons.edit_outlined),
+                          onPressed: () =>
+                              _addOrEditLabel(existing: label, index: idx),
+                        ),
+                        IconButton(
+                          tooltip: 'Delete',
+                          icon: Icon(
+                            Icons.delete_outline,
+                            color: Theme.of(context).colorScheme.error,
+                          ),
+                          onPressed: () => _confirmAndDeleteLabel(
+                            label: label,
+                            index: idx,
+                          ),
+                        ),
+                      ],
+                    ),
+                  ),
+                );
+              }),
+          ],
+        ),
+      ),
+    );
+  }
+}
+
+class _LabelDialogResult {
+  _LabelDialogResult({required this.name, required this.color});
+  final String name;
+  final Color color;
+}
+
+class _LabelDialog extends StatefulWidget {
+  const _LabelDialog({
+    this.existing,
+    this.unavailableColorValues = const <int>{},
+  });
+
+  final Label? existing;
+  final Set<int> unavailableColorValues;
+
+  @override
+  State<_LabelDialog> createState() => _LabelDialogState();
+}
+
+class _LabelDialogState extends State<_LabelDialog> {
+  late final TextEditingController _nameController;
+  late Color? _selectedColor;
+
+  @override
+  void initState() {
+    super.initState();
+    _nameController = TextEditingController(text: widget.existing?.name ?? '');
+    _selectedColor = widget.existing?.color ?? _firstAvailableColor();
+  }
+
+  @override
+  void dispose() {
+    _nameController.dispose();
+    super.dispose();
+  }
+
+  Color? _firstAvailableColor() {
+    for (final color in _labelColors) {
+      if (_isColorAvailable(color)) {
+        return color;
+      }
+    }
+    return null;
+  }
+
+  bool _isColorAvailable(Color? color) {
+    if (color == null) return false;
+    return !widget.unavailableColorValues.contains(color.toARGB32());
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return AlertDialog(
+      title: Text(widget.existing == null ? 'Add label' : 'Edit label'),
+      content: Column(
+        mainAxisSize: MainAxisSize.min,
+        children: [
+          TextField(
+            controller: _nameController,
+            decoration: const InputDecoration(
+              labelText: 'Label name',
+              border: OutlineInputBorder(),
+            ),
+          ),
+          const SizedBox(height: 12),
+          _ColorPickerRow(
+            selected: _selectedColor,
+            unavailableColorValues: widget.unavailableColorValues,
+            onChanged: (color) => setState(() => _selectedColor = color),
+          ),
+        ],
+      ),
+      actions: [
+        TextButton(
+          onPressed: () => Navigator.pop(context, null),
+          child: const Text('Cancel'),
+        ),
+        ValueListenableBuilder<TextEditingValue>(
+          valueListenable: _nameController,
+          builder: (context, value, _) {
+            final selectedColor = _selectedColor;
+            final canSave = value.text.trim().isNotEmpty &&
+                _isColorAvailable(selectedColor);
+            return TextButton(
+              onPressed: canSave
+                  ? () {
+                      final color = selectedColor;
+                      if (color == null) return;
+                      Navigator.pop(
+                        context,
+                        _LabelDialogResult(
+                          name: value.text.trim(),
+                          color: color,
+                        ),
+                      );
+                    }
+                  : null,
+              child: const Text('Save'),
+            );
+          },
+        ),
+      ],
+    );
+  }
+}
+
+class _ColorPickerRow extends StatefulWidget {
+  const _ColorPickerRow({
+    required this.selected,
+    required this.unavailableColorValues,
+    required this.onChanged,
+  });
+
+  final Color? selected;
+  final Set<int> unavailableColorValues;
+  final ValueChanged<Color> onChanged;
+
+  @override
+  State<_ColorPickerRow> createState() => _ColorPickerRowState();
+}
+
+class _ColorPickerRowState extends State<_ColorPickerRow> {
+  @override
+  Widget build(BuildContext context) {
+    final colorScheme = Theme.of(context).colorScheme;
+    return Wrap(
+      spacing: 8,
+      runSpacing: 8,
+      children: _labelColors.map((c) {
+        final colorValue = c.toARGB32();
+        final isUnavailable =
+            widget.unavailableColorValues.contains(colorValue);
+        final isSelected =
+            !isUnavailable && widget.selected?.toARGB32() == colorValue;
+        final checkColor =
+            c.computeLuminance() > 0.5 ? Colors.black : Colors.white;
+
+        return Tooltip(
+          message:
+              isUnavailable ? 'Already used in this label set' : 'Select color',
+          child: Material(
+            key: ValueKey('label-color-$colorValue'),
+            color: Colors.transparent,
+            shape: const CircleBorder(),
+            clipBehavior: Clip.antiAlias,
+            child: InkWell(
+              customBorder: const CircleBorder(),
+              onTap: isUnavailable ? null : () => widget.onChanged(c),
+              child: SizedBox(
+                width: 32,
+                height: 32,
+                child: Stack(
+                  alignment: Alignment.center,
+                  children: [
+                    Opacity(
+                      opacity: isUnavailable ? 0.32 : 1,
+                      child: Container(
+                        width: 28,
+                        height: 28,
+                        decoration: BoxDecoration(
+                          color: c,
+                          shape: BoxShape.circle,
+                          border: Border.all(
+                            width: isSelected ? 3 : 1,
+                            color: isSelected
+                                ? colorScheme.primary
+                                : colorScheme.outlineVariant,
+                          ),
+                        ),
+                      ),
+                    ),
+                    if (isUnavailable)
+                      Icon(
+                        Icons.block_rounded,
+                        size: 18,
+                        color: colorScheme.onSurfaceVariant,
+                      )
+                    else if (isSelected)
+                      Icon(
+                        Icons.check_rounded,
+                        size: 18,
+                        color: checkColor,
+                      ),
+                  ],
+                ),
+              ),
+            ),
+          ),
+        );
+      }).toList(),
+    );
+  }
+}
+
+@Preview(name: 'LabelSetEditorPage')
+Widget labelSetEditorPagePreview() {
+  return const MaterialApp(
+    home: LabelSetEditorPage(
+      initialSet: LabelSet(
+        name: 'Sample Set',
+        labels: [
+          Label(name: 'Walking', color: Colors.green),
+          Label(name: 'Running', color: Colors.red),
+        ],
+      ),
+    ),
+  );
+}
diff --git a/open_wearable/lib/widgets/sensors/local_recorder/local_recorder_all_recordings_page.dart b/open_wearable/lib/widgets/sensors/local_recorder/local_recorder_all_recordings_page.dart
index 47b4c136..a5d56910 100644
--- a/open_wearable/lib/widgets/sensors/local_recorder/local_recorder_all_recordings_page.dart
+++ b/open_wearable/lib/widgets/sensors/local_recorder/local_recorder_all_recordings_page.dart
@@ -195,6 +195,8 @@ class _LocalRecorderAllRecordingsPageState
 
   @override
   Widget build(BuildContext context) {
+    final colorScheme = Theme.of(context).colorScheme;
+
     return PlatformScaffold(
       appBar: PlatformAppBar(
         title: Text(
@@ -210,7 +212,10 @@ class _LocalRecorderAllRecordingsPageState
             ),
           if (_selectionMode && _selectedFolderPaths.isNotEmpty)
             PlatformIconButton(
-              icon: const Icon(Icons.delete_outline),
+              icon: Icon(
+                Icons.delete_outline,
+                color: colorScheme.error,
+              ),
               onPressed: _isBusy ? null : _deleteSelectedFolders,
             ),
           if (_selectionMode)
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 7658918c..ee61f62c 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
@@ -6,10 +6,12 @@ class LocalRecorderRecordingCard extends StatelessWidget {
   final bool hasSensorsConnected;
   final bool canStartRecording;
   final bool isHandlingStopAction;
+  final bool turnOffSensorsWhenStopping;
   final String elapsedRecordingLabel;
   final VoidCallback? onStartRecording;
-  final VoidCallback? onStopAndTurnOff;
-  final VoidCallback? onStopRecordingOnly;
+  final ValueChanged<bool>? onTurnOffSensorsWhenStoppingChanged;
+  final VoidCallback? onStopRecording;
+  final Widget? labelControls;
 
   const LocalRecorderRecordingCard({
     super.key,
@@ -17,10 +19,12 @@ class LocalRecorderRecordingCard extends StatelessWidget {
     required this.hasSensorsConnected,
     required this.canStartRecording,
     required this.isHandlingStopAction,
+    this.turnOffSensorsWhenStopping = false,
     required this.elapsedRecordingLabel,
     required this.onStartRecording,
-    required this.onStopAndTurnOff,
-    required this.onStopRecordingOnly,
+    this.onTurnOffSensorsWhenStoppingChanged,
+    required this.onStopRecording,
+    this.labelControls,
   });
 
   @override
@@ -49,132 +53,307 @@ class LocalRecorderRecordingCard extends StatelessWidget {
             : 'Connect a wearable with sensors to start recording.';
 
     return Card(
+      margin: EdgeInsets.zero,
       child: Padding(
-        padding: const EdgeInsets.all(14),
+        padding: const EdgeInsets.all(16),
         child: Column(
           crossAxisAlignment: CrossAxisAlignment.start,
           children: [
-            Row(
-              crossAxisAlignment: CrossAxisAlignment.start,
-              children: [
-                Container(
-                  width: 38,
-                  height: 38,
-                  decoration: BoxDecoration(
-                    color: statusColor.withValues(alpha: 0.14),
-                    borderRadius: BorderRadius.circular(12),
-                  ),
-                  child: isRecording
-                      ? const Center(
-                          child: RecordingActivityIndicator(
-                            size: 20,
-                            showIdleOutline: false,
-                            padding: EdgeInsets.zero,
-                          ),
-                        )
-                      : Icon(statusIcon, color: statusColor, size: 20),
-                ),
-                const SizedBox(width: 12),
-                Expanded(
-                  child: Column(
-                    crossAxisAlignment: CrossAxisAlignment.start,
-                    children: [
-                      Text(
-                        'Local Recorder',
-                        style: theme.textTheme.titleMedium?.copyWith(
-                          fontWeight: FontWeight.w700,
-                        ),
-                      ),
-                      const SizedBox(height: 2),
-                      Text(
-                        statusTitle,
-                        style: theme.textTheme.titleSmall?.copyWith(
-                          color: statusColor,
-                          fontWeight: FontWeight.w700,
-                        ),
-                      ),
-                      const SizedBox(height: 2),
-                      Text(
-                        statusSubtitle,
-                        style: theme.textTheme.bodySmall?.copyWith(
-                          color: colorScheme.onSurfaceVariant,
-                        ),
-                      ),
-                    ],
-                  ),
-                ),
-                if (isRecording)
-                  Container(
-                    padding: const EdgeInsets.symmetric(
-                      horizontal: 10,
-                      vertical: 8,
-                    ),
-                    decoration: BoxDecoration(
-                      color: colorScheme.errorContainer.withValues(alpha: 0.45),
-                      borderRadius: BorderRadius.circular(10),
-                    ),
-                    child: Text(
-                      elapsedRecordingLabel,
-                      style: theme.textTheme.titleSmall?.copyWith(
-                        color: colorScheme.onErrorContainer,
-                        fontWeight: FontWeight.w700,
-                      ),
-                    ),
-                  ),
-              ],
+            _RecorderHeader(
+              isRecording: isRecording,
+              icon: statusIcon,
+              color: statusColor,
+              title: statusTitle,
+              subtitle: statusSubtitle,
             ),
-            const SizedBox(height: 14),
-            if (!isRecording)
-              SizedBox(
-                width: double.infinity,
-                child: FilledButton.icon(
-                  onPressed: canStartRecording ? onStartRecording : null,
-                  icon: const Icon(Icons.play_arrow),
-                  label: const Text('Start Recording'),
-                ),
+            const SizedBox(height: 16),
+            _RecorderActionArea(
+              isRecording: isRecording,
+              hasSensorsConnected: hasSensorsConnected,
+              canStartRecording: canStartRecording,
+              isHandlingStopAction: isHandlingStopAction,
+              turnOffSensorsWhenStopping: turnOffSensorsWhenStopping,
+              elapsedRecordingLabel: elapsedRecordingLabel,
+              onStartRecording: onStartRecording,
+              onTurnOffSensorsWhenStoppingChanged:
+                  onTurnOffSensorsWhenStoppingChanged,
+              onStopRecording: onStopRecording,
+            ),
+            if (labelControls != null) ...[
+              const SizedBox(height: 16),
+              Divider(
+                height: 1,
+                color: colorScheme.outlineVariant,
               ),
-            if (!isRecording && !hasSensorsConnected)
-              Padding(
-                padding: const EdgeInsets.only(top: 8),
-                child: Text(
-                  'No connected sensors detected yet.',
-                  style: theme.textTheme.bodySmall?.copyWith(
-                    color: colorScheme.onSurfaceVariant,
+              const SizedBox(height: 14),
+              labelControls!,
+            ],
+          ],
+        ),
+      ),
+    );
+  }
+}
+
+class _RecorderHeader extends StatelessWidget {
+  const _RecorderHeader({
+    required this.isRecording,
+    required this.icon,
+    required this.color,
+    required this.title,
+    required this.subtitle,
+  });
+
+  final bool isRecording;
+  final IconData icon;
+  final Color color;
+  final String title;
+  final String subtitle;
+
+  @override
+  Widget build(BuildContext context) {
+    final theme = Theme.of(context);
+    final colorScheme = theme.colorScheme;
+
+    return Row(
+      crossAxisAlignment: CrossAxisAlignment.start,
+      children: [
+        Container(
+          width: 38,
+          height: 38,
+          decoration: BoxDecoration(
+            color: color.withValues(alpha: 0.14),
+            borderRadius: BorderRadius.circular(10),
+          ),
+          child: isRecording
+              ? const Center(
+                  child: RecordingActivityIndicator(
+                    size: 20,
+                    showIdleOutline: false,
+                    padding: EdgeInsets.zero,
                   ),
+                )
+              : Icon(icon, color: color, size: 20),
+        ),
+        const SizedBox(width: 12),
+        Expanded(
+          child: Column(
+            crossAxisAlignment: CrossAxisAlignment.start,
+            children: [
+              Text(
+                'Local Recorder',
+                style: theme.textTheme.titleMedium?.copyWith(
+                  fontWeight: FontWeight.w700,
                 ),
               ),
-            if (isRecording) ...[
-              Row(
-                children: [
-                  Expanded(
-                    child: FilledButton.tonalIcon(
-                      style: FilledButton.styleFrom(
-                        foregroundColor: colorScheme.error,
-                        backgroundColor:
-                            colorScheme.errorContainer.withValues(alpha: 0.45),
-                      ),
-                      onPressed:
-                          isHandlingStopAction ? null : onStopAndTurnOff,
-                      icon: const Icon(Icons.power_settings_new),
-                      label: const Text('Stop + Off'),
-                    ),
-                  ),
-                  const SizedBox(width: 8),
-                  Expanded(
-                    child: FilledButton.icon(
-                      style: FilledButton.styleFrom(
-                        backgroundColor: colorScheme.error,
-                        foregroundColor: colorScheme.onError,
-                      ),
-                      onPressed:
-                          isHandlingStopAction ? null : onStopRecordingOnly,
-                      icon: const Icon(Icons.stop),
-                      label: const Text('Stop Recording'),
-                    ),
-                  ),
-                ],
+              const SizedBox(height: 2),
+              Text(
+                title,
+                style: theme.textTheme.titleSmall?.copyWith(
+                  color: color,
+                  fontWeight: FontWeight.w700,
+                ),
+              ),
+              const SizedBox(height: 2),
+              Text(
+                subtitle,
+                style: theme.textTheme.bodySmall?.copyWith(
+                  color: colorScheme.onSurfaceVariant,
+                ),
               ),
             ],
+          ),
+        ),
+      ],
+    );
+  }
+}
+
+class _RecorderActionArea extends StatelessWidget {
+  const _RecorderActionArea({
+    required this.isRecording,
+    required this.hasSensorsConnected,
+    required this.canStartRecording,
+    required this.isHandlingStopAction,
+    required this.turnOffSensorsWhenStopping,
+    required this.elapsedRecordingLabel,
+    required this.onStartRecording,
+    required this.onTurnOffSensorsWhenStoppingChanged,
+    required this.onStopRecording,
+  });
+
+  final bool isRecording;
+  final bool hasSensorsConnected;
+  final bool canStartRecording;
+  final bool isHandlingStopAction;
+  final bool turnOffSensorsWhenStopping;
+  final String elapsedRecordingLabel;
+  final VoidCallback? onStartRecording;
+  final ValueChanged<bool>? onTurnOffSensorsWhenStoppingChanged;
+  final VoidCallback? onStopRecording;
+
+  @override
+  Widget build(BuildContext context) {
+    if (!isRecording) {
+      return _IdleRecorderActions(
+        hasSensorsConnected: hasSensorsConnected,
+        canStartRecording: canStartRecording,
+        onStartRecording: onStartRecording,
+      );
+    }
+
+    return _RecordingRecorderActions(
+      elapsedRecordingLabel: elapsedRecordingLabel,
+      isHandlingStopAction: isHandlingStopAction,
+      turnOffSensorsWhenStopping: turnOffSensorsWhenStopping,
+      onTurnOffSensorsWhenStoppingChanged: onTurnOffSensorsWhenStoppingChanged,
+      onStopRecording: onStopRecording,
+    );
+  }
+}
+
+class _IdleRecorderActions extends StatelessWidget {
+  const _IdleRecorderActions({
+    required this.hasSensorsConnected,
+    required this.canStartRecording,
+    required this.onStartRecording,
+  });
+
+  final bool hasSensorsConnected;
+  final bool canStartRecording;
+  final VoidCallback? onStartRecording;
+
+  @override
+  Widget build(BuildContext context) {
+    final theme = Theme.of(context);
+    final colorScheme = theme.colorScheme;
+
+    return Column(
+      crossAxisAlignment: CrossAxisAlignment.start,
+      children: [
+        SizedBox(
+          width: double.infinity,
+          child: FilledButton.icon(
+            onPressed: canStartRecording ? onStartRecording : null,
+            icon: const Icon(Icons.play_arrow),
+            label: const Text('Start Recording'),
+          ),
+        ),
+        if (!hasSensorsConnected)
+          Padding(
+            padding: const EdgeInsets.only(top: 8),
+            child: Text(
+              'No connected sensors detected yet.',
+              style: theme.textTheme.bodySmall?.copyWith(
+                color: colorScheme.onSurfaceVariant,
+              ),
+            ),
+          ),
+      ],
+    );
+  }
+}
+
+class _RecordingRecorderActions extends StatelessWidget {
+  const _RecordingRecorderActions({
+    required this.elapsedRecordingLabel,
+    required this.isHandlingStopAction,
+    required this.turnOffSensorsWhenStopping,
+    required this.onTurnOffSensorsWhenStoppingChanged,
+    required this.onStopRecording,
+  });
+
+  final String elapsedRecordingLabel;
+  final bool isHandlingStopAction;
+  final bool turnOffSensorsWhenStopping;
+  final ValueChanged<bool>? onTurnOffSensorsWhenStoppingChanged;
+  final VoidCallback? onStopRecording;
+
+  @override
+  Widget build(BuildContext context) {
+    final theme = Theme.of(context);
+    final colorScheme = theme.colorScheme;
+
+    return Column(
+      crossAxisAlignment: CrossAxisAlignment.start,
+      children: [
+        Text(
+          'Elapsed Time',
+          style: theme.textTheme.labelMedium?.copyWith(
+            color: colorScheme.onSurfaceVariant,
+          ),
+        ),
+        const SizedBox(height: 2),
+        Text(
+          elapsedRecordingLabel,
+          style: theme.textTheme.headlineMedium?.copyWith(
+            fontWeight: FontWeight.w700,
+            color: colorScheme.onSurface,
+          ),
+        ),
+        const SizedBox(height: 14),
+        _StopSensorsOption(
+          value: turnOffSensorsWhenStopping,
+          onChanged:
+              isHandlingStopAction ? null : onTurnOffSensorsWhenStoppingChanged,
+        ),
+        const SizedBox(height: 10),
+        SizedBox(
+          width: double.infinity,
+          child: FilledButton.icon(
+            style: FilledButton.styleFrom(
+              backgroundColor: colorScheme.error,
+              foregroundColor: colorScheme.onError,
+            ),
+            onPressed: isHandlingStopAction ? null : onStopRecording,
+            icon: const Icon(Icons.stop),
+            label: const Text('Stop Recording'),
+          ),
+        ),
+      ],
+    );
+  }
+}
+
+class _StopSensorsOption extends StatelessWidget {
+  const _StopSensorsOption({
+    required this.value,
+    required this.onChanged,
+  });
+
+  final bool value;
+  final ValueChanged<bool>? onChanged;
+
+  @override
+  Widget build(BuildContext context) {
+    final theme = Theme.of(context);
+    final colorScheme = theme.colorScheme;
+
+    return InkWell(
+      borderRadius: BorderRadius.circular(8),
+      onTap: onChanged == null ? null : () => onChanged!(!value),
+      child: Padding(
+        padding: const EdgeInsets.symmetric(horizontal: 2, vertical: 4),
+        child: Row(
+          children: [
+            Checkbox(
+              value: value,
+              onChanged: onChanged == null
+                  ? null
+                  : (checked) => onChanged!(checked ?? false),
+              visualDensity: VisualDensity.compact,
+              materialTapTargetSize: MaterialTapTargetSize.shrinkWrap,
+            ),
+            const SizedBox(width: 8),
+            Expanded(
+              child: Text(
+                'Turn off sensors after stopping',
+                style: theme.textTheme.bodySmall?.copyWith(
+                  color: colorScheme.onSurfaceVariant,
+                  fontWeight: FontWeight.w600,
+                ),
+              ),
+            ),
           ],
         ),
       ),
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 031205d3..e368b8c7 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
@@ -1,4 +1,5 @@
 import 'package:flutter/material.dart';
+import 'package:open_wearable/widgets/recording_activity_indicator.dart';
 import 'package:open_wearable/widgets/sensors/local_recorder/local_recorder_models.dart';
 import 'package:open_wearable/widgets/sensors/sensor_page_spacing.dart';
 
@@ -61,13 +62,10 @@ class LocalRecorderRecordingFolderCard extends StatelessWidget {
               isCurrentRecording ? 'Active recording' : updatedLabel,
             ),
             trailing: isCurrentRecording
-                ? SizedBox(
-                    width: 18,
-                    height: 18,
-                    child: CircularProgressIndicator(
-                      strokeWidth: 2,
-                      color: colorScheme.error,
-                    ),
+                ? const RecordingActivityIndicator(
+                    size: 14,
+                    showIdleOutline: false,
+                    padding: EdgeInsets.zero,
                   )
                 : Row(
                     mainAxisSize: MainAxisSize.min,
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 b3a5765b..96e3ba57 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
@@ -4,10 +4,14 @@ import 'package:flutter/material.dart';
 import 'package:flutter_platform_widgets/flutter_platform_widgets.dart';
 import 'package:go_router/go_router.dart';
 import 'package:logger/logger.dart';
+import 'package:open_wearable/models/labels/label_set.dart';
 import 'package:open_wearable/widgets/sensors/local_recorder/local_recorder_dialogs.dart';
 import 'package:provider/provider.dart';
+import 'package:open_wearable/view_models/label_set_provider.dart';
 import 'package:open_wearable/view_models/sensor_recorder_provider_facade.dart';
 import 'package:open_wearable/view_models/wearables_provider.dart';
+import 'package:open_wearable/widgets/sensors/local_recorder/labels/active_label_bar.dart';
+import 'package:open_wearable/widgets/sensors/local_recorder/labels/label_set_selector.dart';
 import 'package:open_wearable/widgets/sensors/local_recorder/local_recorder_empty_state_card.dart';
 import 'package:open_wearable/widgets/sensors/local_recorder/local_recorder_file_actions.dart';
 import 'package:open_wearable/widgets/sensors/local_recorder/local_recorder_files.dart';
@@ -20,11 +24,6 @@ import 'package:open_wearable/widgets/sensors/sensor_page_spacing.dart';
 
 Logger _logger = Logger();
 
-enum _StopRecordingMode {
-  stopOnly,
-  stopAndTurnOffSensors,
-}
-
 // MARK: - LocalRecorderView
 
 class LocalRecorderView extends StatefulWidget {
@@ -41,6 +40,7 @@ class _LocalRecorderViewState extends State<LocalRecorderView> {
   Duration _elapsedRecording = Duration.zero;
   bool _lastRecordingState = false;
   bool _isHandlingStopAction = false;
+  bool _turnOffSensorsWhenStopping = false;
   DateTime? _activeRecordingStart;
   SensorRecorderProvider? _recorder;
 
@@ -126,23 +126,19 @@ class _LocalRecorderViewState extends State<LocalRecorderView> {
     return true;
   }
 
-  Future<void> _handleStopRecording(
-    SensorRecorderProvider recorder, {
-    required _StopRecordingMode mode,
-  }) async {
+  Future<void> _handleStopRecording(SensorRecorderProvider recorder) async {
     if (_isHandlingStopAction) return;
+    final shouldTurnOffSensors = _turnOffSensorsWhenStopping;
+
     setState(() {
       _isHandlingStopAction = true;
     });
 
-    final wearablesProvider = mode == _StopRecordingMode.stopAndTurnOffSensors
-        ? context.read<WearablesProvider>()
-        : null;
+    final wearablesProvider =
+        shouldTurnOffSensors ? context.read<WearablesProvider>() : null;
 
     try {
-      await recorder.stopRecording(
-        mode == _StopRecordingMode.stopAndTurnOffSensors,
-      );
+      await recorder.stopRecording(shouldTurnOffSensors);
       if (wearablesProvider != null) {
         final futures = wearablesProvider.sensorConfigurationProviders.values
             .map((provider) => provider.turnOffAllSensors());
@@ -166,6 +162,7 @@ class _LocalRecorderViewState extends State<LocalRecorderView> {
     _activeRecordingStart = reference;
     _recordingTimer?.cancel();
     setState(() {
+      _turnOffSensorsWhenStopping = false;
       _elapsedRecording = DateTime.now().difference(reference);
     });
     _recordingTimer = Timer.periodic(const Duration(seconds: 1), (_) {
@@ -183,6 +180,7 @@ class _LocalRecorderViewState extends State<LocalRecorderView> {
     _activeRecordingStart = null;
     if (!mounted) return;
     setState(() {
+      _turnOffSensorsWhenStopping = false;
       _elapsedRecording = Duration.zero;
     });
   }
@@ -298,6 +296,14 @@ class _LocalRecorderViewState extends State<LocalRecorderView> {
         final canStartRecording = recorder.hasSensorsConnected && !isRecording;
         final hasRecordings = _recordings.isNotEmpty;
         final latestRecording = hasRecordings ? _recordings.first : null;
+        final selectedLabelSet =
+            context.watch<LabelSetProvider>().selectedLabelSet;
+        final labelControls = !isRecording || selectedLabelSet != null
+            ? _LocalRecorderLabelSection(
+                isRecording: isRecording,
+                labelSet: selectedLabelSet,
+              )
+            : null;
 
         return SafeArea(
           top: false,
@@ -311,16 +317,16 @@ class _LocalRecorderViewState extends State<LocalRecorderView> {
                   hasSensorsConnected: recorder.hasSensorsConnected,
                   canStartRecording: canStartRecording,
                   isHandlingStopAction: _isHandlingStopAction,
+                  turnOffSensorsWhenStopping: _turnOffSensorsWhenStopping,
                   elapsedRecordingLabel: _formatDuration(_elapsedRecording),
                   onStartRecording: () => _startRecording(recorder),
-                  onStopAndTurnOff: () => _handleStopRecording(
-                    recorder,
-                    mode: _StopRecordingMode.stopAndTurnOffSensors,
-                  ),
-                  onStopRecordingOnly: () => _handleStopRecording(
-                    recorder,
-                    mode: _StopRecordingMode.stopOnly,
-                  ),
+                  onTurnOffSensorsWhenStoppingChanged: (value) {
+                    setState(() {
+                      _turnOffSensorsWhenStopping = value;
+                    });
+                  },
+                  onStopRecording: () => _handleStopRecording(recorder),
+                  labelControls: labelControls,
                 ),
                 const SizedBox(height: SensorPageSpacing.sectionGap),
                 Text(
@@ -396,6 +402,44 @@ class _LocalRecorderViewState extends State<LocalRecorderView> {
   }
 }
 
+class _LocalRecorderLabelSection extends StatelessWidget {
+  const _LocalRecorderLabelSection({
+    required this.isRecording,
+    required this.labelSet,
+  });
+
+  final bool isRecording;
+  final LabelSet? labelSet;
+
+  @override
+  Widget build(BuildContext context) {
+    final theme = Theme.of(context);
+    final set = labelSet;
+
+    return Column(
+      crossAxisAlignment: CrossAxisAlignment.start,
+      children: [
+        if (!isRecording) const LabelSetSelector(showHelperText: false),
+        if (set != null) ...[
+          if (!isRecording) const SizedBox(height: 14),
+          Text(
+            isRecording ? 'Current Segment' : 'Available Labels',
+            style: theme.textTheme.titleSmall?.copyWith(
+              fontWeight: FontWeight.w700,
+            ),
+          ),
+          const SizedBox(height: 10),
+          ActiveLabelBar(
+            labelSet: set,
+            selectionEnabled: isRecording,
+            showNoLabelOption: isRecording,
+          ),
+        ],
+      ],
+    );
+  }
+}
+
 Future<bool> _askOverwriteConfirmation(
   BuildContext context,
   String dirPath,
diff --git a/open_wearable/pubspec.lock b/open_wearable/pubspec.lock
index bdcab1ef..e9c1e855 100644
--- a/open_wearable/pubspec.lock
+++ b/open_wearable/pubspec.lock
@@ -625,7 +625,7 @@ packages:
     source: hosted
     version: "3.2.1"
   path:
-    dependency: transitive
+    dependency: "direct main"
     description:
       name: path
       sha256: "75cca69d1490965be98c73ceaea117e8a04dd21217b37b292c9ddbec0d955bc5"
diff --git a/open_wearable/pubspec.yaml b/open_wearable/pubspec.yaml
index c460b7dd..96627be2 100644
--- a/open_wearable/pubspec.yaml
+++ b/open_wearable/pubspec.yaml
@@ -16,7 +16,7 @@ publish_to: 'none' # Remove this line if you wish to publish to pub.dev
 # https://developer.apple.com/library/archive/documentation/General/Reference/InfoPlistKeyReference/Articles/CoreFoundationKeys.html
 # In Windows, build-name is used as the major, minor, and patch parts
 # of the product and file versions while build-number is used as the build suffix.
-version: 1.4.1+1
+version: 1.5.0
 
 environment:
   sdk: ^3.6.0
@@ -62,6 +62,7 @@ dependencies:
   pub_semver: ^2.2.0
   flutter_headset_detector: ^3.1.0
   record: ^7.0.0
+  path: ^1.9.1
   web: ^1.1.1
 
 dev_dependencies:
diff --git a/open_wearable/test/models/app_upgrade_registry_test.dart b/open_wearable/test/models/app_upgrade_registry_test.dart
index fab1e7db..ad473291 100644
--- a/open_wearable/test/models/app_upgrade_registry_test.dart
+++ b/open_wearable/test/models/app_upgrade_registry_test.dart
@@ -3,13 +3,14 @@ import 'package:open_wearable/models/app_upgrade_registry.dart';
 
 void main() {
   group('AppUpgradeRegistry', () {
-    test('registers version 1.4.0 as the latest upgrade highlight', () {
-      final highlight = AppUpgradeRegistry.forVersion('1.4.0');
+    test('registers version 1.5.0 as the latest upgrade highlight', () {
+      final highlight = AppUpgradeRegistry.forVersion('1.5.0');
 
       expect(highlight, isNotNull);
-      expect(highlight?.version, '1.4.0');
-      expect(AppUpgradeRegistry.latest?.version, '1.4.0');
-      expect(AppUpgradeRegistry.all.first.version, '1.4.0');
+      expect(highlight?.version, '1.5.0');
+      expect(highlight?.features.first.title, 'Recording labels');
+      expect(AppUpgradeRegistry.latest?.version, '1.5.0');
+      expect(AppUpgradeRegistry.all.first.version, '1.5.0');
     });
   });
 }
diff --git a/open_wearable/test/models/beta_firmware_title_resolver_test.dart b/open_wearable/test/models/beta_firmware_title_resolver_test.dart
new file mode 100644
index 00000000..67dc6da2
--- /dev/null
+++ b/open_wearable/test/models/beta_firmware_title_resolver_test.dart
@@ -0,0 +1,121 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:open_earable_flutter/open_earable_flutter.dart';
+import 'package:open_wearable/models/beta_firmware_title_resolver.dart';
+
+void main() {
+  group('BetaFirmwareTitleResolver', () {
+    test('uses GitHub pull request title for beta firmware display name',
+        () async {
+      final resolver = BetaFirmwareTitleResolver(
+        fetchTitles: (numbers) async {
+          expect(numbers, {250});
+          return {250: '2.2.7'};
+        },
+      );
+
+      final entries = await resolver.resolve([
+        _betaEntry(
+          name: '2 2 7',
+          version: 'PR #250',
+          url:
+              'https://github.com/OpenEarable/open-earable-2/releases/download/pr-builds/pr-250-2_2_7-openearable_v2_fota.zip',
+        ),
+      ]);
+
+      expect(entries.single.firmware.name, '2.2.7');
+      expect(entries.single.firmware.version, 'PR #250');
+      expect(entries.single.firmware.url, contains('pr-250-2_2_7'));
+      expect(entries.single.firmware.type, FirmwareType.multiImage);
+      expect(entries.single.isBeta, isTrue);
+    });
+
+    test('preserves punctuation from pull request titles', () async {
+      final resolver = BetaFirmwareTitleResolver(
+        fetchTitles: (_) async => {228: 'Feature/audio response'},
+      );
+
+      final entries = await resolver.resolve([
+        _betaEntry(
+          name: 'Feature audio response',
+          version: 'PR #228',
+          url:
+              'https://github.com/OpenEarable/open-earable-2/releases/download/pr-builds/pr-228-Feature_audio_response-openearable_v2_fota.zip',
+        ),
+      ]);
+
+      expect(entries.single.firmware.name, 'Feature/audio response');
+    });
+
+    test('preserves brackets and dots from pull request titles', () async {
+      final resolver = BetaFirmwareTitleResolver(
+        fetchTitles: (_) async => {250: '[2.2.7] FOTA retry upload'},
+      );
+
+      final entries = await resolver.resolve([
+        _betaEntry(
+          name: '2 2 7 FOTA retry upload',
+          version: 'PR #250',
+          url:
+              'https://github.com/OpenEarable/open-earable-2/releases/download/pr-builds/pr-250-2_2_7_FOTA_retry_upload-openearable_v2_fota.zip',
+        ),
+      ]);
+
+      expect(entries.single.firmware.name, '[2.2.7] FOTA retry upload');
+    });
+
+    test('does not change stable firmware entries', () async {
+      final resolver = BetaFirmwareTitleResolver(
+        fetchTitles: (numbers) async {
+          expect(numbers, isEmpty);
+          return const {};
+        },
+      );
+      final entry = FirmwareEntry(
+        firmware: RemoteFirmware(
+          name: 'OpenEarable 2.2.7',
+          version: '2.2.7',
+          url: 'https://example.com/openearable_v2_fota.zip',
+          type: FirmwareType.multiImage,
+        ),
+        source: FirmwareSource.stable,
+      );
+
+      final entries = await resolver.resolve([entry]);
+
+      expect(entries.single, same(entry));
+    });
+
+    test('keeps asset-derived title when pull request title is unavailable',
+        () async {
+      final resolver = BetaFirmwareTitleResolver(
+        fetchTitles: (_) async => const {},
+      );
+      final entry = _betaEntry(
+        name: '2 2 7',
+        version: 'PR #250',
+        url:
+            'https://github.com/OpenEarable/open-earable-2/releases/download/pr-builds/pr-250-2_2_7-openearable_v2_fota.zip',
+      );
+
+      final entries = await resolver.resolve([entry]);
+
+      expect(entries.single, same(entry));
+    });
+  });
+}
+
+FirmwareEntry _betaEntry({
+  required String name,
+  required String version,
+  required String url,
+}) {
+  return FirmwareEntry(
+    firmware: RemoteFirmware(
+      name: name,
+      version: version,
+      url: url,
+      type: FirmwareType.multiImage,
+    ),
+    source: FirmwareSource.beta,
+  );
+}
diff --git a/open_wearable/test/models/firmware_version_matcher_test.dart b/open_wearable/test/models/firmware_version_matcher_test.dart
new file mode 100644
index 00000000..4550b26b
--- /dev/null
+++ b/open_wearable/test/models/firmware_version_matcher_test.dart
@@ -0,0 +1,41 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:open_wearable/models/firmware_version_matcher.dart';
+
+void main() {
+  group('normalizeFirmwareVersion', () {
+    test('removes transport nulls and surrounding whitespace', () {
+      expect(normalizeFirmwareVersion(' \x002.2.7\x00 '), '2.2.7');
+    });
+
+    test('returns null for missing firmware versions', () {
+      expect(normalizeFirmwareVersion(null), isNull);
+      expect(normalizeFirmwareVersion('   '), isNull);
+    });
+  });
+
+  group('firmwareVersionsMatch', () {
+    test('matches beta PR labels against device firmware ids', () {
+      expect(firmwareVersionsMatch('PR #123', '2.2.7-pr123'), isTrue);
+      expect(firmwareVersionsMatch('2.2.7-pr123', 'PR #123'), isTrue);
+    });
+
+    test('matches alternate beta PR spellings', () {
+      expect(firmwareVersionsMatch('PR #123', '2.2.7-PR-123+1'), isTrue);
+      expect(
+        firmwareVersionsMatch('pull request #123', '2.2.7-pr123'),
+        isTrue,
+      );
+    });
+
+    test('rejects different beta PR numbers', () {
+      expect(firmwareVersionsMatch('PR #123', '2.2.7-pr124'), isFalse);
+      expect(firmwareVersionsMatch('PR #123', '2.2.7'), isFalse);
+    });
+
+    test('keeps existing stable version containment behavior', () {
+      expect(firmwareVersionsMatch('2.2.7', '2.2.7+1'), isTrue);
+      expect(firmwareVersionsMatch('2.2.7+1', '2.2.7'), isTrue);
+      expect(firmwareVersionsMatch('2.2.7', '2.2.8'), isFalse);
+    });
+  });
+}
diff --git a/open_wearable/test/view_models/sensor_recorder_provider_test.dart b/open_wearable/test/view_models/sensor_recorder_provider_test.dart
new file mode 100644
index 00000000..b22d1c14
--- /dev/null
+++ b/open_wearable/test/view_models/sensor_recorder_provider_test.dart
@@ -0,0 +1,37 @@
+import 'dart:async';
+
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:logger/logger.dart';
+import 'package:open_wearable/models/labels/label.dart';
+import 'package:open_wearable/models/labels/label_sensor.dart';
+import 'package:open_wearable/models/labels/label_set.dart';
+import 'package:open_wearable/models/logger.dart';
+import 'package:open_wearable/view_models/sensor_recorder_provider_facade.dart';
+
+void main() {
+  setUpAll(() {
+    initLogger(Logger());
+  });
+
+  test('does not treat a selected label set as connected sensors', () async {
+    final provider = SensorRecorderProvider();
+    final labelStream = StreamController<(int, List<Label>)>.broadcast();
+    addTearDown(provider.dispose);
+    addTearDown(labelStream.close);
+
+    await provider.addWearable(
+      LabelWearable(
+        labelSet: const LabelSet(
+          name: 'Activities',
+          labels: [
+            Label(name: 'Walking', color: Color(0xff4caf50)),
+          ],
+        ),
+        labelStream: labelStream.stream,
+      ),
+    );
+
+    expect(provider.hasSensorsConnected, isFalse);
+  });
+}
diff --git a/open_wearable/test/widgets/labelset_editor_page_test.dart b/open_wearable/test/widgets/labelset_editor_page_test.dart
new file mode 100644
index 00000000..16f09d47
--- /dev/null
+++ b/open_wearable/test/widgets/labelset_editor_page_test.dart
@@ -0,0 +1,552 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:open_wearable/models/labels/label.dart';
+import 'package:open_wearable/models/labels/label_set.dart';
+import 'package:open_wearable/models/labels/label_set_manager.dart';
+import 'package:open_wearable/models/labels/label_set_storage.dart';
+import 'package:open_wearable/view_models/label_provider.dart';
+import 'package:open_wearable/view_models/label_set_provider.dart';
+import 'package:open_wearable/widgets/sensors/local_recorder/labels/active_label_bar.dart';
+import 'package:open_wearable/widgets/sensors/local_recorder/labels/label_set_selector.dart';
+import 'package:open_wearable/widgets/sensors/local_recorder/labels/labelset_dropdown.dart';
+import 'package:open_wearable/widgets/sensors/local_recorder/labels/labelset_editor_page.dart';
+import 'package:provider/provider.dart';
+
+void main() {
+  testWidgets('autosaves label set name edits without save controls',
+      (tester) async {
+    final initialSet = LabelSet(
+      name: 'Activities',
+      labels: [
+        Label(name: 'Walking', color: Colors.green),
+      ],
+    );
+    final provider = _providerWithStorage([initialSet]);
+    addTearDown(provider.dispose);
+
+    await tester.pumpWidget(
+      _TestApp(
+        provider: provider,
+        child: LabelSetEditorPage(initialSet: initialSet),
+      ),
+    );
+    await tester.pumpAndSettle();
+
+    expect(find.byTooltip('Save'), findsNothing);
+    expect(find.text('Save label set'), findsNothing);
+
+    await tester.enterText(find.byType(TextField).first, 'Movement');
+    await tester.pumpAndSettle();
+
+    expect(
+      provider.labelSets.map((set) => set.name),
+      <String>['Movement'],
+    );
+    expect(provider.labelSets.single.labels.single.name, 'Walking');
+  });
+
+  testWidgets('shows a contrast checkmark on the selected color',
+      (tester) async {
+    final initialSet = LabelSet(
+      name: 'Contrast',
+      labels: [
+        Label(name: 'Dark label', color: Colors.black),
+      ],
+    );
+    final provider = _providerWithStorage([initialSet]);
+    addTearDown(provider.dispose);
+
+    await tester.pumpWidget(
+      _TestApp(
+        provider: provider,
+        child: LabelSetEditorPage(initialSet: initialSet),
+      ),
+    );
+    await tester.pumpAndSettle();
+
+    await tester.tap(find.byTooltip('Edit'));
+    await tester.pumpAndSettle();
+
+    final selectedCheck = tester.widget<Icon>(
+      find.byIcon(Icons.check_rounded),
+    );
+    expect(selectedCheck.color, Colors.white);
+  });
+
+  testWidgets('prevents reusing a label color within the same label set',
+      (tester) async {
+    final initialSet = LabelSet(
+      name: 'Activities',
+      labels: [
+        Label(name: 'Walking', color: Colors.green),
+      ],
+    );
+    final provider = _providerWithStorage([initialSet]);
+    addTearDown(provider.dispose);
+
+    await tester.pumpWidget(
+      _TestApp(
+        provider: provider,
+        child: LabelSetEditorPage(initialSet: initialSet),
+      ),
+    );
+    await tester.pumpAndSettle();
+
+    await tester.tap(find.widgetWithText(ElevatedButton, 'Add'));
+    await tester.pumpAndSettle();
+
+    final greenSwatch = find.byKey(
+      ValueKey('label-color-${Colors.green.toARGB32()}'),
+    );
+    expect(greenSwatch, findsOneWidget);
+    expect(find.byIcon(Icons.block_rounded), findsOneWidget);
+
+    await tester.enterText(find.byType(TextField).last, 'Running');
+    await tester.tap(greenSwatch);
+    await tester.pumpAndSettle();
+    await tester.tap(find.widgetWithText(TextButton, 'Save'));
+    await tester.pumpAndSettle();
+
+    final labelColors = provider.labelSets.single.labels
+        .map((label) => label.color.toARGB32())
+        .toList();
+    expect(labelColors, hasLength(2));
+    expect(labelColors.first, Colors.green.toARGB32());
+    expect(labelColors.last, isNot(Colors.green.toARGB32()));
+  });
+
+  testWidgets('uses natural label set selector wording', (tester) async {
+    final provider = _providerWithStorage();
+    addTearDown(provider.dispose);
+
+    await tester.pumpWidget(
+      _TestApp(
+        provider: provider,
+        child: const Padding(
+          padding: EdgeInsets.all(16),
+          child: LabelSetSelector(),
+        ),
+      ),
+    );
+    await tester.pumpAndSettle();
+
+    expect(find.byTooltip('Create label set'), findsNothing);
+    expect(find.byTooltip('Manage label sets'), findsOneWidget);
+    expect(
+      find.text('Pick a label set to add labels while recording.'),
+      findsOneWidget,
+    );
+    expect(find.textContaining('in-recording'), findsNothing);
+  });
+
+  testWidgets('disables label dialog save until a label name is entered',
+      (tester) async {
+    final provider = _providerWithStorage();
+    addTearDown(provider.dispose);
+
+    await tester.pumpWidget(
+      _TestApp(
+        provider: provider,
+        child: const LabelSetEditorPage(),
+      ),
+    );
+    await tester.pumpAndSettle();
+
+    await tester.tap(find.widgetWithText(ElevatedButton, 'Add'));
+    await tester.pumpAndSettle();
+
+    var saveButton = tester.widget<TextButton>(
+      find.widgetWithText(TextButton, 'Save'),
+    );
+    expect(saveButton.onPressed, isNull);
+
+    await tester.enterText(find.byType(TextField).last, 'Walking');
+    await tester.pumpAndSettle();
+
+    saveButton = tester.widget<TextButton>(
+      find.widgetWithText(TextButton, 'Save'),
+    );
+    expect(saveButton.onPressed, isNotNull);
+  });
+
+  testWidgets('create checkmark confirms a valid set and switches to edit mode',
+      (tester) async {
+    final provider = _providerWithStorage();
+    addTearDown(provider.dispose);
+
+    await tester.pumpWidget(
+      _TestApp(
+        provider: provider,
+        child: const LabelSetEditorPage(),
+      ),
+    );
+    await tester.pumpAndSettle();
+
+    expect(find.text('Create label set'), findsOneWidget);
+    var saveAction = _createPageSaveAction(tester);
+    expect(saveAction.onPressed, isNull);
+
+    await tester.enterText(find.byType(TextField), 'Activities');
+    await tester.pumpAndSettle();
+
+    saveAction = _createPageSaveAction(tester);
+    expect(saveAction.onPressed, isNull);
+
+    await tester.tap(find.widgetWithText(ElevatedButton, 'Add'));
+    await tester.pumpAndSettle();
+    await tester.enterText(find.byType(TextField).last, 'Walking');
+    await tester.pumpAndSettle();
+    await tester.tap(find.widgetWithText(TextButton, 'Save'));
+    await tester.pumpAndSettle();
+
+    expect(provider.labelSets.single.name, 'Activities');
+    expect(provider.labelSets.single.labels.single.name, 'Walking');
+    saveAction = _createPageSaveAction(tester);
+    expect(saveAction.onPressed, isNotNull);
+
+    await tester.tap(find.byTooltip('Save'));
+    await tester.pumpAndSettle();
+
+    expect(find.text('Edit label set'), findsOneWidget);
+    expect(find.byTooltip('Save'), findsNothing);
+    expect(provider.labelSets.single.name, 'Activities');
+  });
+
+  testWidgets('removes an autosaved create draft when it becomes invalid',
+      (tester) async {
+    final provider = _providerWithStorage();
+    addTearDown(provider.dispose);
+
+    await tester.pumpWidget(
+      _TestApp(
+        provider: provider,
+        child: const LabelSetEditorPage(),
+      ),
+    );
+    await tester.pumpAndSettle();
+
+    await tester.enterText(find.byType(TextField), 'Activities');
+    await tester.tap(find.widgetWithText(ElevatedButton, 'Add'));
+    await tester.pumpAndSettle();
+    await tester.enterText(find.byType(TextField).last, 'Walking');
+    await tester.pumpAndSettle();
+    await tester.tap(find.widgetWithText(TextButton, 'Save'));
+    await tester.pumpAndSettle();
+
+    expect(provider.labelSets, hasLength(1));
+
+    await tester.tap(find.byTooltip('Delete'));
+    await tester.pumpAndSettle();
+    await tester.tap(find.widgetWithText(TextButton, 'Delete'));
+    await tester.pumpAndSettle();
+
+    expect(provider.labelSets, isEmpty);
+    expect(find.text('Create label set'), findsOneWidget);
+    final saveAction = _createPageSaveAction(tester);
+    expect(saveAction.onPressed, isNull);
+  });
+
+  testWidgets('warns before leaving a new named label set with no labels',
+      (tester) async {
+    final provider = _providerWithStorage();
+    addTearDown(provider.dispose);
+
+    await tester.pumpWidget(_EditorRouteApp(provider: provider));
+    await tester.pumpAndSettle();
+
+    await tester.tap(find.text('Open editor'));
+    await tester.pumpAndSettle();
+    await tester.enterText(find.byType(TextField), 'Empty Set');
+    await tester.pumpAndSettle();
+
+    await tester.tap(find.byTooltip('Back'));
+    await tester.pumpAndSettle();
+
+    expect(find.text('Leave without labels?'), findsOneWidget);
+    expect(provider.labelSets, isEmpty);
+
+    await tester.tap(find.text('Leave'));
+    await tester.pumpAndSettle();
+
+    expect(find.text('Open editor'), findsOneWidget);
+    expect(provider.labelSets, isEmpty);
+  });
+
+  testWidgets('warns before leaving labels without a label set name',
+      (tester) async {
+    final provider = _providerWithStorage();
+    addTearDown(provider.dispose);
+
+    await tester.pumpWidget(_EditorRouteApp(provider: provider));
+    await tester.pumpAndSettle();
+
+    await tester.tap(find.text('Open editor'));
+    await tester.pumpAndSettle();
+    await tester.tap(find.widgetWithText(ElevatedButton, 'Add'));
+    await tester.pumpAndSettle();
+    await tester.enterText(find.byType(TextField).last, 'Walking');
+    await tester.pumpAndSettle();
+    await tester.tap(find.widgetWithText(TextButton, 'Save'));
+    await tester.pumpAndSettle();
+
+    await tester.tap(find.byTooltip('Back'));
+    await tester.pumpAndSettle();
+
+    expect(find.text('Leave without set name?'), findsOneWidget);
+    expect(
+      find.text(
+        'This label set cannot be saved because no set name was given. Leave anyway?',
+      ),
+      findsOneWidget,
+    );
+    expect(provider.labelSets, isEmpty);
+
+    await tester.tap(find.text('Leave'));
+    await tester.pumpAndSettle();
+
+    expect(find.text('Open editor'), findsOneWidget);
+    expect(provider.labelSets, isEmpty);
+  });
+
+  testWidgets('dropdown shows selected label set without floating label text',
+      (tester) async {
+    final initialSet = LabelSet(
+      name: 'Activities',
+      labels: [
+        Label(name: 'Walking', color: Colors.green),
+      ],
+    );
+    final provider = _providerWithStorage([initialSet]);
+    addTearDown(provider.dispose);
+
+    await tester.pumpWidget(
+      _TestApp(
+        provider: provider,
+        child: const Padding(
+          padding: EdgeInsets.all(16),
+          child: LabelSetDropdown(),
+        ),
+      ),
+    );
+    await tester.pumpAndSettle();
+
+    expect(find.text('No Labels'), findsOneWidget);
+    expect(find.text('None'), findsNothing);
+
+    provider.selectLabelSet(initialSet);
+    await tester.pumpAndSettle();
+
+    expect(find.text('Activities'), findsOneWidget);
+    expect(find.text('Label set'), findsNothing);
+  });
+
+  testWidgets('label chips keep their size when selected', (tester) async {
+    final labelSet = LabelSet(
+      name: 'Activities',
+      labels: [
+        Label(name: 'Walking', color: Colors.green),
+        Label(name: 'Running', color: Colors.red),
+      ],
+    );
+    final labelProvider = LabelProvider(labelSet);
+    addTearDown(labelProvider.dispose);
+
+    await tester.pumpWidget(
+      ChangeNotifierProvider<LabelProvider>.value(
+        value: labelProvider,
+        child: MaterialApp(
+          home: Scaffold(
+            body: ActiveLabelBar(
+              labelSet: labelSet,
+              selectionEnabled: true,
+            ),
+          ),
+        ),
+      ),
+    );
+    await tester.pumpAndSettle();
+
+    final walkingChip = find.ancestor(
+      of: find.text('Walking'),
+      matching: find.byType(AnimatedContainer),
+    );
+    final sizeBefore = tester.getSize(walkingChip);
+
+    await tester.tap(find.text('Walking'));
+    await tester.pumpAndSettle();
+
+    final sizeAfter = tester.getSize(walkingChip);
+    expect(sizeAfter, sizeBefore);
+  });
+
+  testWidgets('recording label bar can clear the current segment label',
+      (tester) async {
+    final labelSet = LabelSet(
+      name: 'Activities',
+      labels: [
+        Label(name: 'Walking', color: Colors.green),
+        Label(name: 'Running', color: Colors.red),
+      ],
+    );
+    final labelProvider = LabelProvider(labelSet);
+    addTearDown(labelProvider.dispose);
+
+    await tester.pumpWidget(
+      ChangeNotifierProvider<LabelProvider>.value(
+        value: labelProvider,
+        child: MaterialApp(
+          home: Scaffold(
+            body: ActiveLabelBar(
+              labelSet: labelSet,
+              selectionEnabled: true,
+              showNoLabelOption: true,
+            ),
+          ),
+        ),
+      ),
+    );
+    await tester.pumpAndSettle();
+
+    expect(find.text('No Label'), findsOneWidget);
+    expect(labelProvider.activeLabel, isNull);
+
+    await tester.tap(find.text('Walking'));
+    await tester.pumpAndSettle();
+    expect(labelProvider.activeLabel, labelSet.labels.first);
+    expect(find.byIcon(Icons.radio_button_unchecked), findsNothing);
+
+    await tester.tap(find.text('No Label'));
+    await tester.pumpAndSettle();
+    expect(labelProvider.activeLabel, isNull);
+  });
+
+  testWidgets('confirms before deleting a label from a label set',
+      (tester) async {
+    final initialSet = LabelSet(
+      name: 'Activities',
+      labels: [
+        Label(name: 'Walking', color: Colors.green),
+        Label(name: 'Running', color: Colors.red),
+      ],
+    );
+    final provider = _providerWithStorage([initialSet]);
+    addTearDown(provider.dispose);
+
+    await tester.pumpWidget(
+      _TestApp(
+        provider: provider,
+        child: LabelSetEditorPage(initialSet: initialSet),
+      ),
+    );
+    await tester.pumpAndSettle();
+
+    await tester.tap(find.byTooltip('Delete').first);
+    await tester.pumpAndSettle();
+
+    expect(find.text('Delete label?'), findsOneWidget);
+    expect(find.text('Delete "Walking" from this label set?'), findsOneWidget);
+
+    await tester.tap(find.text('Cancel'));
+    await tester.pumpAndSettle();
+
+    expect(provider.labelSets.single.labels.map((label) => label.name), [
+      'Walking',
+      'Running',
+    ]);
+
+    await tester.tap(find.byTooltip('Delete').first);
+    await tester.pumpAndSettle();
+    await tester.tap(find.widgetWithText(TextButton, 'Delete'));
+    await tester.pumpAndSettle();
+
+    expect(provider.labelSets.single.labels.map((label) => label.name), [
+      'Running',
+    ]);
+  });
+}
+
+IconButton _createPageSaveAction(WidgetTester tester) {
+  final finder = find.ancestor(
+    of: find.byIcon(Icons.check),
+    matching: find.byType(IconButton),
+  );
+  return tester.widget<IconButton>(finder);
+}
+
+LabelSetProvider _providerWithStorage([List<LabelSet> initialSets = const []]) {
+  return LabelSetProvider(
+    manager: LabelSetManager(
+      storage: _MemoryLabelSetStorage(initialSets),
+    ),
+  );
+}
+
+class _TestApp extends StatelessWidget {
+  const _TestApp({
+    required this.provider,
+    required this.child,
+  });
+
+  final LabelSetProvider provider;
+  final Widget child;
+
+  @override
+  Widget build(BuildContext context) {
+    return ChangeNotifierProvider<LabelSetProvider>.value(
+      value: provider,
+      child: MaterialApp(
+        home: Scaffold(
+          body: child,
+        ),
+      ),
+    );
+  }
+}
+
+class _EditorRouteApp extends StatelessWidget {
+  const _EditorRouteApp({required this.provider});
+
+  final LabelSetProvider provider;
+
+  @override
+  Widget build(BuildContext context) {
+    return ChangeNotifierProvider<LabelSetProvider>.value(
+      value: provider,
+      child: MaterialApp(
+        home: Builder(
+          builder: (context) => Scaffold(
+            body: Center(
+              child: TextButton(
+                onPressed: () {
+                  Navigator.of(context).push(
+                    MaterialPageRoute<void>(
+                      builder: (_) => const LabelSetEditorPage(),
+                    ),
+                  );
+                },
+                child: const Text('Open editor'),
+              ),
+            ),
+          ),
+        ),
+      ),
+    );
+  }
+}
+
+class _MemoryLabelSetStorage implements LabelSetStorage {
+  _MemoryLabelSetStorage(List<LabelSet> initialSets)
+      : _sets = List<LabelSet>.of(initialSets);
+
+  List<LabelSet> _sets;
+
+  @override
+  Future<List<LabelSet>> loadLabelSets() async {
+    return List<LabelSet>.of(_sets);
+  }
+
+  @override
+  Future<void> saveLabelSets(List<LabelSet> sets) async {
+    _sets = List<LabelSet>.of(sets);
+  }
+}
diff --git a/open_wearable/test/widgets/local_recorder_recording_card_test.dart b/open_wearable/test/widgets/local_recorder_recording_card_test.dart
new file mode 100644
index 00000000..02d10963
--- /dev/null
+++ b/open_wearable/test/widgets/local_recorder_recording_card_test.dart
@@ -0,0 +1,78 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:open_wearable/view_models/label_provider.dart';
+import 'package:open_wearable/view_models/sensor_recorder_provider_facade.dart';
+import 'package:open_wearable/widgets/sensors/local_recorder/local_recorder_recording_card.dart';
+import 'package:provider/provider.dart';
+
+void main() {
+  testWidgets('uses the full available card width', (tester) async {
+    await tester.pumpWidget(
+      MaterialApp(
+        home: Scaffold(
+          body: LocalRecorderRecordingCard(
+            isRecording: false,
+            hasSensorsConnected: true,
+            canStartRecording: true,
+            isHandlingStopAction: false,
+            elapsedRecordingLabel: '00:00:00',
+            onStartRecording: () {},
+            onStopRecording: () {},
+          ),
+        ),
+      ),
+    );
+
+    final card = tester.widget<Card>(find.byType(Card));
+
+    expect(card.margin, EdgeInsets.zero);
+  });
+
+  testWidgets('uses an unchecked sensor shutdown option while recording',
+      (tester) async {
+    var turnOffSensors = false;
+    final recorderProvider = SensorRecorderProvider();
+    final labelProvider = LabelProvider(null);
+    addTearDown(recorderProvider.dispose);
+    addTearDown(labelProvider.dispose);
+
+    await tester.pumpWidget(
+      MultiProvider(
+        providers: [
+          ChangeNotifierProvider<SensorRecorderProvider>.value(
+            value: recorderProvider,
+          ),
+          ChangeNotifierProvider<LabelProvider>.value(value: labelProvider),
+        ],
+        child: StatefulBuilder(
+          builder: (context, setState) => MaterialApp(
+            home: Scaffold(
+              body: LocalRecorderRecordingCard(
+                isRecording: true,
+                hasSensorsConnected: true,
+                canStartRecording: false,
+                isHandlingStopAction: false,
+                turnOffSensorsWhenStopping: turnOffSensors,
+                elapsedRecordingLabel: '00:00:12',
+                onStartRecording: () {},
+                onTurnOffSensorsWhenStoppingChanged: (value) {
+                  setState(() => turnOffSensors = value);
+                },
+                onStopRecording: () {},
+              ),
+            ),
+          ),
+        ),
+      ),
+    );
+
+    expect(find.text('Stop + Off'), findsNothing);
+    expect(find.text('Turn off sensors after stopping'), findsOneWidget);
+    expect(tester.widget<Checkbox>(find.byType(Checkbox)).value, isFalse);
+
+    await tester.tap(find.byType(Checkbox));
+    await tester.pumpAndSettle();
+
+    expect(tester.widget<Checkbox>(find.byType(Checkbox)).value, isTrue);
+  });
+}
diff --git a/open_wearable/test/widgets/recording_activity_indicator_test.dart b/open_wearable/test/widgets/recording_activity_indicator_test.dart
new file mode 100644
index 00000000..1a62f1d6
--- /dev/null
+++ b/open_wearable/test/widgets/recording_activity_indicator_test.dart
@@ -0,0 +1,66 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:open_wearable/models/labels/label.dart';
+import 'package:open_wearable/models/labels/label_set.dart';
+import 'package:open_wearable/view_models/label_provider.dart';
+import 'package:open_wearable/view_models/sensor_recorder_provider_facade.dart';
+import 'package:open_wearable/widgets/recording_activity_indicator.dart';
+import 'package:provider/provider.dart';
+
+void main() {
+  testWidgets('draws active label color around recording indicator',
+      (tester) async {
+    final labelSet = LabelSet(
+      name: 'Activities',
+      labels: [
+        Label(name: 'Walking', color: Colors.green),
+      ],
+    );
+    final labelProvider = LabelProvider(labelSet)
+      ..setActiveLabel(labelSet.labels.first);
+    final recorderProvider = _RecordingSensorRecorderProvider();
+    addTearDown(labelProvider.dispose);
+    addTearDown(recorderProvider.dispose);
+
+    await tester.pumpWidget(
+      MultiProvider(
+        providers: [
+          ChangeNotifierProvider<SensorRecorderProvider>.value(
+            value: recorderProvider,
+          ),
+          ChangeNotifierProvider<LabelProvider>.value(value: labelProvider),
+        ],
+        child: const MaterialApp(
+          home: Scaffold(
+            body: RecordingActivityIndicator(
+              size: 20,
+              showIdleOutline: false,
+              padding: EdgeInsets.zero,
+            ),
+          ),
+        ),
+      ),
+    );
+
+    final borderBox = find.byKey(const ValueKey('recording-label-border'));
+    expect(borderBox, findsOneWidget);
+
+    final decoration = tester
+        .widget<DecoratedBox>(
+          find.descendant(
+            of: borderBox,
+            matching: find.byType(DecoratedBox),
+          ),
+        )
+        .decoration as BoxDecoration;
+    expect(decoration.border, isNotNull);
+  });
+}
+
+class _RecordingSensorRecorderProvider extends SensorRecorderProvider {
+  @override
+  bool get isRecording => true;
+
+  @override
+  DateTime? get recordingStart => DateTime(2026, 7, 16, 12);
+}
diff --git a/open_wearable/test/widgets/sensors/configuration/edge_recorder_prefix_row_test.dart b/open_wearable/test/widgets/sensors/configuration/edge_recorder_prefix_row_test.dart
new file mode 100644
index 00000000..1e29048a
--- /dev/null
+++ b/open_wearable/test/widgets/sensors/configuration/edge_recorder_prefix_row_test.dart
@@ -0,0 +1,47 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:open_earable_flutter/open_earable_flutter.dart';
+import 'package:open_wearable/widgets/sensors/configuration/edge_recorder_prefix_row.dart';
+
+void main() {
+  testWidgets('sets filename prefix on both paired edge recorder managers',
+      (tester) async {
+    final primaryManager = _FakeEdgeRecorderManager('');
+    final pairedManager = _FakeEdgeRecorderManager('');
+
+    await tester.pumpWidget(
+      MaterialApp(
+        home: Scaffold(
+          body: EdgeRecorderPrefixRow(
+            manager: primaryManager,
+            pairedManager: pairedManager,
+          ),
+        ),
+      ),
+    );
+    await tester.pumpAndSettle();
+
+    await tester.tap(find.text('On-Device Filename Prefix'));
+    await tester.pumpAndSettle();
+    await tester.enterText(find.byType(TextField), 'session_01');
+    await tester.tap(find.text('Save'));
+    await tester.pumpAndSettle();
+
+    expect(primaryManager.prefix, 'session_01');
+    expect(pairedManager.prefix, 'session_01');
+  });
+}
+
+class _FakeEdgeRecorderManager implements EdgeRecorderManager {
+  _FakeEdgeRecorderManager(this.prefix);
+
+  String prefix;
+
+  @override
+  Future<String> get filePrefix async => prefix;
+
+  @override
+  Future<void> setFilePrefix(String prefix) async {
+    this.prefix = prefix;
+  }
+}