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/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/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/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..18ca317a 100644
--- a/open_wearable/pubspec.yaml
+++ b/open_wearable/pubspec.yaml
@@ -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/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);
+}