diff --git a/docs/app/index.html b/docs/app/index.html
index 6e885268..2a8133d7 100644
--- a/docs/app/index.html
+++ b/docs/app/index.html
@@ -7,6 +7,12 @@
   <title>Maximum Trainer — Web App (Beta)</title>
   <meta name="description" content="Maximum Trainer running in your browser via WebAssembly and WebBluetooth." />
   <link rel="icon" type="image/png" href="../assets/images/main_icon.png" />
+  <link rel="manifest" href="manifest.json" />
+  <meta name="theme-color" content="#e05a00" />
+  <meta name="mobile-web-app-capable" content="yes" />
+  <meta name="apple-mobile-web-app-capable" content="yes" />
+  <meta name="apple-mobile-web-app-title" content="Maximum Trainer" />
+  <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent" />
   <style>
     *, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
     html, body {
@@ -315,5 +321,20 @@ <h2>🔌 Trainer Disconnected</h2>
       }
     });
   </script>
+
+  <!-- PWA Service Worker registration -->
+  <script>
+    if ('serviceWorker' in navigator) {
+      window.addEventListener('load', function() {
+        navigator.serviceWorker.register('./service-worker.js', { scope: './' })
+          .then(function(reg) {
+            console.log('[SW] Registered, scope:', reg.scope);
+          })
+          .catch(function(err) {
+            console.warn('[SW] Registration failed:', err);
+          });
+      });
+    }
+  </script>
 </body>
 </html>
diff --git a/docs/app/manifest.json b/docs/app/manifest.json
new file mode 100644
index 00000000..104e01bf
--- /dev/null
+++ b/docs/app/manifest.json
@@ -0,0 +1,20 @@
+{
+  "name": "Maximum Trainer",
+  "short_name": "MaxTrainer",
+  "description": "Free, open-source indoor cycling training — ERG mode, real-time power, BLE sensors & structured intervals.",
+  "start_url": "./",
+  "scope": "./",
+  "display": "standalone",
+  "background_color": "#0d0d0d",
+  "theme_color": "#e05a00",
+  "orientation": "landscape-primary",
+  "categories": ["sports", "fitness", "health"],
+  "icons": [
+    {
+      "src": "../assets/images/main_icon.png",
+      "sizes": "512x512",
+      "type": "image/png",
+      "purpose": "any maskable"
+    }
+  ]
+}
diff --git a/docs/app/service-worker.js b/docs/app/service-worker.js
new file mode 100644
index 00000000..1d3231fa
--- /dev/null
+++ b/docs/app/service-worker.js
@@ -0,0 +1,129 @@
+/**
+ * Maximum Trainer — Service Worker
+ *
+ * Caches the WASM application shell and assets for offline use.
+ * Cache key includes the SW version so that new deployments bust the cache
+ * automatically.
+ *
+ * Cache strategy:
+ *   - App shell assets (JS, WASM, HTML, icons): Cache-first with network fallback.
+ *   - Uncached requests: Network-first.
+ */
+
+const SW_VERSION = 'v1';
+const CACHE_NAME = `maximum-trainer-${SW_VERSION}`;
+
+// Assets to pre-cache at install time.
+// The WASM/JS assets are large — we only pre-cache the thin shell files and
+// icons; the WASM binary is cached on first fetch (runtime caching below).
+const PRECACHE_ASSETS = [
+  './',
+  './index.html',
+  './logger.js',
+  './qtloader.js',
+  './manifest.json',
+  '../assets/images/main_icon.png',
+];
+
+// ── Install: pre-cache shell assets ──────────────────────────────────────────
+self.addEventListener('install', (event) => {
+  event.waitUntil(
+    caches.open(CACHE_NAME).then((cache) => {
+      // Individually fetch and cache each asset; ignore failures for assets
+      // that may not yet exist in the current deployment (e.g. WASM binary).
+      return Promise.allSettled(
+        PRECACHE_ASSETS.map((url) =>
+          cache.add(url).catch((err) => {
+            console.warn('[SW] Pre-cache failed for', url, err);
+          })
+        )
+      );
+    }).then(() => self.skipWaiting())
+  );
+});
+
+// ── Activate: delete old caches ───────────────────────────────────────────────
+self.addEventListener('activate', (event) => {
+  event.waitUntil(
+    caches.keys().then((keys) =>
+      Promise.all(
+        keys
+          .filter((key) => key !== CACHE_NAME)
+          .map((key) => {
+            console.log('[SW] Deleting old cache:', key);
+            return caches.delete(key);
+          })
+      )
+    ).then(() => self.clients.claim())
+  );
+});
+
+// ── Fetch: cache-first for same-origin requests ───────────────────────────────
+self.addEventListener('fetch', (event) => {
+  // Only intercept GET requests to same origin.
+  if (event.request.method !== 'GET') return;
+
+  const url = new URL(event.request.url);
+  if (url.origin !== self.location.origin) return;
+
+  event.respondWith(
+    caches.match(event.request).then((cached) => {
+      if (cached) {
+        // Return cached version and update cache in background for
+        // HTML/JS files so the next load gets fresh content.
+        const isRevalidatable =
+          event.request.url.endsWith('.html') ||
+          event.request.url.endsWith('.js');
+
+        if (isRevalidatable) {
+          const networkUpdate = fetch(event.request)
+            .then((response) => {
+              if (response && response.status === 200) {
+                caches.open(CACHE_NAME).then((cache) =>
+                  cache.put(event.request, response.clone())
+                );
+              }
+              return response;
+            })
+            .catch(() => null);
+
+          // Return stale-while-revalidate
+          void networkUpdate;
+        }
+
+        return cached;
+      }
+
+      // Not in cache — fetch from network and cache the response.
+      return fetch(event.request).then((response) => {
+        if (!response || response.status !== 200 || response.type === 'opaque') {
+          return response;
+        }
+
+        // Cache WASM, JS, and image assets for offline use.
+        const shouldCache =
+          event.request.url.endsWith('.wasm') ||
+          event.request.url.endsWith('.js')   ||
+          event.request.url.endsWith('.html') ||
+          event.request.url.endsWith('.png')  ||
+          event.request.url.endsWith('.svg')  ||
+          event.request.url.endsWith('.json');
+
+        if (shouldCache) {
+          caches.open(CACHE_NAME).then((cache) =>
+            cache.put(event.request, response.clone())
+          );
+        }
+
+        return response;
+      }).catch(() => {
+        // Network failed and not in cache — return a minimal offline page
+        // for navigation requests.
+        if (event.request.mode === 'navigate') {
+          return caches.match('./index.html');
+        }
+        return new Response('', { status: 503, statusText: 'Service Unavailable' });
+      });
+    })
+  );
+});
diff --git a/src/app/credential_store.h b/src/app/credential_store.h
index 65589f79..2b140c7d 100644
--- a/src/app/credential_store.h
+++ b/src/app/credential_store.h
@@ -11,7 +11,8 @@
 ///   macOS    — Security.framework Keychain (SecItemAdd / SecItemCopyMatching).
 ///   Linux    — AES-256-GCM via OpenSSL with a randomly-generated key persisted
 ///              in a chmod-600 protected file in the application data directory.
-///   WASM     — No-op: third-party tokens are not persisted in the browser context.
+///   WASM     — browser localStorage via Emscripten JS interop (not encrypted;
+///              consistent with standard browser-based web app security model).
 ///
 /// Credentials are keyed by (service, key), e.g.:
 ///   store("strava", "access_token", token)
diff --git a/src/app/credential_store_wasm.cpp b/src/app/credential_store_wasm.cpp
index c7f97db6..daf29bfc 100644
--- a/src/app/credential_store_wasm.cpp
+++ b/src/app/credential_store_wasm.cpp
@@ -1,22 +1,74 @@
-// WASM stub for CredentialStore.
-// Third-party service tokens are not persisted in the browser context —
-// browser-local storage has no reliable encryption boundary and the WASM
-// build targets single-session use.  All operations are silent no-ops.
+// WASM credential store using browser localStorage via Emscripten JS interop.
+//
+// Desktop builds use platform keychain (DPAPI / Keychain / OpenSSL-AES).
+// WASM has no native secure enclave, so credentials are stored in
+// localStorage under the key "mt_cred_<service>_<key>".  The store is
+// cleared when the user's browser data is wiped; values are not encrypted
+// but this matches the security model of any other browser-based web app.
+//
+// This enables OAuth tokens for Strava, Intervals.icu, and TrainingPeaks to
+// persist across browser sessions in the WASM build.
 
 #include "credential_store.h"
+#include <emscripten.h>
+#include <cstdlib>
 
-bool CredentialStore::store(const QString & /*service*/,
-                            const QString & /*key*/,
-                            const QString & /*value*/)
+static std::string makeLocalStorageKey(const QString &service, const QString &key)
 {
-    return false;
+    return std::string("mt_cred_")
+        + service.toStdString()
+        + "_"
+        + key.toStdString();
 }
 
-QString CredentialStore::load(const QString & /*service*/, const QString & /*key*/)
+bool CredentialStore::store(const QString &service,
+                             const QString &key,
+                             const QString &value)
 {
-    return {};
+    const std::string k = makeLocalStorageKey(service, key);
+    const std::string v = value.toStdString();
+    const int stored = EM_ASM_INT({
+        try {
+            window.localStorage.setItem(
+                UTF8ToString($0),
+                UTF8ToString($1));
+            return 1;
+        } catch(e) {
+            return 0;
+        }
+    }, k.c_str(), v.c_str());
+    return stored != 0;
 }
 
-void CredentialStore::remove(const QString & /*service*/, const QString & /*key*/)
+QString CredentialStore::load(const QString &service, const QString &key)
 {
+    const std::string k = makeLocalStorageKey(service, key);
+    char *raw = reinterpret_cast<char *>(EM_ASM_PTR({
+        try {
+            const val = window.localStorage.getItem(UTF8ToString($0));
+            if (!val) return 0;
+            const len  = lengthBytesUTF8(val) + 1;
+            const heap = _malloc(len);
+            stringToUTF8(val, heap, len);
+            return heap;
+        } catch(e) {
+            return 0;
+        }
+    }, k.c_str()));
+    if (!raw)
+        return {};
+    const QString result = QString::fromUtf8(raw);
+    // NOLINTNEXTLINE(cppcoreguidelines-no-malloc)
+    free(raw);
+    return result;
+}
+
+void CredentialStore::remove(const QString &service, const QString &key)
+{
+    const std::string k = makeLocalStorageKey(service, key);
+    EM_ASM({
+        try {
+            window.localStorage.removeItem(UTF8ToString($0));
+        } catch(e) {}
+    }, k.c_str());
 }
diff --git a/src/app/main.cpp b/src/app/main.cpp
index 5210c52e..83f88383 100644
--- a/src/app/main.cpp
+++ b/src/app/main.cpp
@@ -13,6 +13,7 @@
 #include "splashscreen.h"
 #include "account.h"
 #include "xmlutil.h"
+#include "apptheme.h"
 
 #ifdef GC_HAVE_VLCQT
 #include "myvlcplayer.h"
@@ -94,9 +95,12 @@ int main(int argc, char *argv[]) {
     splash.setProgress(30);
 #endif // Q_OS_WASM
 
-    /// App Stylesheet (hack so I can type stylesheet in designer instead of source code)
+    /// App Stylesheet — apply light theme as baseline; re-applied after login
+    /// based on the user's saved theme preference (Light / Dark / System).
     Z_StyleSheet styleSheetDummy;
-    app.setStyleSheet(styleSheetDummy.styleSheet());
+    const QString lightQss = styleSheetDummy.styleSheet();
+    qApp->setProperty("lightStylesheet", lightQss);
+    app.setStyleSheet(lightQss);
 
     // --screenshots [dir] / /screenshots [dir]: bypass login, capture UI
     // screenshots to [dir] (default: <appdir>/screenshots), then quit.
@@ -128,6 +132,13 @@ int main(int argc, char *argv[]) {
     }
 #endif // Q_OS_WASM
 
+    // Re-apply theme based on user preference now that the Account is loaded.
+    {
+        auto *account = qApp->property("Account").value<Account*>();
+        if (account)
+            AppTheme::apply(&app, static_cast<AppTheme::Mode>(account->app_theme));
+    }
+
 #ifdef Q_OS_WASM
     // WASM has no persistent server login. Initialize the global Account with
     // safe offline/guest defaults — identical to DialogLogin::loginOffline().
diff --git a/src/btle/btle_hub.cpp b/src/btle/btle_hub.cpp
index 34bed7da..557a2867 100644
--- a/src/btle/btle_hub.cpp
+++ b/src/btle/btle_hub.cpp
@@ -20,6 +20,8 @@ static const QBluetoothUuid CyclingPower          (QBluetoothUuid::CyclingPower)
 #endif
 // Fitness Machine Service (FTMS) – not in Qt enum, use raw 16-bit UUID
 static const QBluetoothUuid FitnessMachine        (quint16(0x1826));
+// Battery Service – standard BT SIG service for battery level percentage
+static const QBluetoothUuid BatteryService        (quint16(0x180F));
 
 // Characteristics
 #if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
@@ -33,6 +35,7 @@ static const QBluetoothUuid CyclingPowerMeasurement (QBluetoothUuid::CyclingPowe
 #endif
 static const QBluetoothUuid FtmsIndoorBikeData      (quint16(0x2AD2));
 static const QBluetoothUuid FtmsControlPoint        (quint16(0x2AD9));
+static const QBluetoothUuid BatteryLevel            (quint16(0x2A19));
 // Moxy Muscle Oxygen Monitor (proprietary UUIDs - not in BT SIG enum)
 static const QBluetoothUuid MoxyService             (quint16(0xAAB0));
 static const QBluetoothUuid MoxyMeasurement         (quint16(0xAAB2));
@@ -194,6 +197,7 @@ void BtleHub::simulateNotification(quint16 characteristicUuid, const QByteArray
     case BTLE_UUID_POWER_MEASUREMENT: parsePowerMeasurement(data);   break;
     case BTLE_UUID_FTMS_BIKE_DATA:    parseFtmsIndoorBikeData(data); break;
     case BTLE_UUID_MOXY_MEASUREMENT:  parseMoxyMeasurement(data);    break;
+    case BTLE_UUID_BATTERY_LEVEL:     parseBatteryLevel(data);       break;
     default: break;
     }
 }
@@ -262,6 +266,15 @@ void BtleHub::onServiceDiscovered(const QBluetoothUuid &serviceUuid)
         if (m_moxyService)
             setupService(m_moxyService);
     }
+    else if (serviceUuid == BtleUuid::BatteryService) {
+        m_batteryService = m_controller->createServiceObject(serviceUuid, this);
+        if (m_batteryService) {
+            // Also handle characteristicRead for the initial one-shot read
+            connect(m_batteryService, &QLowEnergyService::characteristicRead,
+                    this, &BtleHub::onCharacteristicChanged);
+            setupService(m_batteryService);
+        }
+    }
 }
 
 void BtleHub::onDiscoveryFinished()
@@ -352,6 +365,16 @@ void BtleHub::onServiceStateChanged(QLowEnergyService::ServiceState state)
         enableNotification(service,
             service->characteristic(BtleUuid::MoxyMeasurement));
     }
+    else if (service == m_batteryService) {
+        QLowEnergyCharacteristic battChar =
+            service->characteristic(BtleUuid::BatteryLevel);
+        if (battChar.isValid()) {
+            // Enable notifications if the device supports them
+            enableNotification(service, battChar);
+            // Also do an immediate read for instant level on connect
+            service->readCharacteristic(battChar);
+        }
+    }
 }
 
 // ─────────────────────────────────────────────────────────────────────────────
@@ -372,6 +395,8 @@ void BtleHub::onCharacteristicChanged(const QLowEnergyCharacteristic &characteri
         parseFtmsIndoorBikeData(value);
     else if (uuid == BtleUuid::MoxyMeasurement)
         parseMoxyMeasurement(value);
+    else if (uuid == BtleUuid::BatteryLevel)
+        parseBatteryLevel(value);
 }
 
 // ─────────────────────────────────────────────────────────────────────────────
@@ -607,3 +632,27 @@ void BtleHub::parseMoxyMeasurement(const QByteArray &data)
 
     emit signal_oxygen(0, smo2, thb);
 }
+
+// Battery Level (0x2A19)
+// Single byte: battery percentage 0–100
+void BtleHub::parseBatteryLevel(const QByteArray &data)
+{
+    if (data.isEmpty())
+        return;
+
+    int percentage = static_cast<quint8>(data[0]);
+    percentage = qBound(0, percentage, 100);
+
+    emit signal_battery(determineSensorType(), percentage);
+}
+
+// Return a human-readable sensor type based on which services are connected.
+QString BtleHub::determineSensorType() const
+{
+    if (m_hrService)      return QStringLiteral("Heart Rate");
+    if (m_powerService)   return QStringLiteral("Power");
+    if (m_ftmsService)    return QStringLiteral("Trainer");
+    if (m_cscService)     return QStringLiteral("Speed/Cadence");
+    if (m_moxyService)    return QStringLiteral("Oxygen");
+    return QStringLiteral("Sensor");
+}
diff --git a/src/btle/btle_hub.h b/src/btle/btle_hub.h
index a3c1ee02..02cf06af 100644
--- a/src/btle/btle_hub.h
+++ b/src/btle/btle_hub.h
@@ -49,6 +49,10 @@ class BtleHub : public QObject
     void signal_speed(int userID, double speed);       // km/h
     void signal_power(int userID, int power);          // watts
     void signal_oxygen(int userID, double smo2Percent, double thbGdL);
+    /// Emitted when the connected device's Battery Service reports a level.
+    /// \param sensorType  Human-readable sensor name ("Heart Rate", "Power", …)
+    /// \param percentage  Battery level 0–100 (%)
+    void signal_battery(QString sensorType, int percentage);
 
     // ----------- Connection status signals ---------------------------------
     void deviceConnected();
@@ -93,14 +97,17 @@ private slots:
     void parsePowerMeasurement(const QByteArray &data);
     void parseFtmsIndoorBikeData(const QByteArray &data);
     void parseMoxyMeasurement(const QByteArray &data);
+    void parseBatteryLevel(const QByteArray &data);
+    QString determineSensorType() const; ///< Infer sensor type from connected services
 
     QLowEnergyController *m_controller = nullptr;
 
-    QLowEnergyService *m_hrService    = nullptr;
-    QLowEnergyService *m_cscService   = nullptr;
-    QLowEnergyService *m_powerService = nullptr;
-    QLowEnergyService *m_ftmsService  = nullptr;
-    QLowEnergyService *m_moxyService  = nullptr;
+    QLowEnergyService *m_hrService       = nullptr;
+    QLowEnergyService *m_cscService      = nullptr;
+    QLowEnergyService *m_powerService    = nullptr;
+    QLowEnergyService *m_ftmsService     = nullptr;
+    QLowEnergyService *m_moxyService     = nullptr;
+    QLowEnergyService *m_batteryService  = nullptr;
 
     bool m_ftmsControlRequested = false;
 
diff --git a/src/btle/btle_hub_wasm.cpp b/src/btle/btle_hub_wasm.cpp
index 3b6034b6..18f84035 100644
--- a/src/btle/btle_hub_wasm.cpp
+++ b/src/btle/btle_hub_wasm.cpp
@@ -118,11 +118,12 @@ void BtleHubWasm::simulateNotification(quint16 characteristicUuid, const QByteAr
 void BtleHubWasm::onBleNotification(quint16 uuid16, const QByteArray &data)
 {
     switch (uuid16) {
-    case 0x2A37: parseHrMeasurement(data);       break; // Heart Rate Measurement
-    case 0x2A63: parsePowerMeasurement(data);    break; // Cycling Power Measurement
-    case 0x2A5B: parseCscMeasurement(data);      break; // CSC Measurement
-    case 0x2AD2: parseFtmsIndoorBikeData(data);  break; // Indoor Bike Data
-    case 0xAAB2: parseMoxyMeasurement(data);     break; // Moxy Muscle Oxygen
+    case 0x2A37: m_seenHr    = true; parseHrMeasurement(data);       break; // Heart Rate Measurement
+    case 0x2A63: m_seenPower = true; parsePowerMeasurement(data);    break; // Cycling Power Measurement
+    case 0x2A5B: m_seenCsc   = true; parseCscMeasurement(data);      break; // CSC Measurement
+    case 0x2AD2: m_seenFtms  = true; parseFtmsIndoorBikeData(data);  break; // Indoor Bike Data
+    case 0xAAB2: m_seenMoxy  = true; parseMoxyMeasurement(data);     break; // Moxy Muscle Oxygen
+    case 0x2A19: parseBatteryLevel(data);         break; // Battery Level
     default:
         qDebug() << "[BtleHubWasm] Unknown characteristic UUID:" << Qt::hex << uuid16;
         break;
@@ -269,3 +270,28 @@ void BtleHubWasm::parseMoxyMeasurement(const QByteArray &data)
 
     emit signal_oxygen(0, smo2, thb);
 }
+
+// Battery Level (0x2A19)
+// Byte 0: Battery percentage 0–100
+void BtleHubWasm::parseBatteryLevel(const QByteArray &data)
+{
+    if (data.isEmpty())
+        return;
+
+    int percentage = static_cast<quint8>(data[0]);
+    percentage = qBound(0, percentage, 100);
+
+    emit signal_battery(determineSensorType(), percentage);
+}
+
+// Return a human-readable sensor type based on which measurement UUIDs have
+// been received, mirroring BtleHub::determineSensorType().
+QString BtleHubWasm::determineSensorType() const
+{
+    if (m_seenHr)    return QStringLiteral("Heart Rate");
+    if (m_seenPower) return QStringLiteral("Power");
+    if (m_seenFtms)  return QStringLiteral("Trainer");
+    if (m_seenCsc)   return QStringLiteral("Speed/Cadence");
+    if (m_seenMoxy)  return QStringLiteral("Oxygen");
+    return QStringLiteral("Sensor");
+}
diff --git a/src/btle/btle_hub_wasm.h b/src/btle/btle_hub_wasm.h
index e090c8aa..73586173 100644
--- a/src/btle/btle_hub_wasm.h
+++ b/src/btle/btle_hub_wasm.h
@@ -44,6 +44,10 @@ class BtleHubWasm : public QObject
     void signal_speed(int userID, double speed);   // km/h
     void signal_power(int userID, int power);      // watts
     void signal_oxygen(int userID, double smo2Percent, double thbGdL);
+    /// Emitted when the connected device's Battery Service reports a level.
+    /// \param sensorType  Human-readable sensor name ("Heart Rate", "Power", …)
+    /// \param percentage  Battery level 0–100 (%)
+    void signal_battery(QString sensorType, int percentage);
 
     // ── Connection status ─────────────────────────────────────────────────
     void deviceConnected();
@@ -71,6 +75,11 @@ public slots:
     void parsePowerMeasurement(const QByteArray &data);
     void parseFtmsIndoorBikeData(const QByteArray &data);
     void parseMoxyMeasurement(const QByteArray &data);
+    void parseBatteryLevel(const QByteArray &data);
+
+    // Infer a human-readable sensor type from the measurement UUIDs seen so
+    // far, mirroring BtleHub::determineSensorType() which checks service ptrs.
+    QString determineSensorType() const;
 
     bool   m_connected         = false;
     bool   m_userDisconnect    = false; // true when disconnectFromDevice() was called intentionally
@@ -81,6 +90,13 @@ public slots:
     quint16 m_lastCrankRevs    = 0;
     quint16 m_lastCrankTime    = 0;
     bool    m_firstCsc         = true;
+
+    // Track which measurement types have been seen for determineSensorType()
+    bool    m_seenHr           = false;
+    bool    m_seenPower        = false;
+    bool    m_seenFtms         = false;
+    bool    m_seenCsc          = false;
+    bool    m_seenMoxy         = false;
 };
 
 // Alias so headers that #include "btle_hub.h" can use BtleHub type on Wasm
diff --git a/src/btle/btle_uuids.h b/src/btle/btle_uuids.h
index 55486900..6c9a9230 100644
--- a/src/btle/btle_uuids.h
+++ b/src/btle/btle_uuids.h
@@ -11,6 +11,7 @@ static constexpr quint16 BTLE_UUID_HR_MEASUREMENT    = 0x2A37;
 static constexpr quint16 BTLE_UUID_CSC_MEASUREMENT   = 0x2A5B;
 static constexpr quint16 BTLE_UUID_POWER_MEASUREMENT = 0x2A63;
 static constexpr quint16 BTLE_UUID_FTMS_BIKE_DATA    = 0x2AD2;
+static constexpr quint16 BTLE_UUID_BATTERY_LEVEL     = 0x2A19;
 
 // Moxy Muscle Oxygen Monitor (proprietary, not BT SIG)
 static constexpr quint16 BTLE_UUID_MOXY_SERVICE     = 0xAAB0;
diff --git a/src/fitness/fitness.pri b/src/fitness/fitness.pri
index 0904fedd..b9c5fb04 100644
--- a/src/fitness/fitness.pri
+++ b/src/fitness/fitness.pri
@@ -1,3 +1,9 @@
 # src/fitness/fitness.pri — Fitness domain (FIT protocol + achievements)
+INCLUDEPATH += $$PWD
 include($$PWD/fit/fit.pri)
 include($$PWD/achievements/achievements.pri)
+
+SOURCES += $$PWD/mmpcalculator.cpp \
+           $$PWD/pmccalculator.cpp
+HEADERS += $$PWD/mmpcalculator.h \
+           $$PWD/pmccalculator.h
diff --git a/src/fitness/mmpcalculator.cpp b/src/fitness/mmpcalculator.cpp
new file mode 100644
index 00000000..97aa9ac1
--- /dev/null
+++ b/src/fitness/mmpcalculator.cpp
@@ -0,0 +1,167 @@
+#include "mmpcalculator.h"
+
+#include <algorithm>
+#include <numeric>
+#include <fstream>
+#include <cmath>
+
+#include <QDebug>
+
+#include "fit_decode.hpp"
+#include "fit_mesg_broadcaster.hpp"
+#include "fit_profile.hpp"
+#include "fit_record_mesg.hpp"
+#include "fit_record_mesg_listener.hpp"
+#include "fit_runtime_exception.hpp"
+
+// ---------------------------------------------------------------------------
+// Internal FIT Record listener
+// ---------------------------------------------------------------------------
+namespace {
+
+class PowerSeriesReader : public fit::RecordMesgListener
+{
+public:
+    QVector<int> powers;   ///< 1-Hz power series (0 for seconds with no valid power)
+
+    void OnMesg(fit::RecordMesg &mesg) override
+    {
+        if (!mesg.IsTimestampValid())
+            return;
+
+        FIT_DATE_TIME ts = mesg.GetTimestamp();
+
+        if (m_lastTs == 0) {
+            // First record — seed the series
+            m_lastTs = ts;
+            int w = (mesg.IsPowerValid()) ? static_cast<int>(mesg.GetPower()) : 0;
+            powers.append(qBound(0, w, 4999));
+            return;
+        }
+
+        // Fill any gaps with 0 (dropout / pause)
+        int gap = static_cast<int>(ts - m_lastTs);
+        if (gap <= 0) gap = 1; // guard against duplicate / out-of-order timestamps
+        if (gap > 3600) gap = 1; // guard against huge jumps (e.g. multi-day file merge)
+
+        for (int i = 1; i < gap; ++i)
+            powers.append(0);
+
+        int w = (mesg.IsPowerValid()) ? static_cast<int>(mesg.GetPower()) : 0;
+        powers.append(qBound(0, w, 4999));
+        m_lastTs = ts;
+    }
+
+private:
+    FIT_DATE_TIME m_lastTs = 0;
+};
+
+} // anonymous namespace
+
+// ---------------------------------------------------------------------------
+// MmpCalculator
+// ---------------------------------------------------------------------------
+
+QVector<int> MmpCalculator::readPowerSeries(const QString &fitFilePath)
+{
+    PowerSeriesReader reader;
+
+    std::ifstream stream;
+#ifdef Q_OS_WIN32
+    stream.open(fitFilePath.toStdWString(), std::ios::in | std::ios::binary);
+#else
+    stream.open(fitFilePath.toStdString(), std::ios::in | std::ios::binary);
+#endif
+
+    if (!stream.is_open())
+        return {};
+
+    fit::Decode decoder;
+    fit::MesgBroadcaster broadcaster;
+    broadcaster.AddListener(static_cast<fit::RecordMesgListener &>(reader));
+
+    try {
+        decoder.Read(stream, broadcaster, broadcaster);
+    } catch (const fit::RuntimeException &) {
+        // partial decode — return whatever we extracted
+    } catch (...) {}
+
+    return reader.powers;
+}
+
+QVector<double> MmpCalculator::computeMmp(const QList<QString>  &fitFilePaths,
+                                           const QVector<int>    &durations)
+{
+    const int nDur = durations.size();
+    QVector<double> best(nDur, 0.0);
+
+    for (const QString &path : fitFilePaths) {
+        QVector<int> power = readPowerSeries(path);
+        const int n = power.size();
+        if (n == 0) continue;
+
+        for (int di = 0; di < nDur; ++di) {
+            const int D = durations[di];
+            if (D > n) continue; // file too short
+
+            // Compute initial window sum
+            long long windowSum = 0;
+            for (int i = 0; i < D; ++i)
+                windowSum += power[i];
+
+            double maxAvg = static_cast<double>(windowSum) / D;
+
+            // Slide window
+            for (int i = D; i < n; ++i) {
+                windowSum += power[i] - power[i - D];
+                double avg = static_cast<double>(windowSum) / D;
+                if (avg > maxAvg)
+                    maxAvg = avg;
+            }
+
+            if (maxAvg > best[di])
+                best[di] = maxAvg;
+        }
+    }
+
+    return best;
+}
+
+CriticalPowerModel MmpCalculator::fitCriticalPower(const QVector<int>    &durations,
+                                                    const QVector<double> &mmps)
+{
+    // Fit using durations in [120 s, 1800 s] (2 min to 30 min).
+    // Model: TotalWork = W' + CP * Duration
+    // Linear regression Y = a + b*X, Y = MMP*Duration, X = Duration
+    QVector<double> xs, ys;
+    for (int i = 0; i < durations.size() && i < mmps.size(); ++i) {
+        int D = durations[i];
+        double mmp = mmps[i];
+        if (mmp <= 0.0) continue;
+        if (D < 120 || D > 1800) continue;
+        xs.append(static_cast<double>(D));
+        ys.append(mmp * D); // total work (joules)
+    }
+
+    if (xs.size() < 3)
+        return {};
+
+    const int n = xs.size();
+    double sumX = 0, sumY = 0, sumXX = 0, sumXY = 0;
+    for (int i = 0; i < n; ++i) {
+        sumX  += xs[i];
+        sumY  += ys[i];
+        sumXX += xs[i] * xs[i];
+        sumXY += xs[i] * ys[i];
+    }
+
+    double denom = n * sumXX - sumX * sumX;
+    if (std::abs(denom) < 1e-9)
+        return {};
+
+    CriticalPowerModel model;
+    model.cp     = (n * sumXY - sumX * sumY) / denom;   // slope = CP
+    model.wPrime = (sumY - model.cp * sumX) / n;         // intercept = W'
+    model.valid  = (model.cp > 0 && model.wPrime > 0);
+    return model;
+}
diff --git a/src/fitness/mmpcalculator.h b/src/fitness/mmpcalculator.h
new file mode 100644
index 00000000..820de8b1
--- /dev/null
+++ b/src/fitness/mmpcalculator.h
@@ -0,0 +1,58 @@
+#ifndef MMPCALCULATOR_H
+#define MMPCALCULATOR_H
+
+#include <QVector>
+#include <QString>
+#include <QList>
+
+class WorkoutHistorySummary;
+
+/// Standard MMP durations in seconds.
+static const QVector<int> MMP_DURATIONS = {
+    1, 5, 10, 20, 30, 60, 120, 300, 600, 1200, 1800, 3600, 5400, 7200
+};
+
+struct CriticalPowerModel
+{
+    double cp   = 0.0;   ///< Critical Power in watts
+    double wPrime = 0.0; ///< W' (anaerobic work capacity) in joules
+    bool   valid  = false;
+};
+
+/**
+ * @brief Computes Mean Maximal Power (MMP) for a set of activity FIT files
+ *        and fits the CP + W' critical power model.
+ */
+class MmpCalculator
+{
+public:
+    /**
+     * @brief Reads per-second power from a FIT file.
+     * @return Vector of power values (watts), one entry per FIT Record message.
+     */
+    static QVector<int> readPowerSeries(const QString &fitFilePath);
+
+    /**
+     * @brief Computes MMP values over standard durations from all FIT files.
+     * @param fitFilePaths  List of absolute paths to .fit files.
+     * @param durations     Durations in seconds; defaults to MMP_DURATIONS.
+     * @return MMP in watts for each requested duration (0 if no data).
+     */
+    static QVector<double> computeMmp(const QList<QString> &fitFilePaths,
+                                      const QVector<int>   &durations = MMP_DURATIONS);
+
+    /**
+     * @brief Fits the CP + W' model to MMP data.
+     *
+     * Uses linearised regression: Total_Work = W' + CP * Duration.
+     * Only durations in the range [120, 1800] s are used for fitting.
+     *
+     * @param durations  Duration vector (seconds).
+     * @param mmps       Corresponding MMP values (watts); 0 means no data.
+     * @return Fitted CP and W' (invalid if fewer than 2 valid points).
+     */
+    static CriticalPowerModel fitCriticalPower(const QVector<int>    &durations,
+                                               const QVector<double> &mmps);
+};
+
+#endif // MMPCALCULATOR_H
diff --git a/src/fitness/pmccalculator.cpp b/src/fitness/pmccalculator.cpp
new file mode 100644
index 00000000..91df2854
--- /dev/null
+++ b/src/fitness/pmccalculator.cpp
@@ -0,0 +1,54 @@
+#include "pmccalculator.h"
+
+#include <QHash>
+#include <cmath>
+
+QList<PmcPoint> PmcCalculator::compute(const QList<WorkoutHistorySummary> &history,
+                                       const QDate &to,
+                                       int leadInDays)
+{
+    if (history.isEmpty())
+        return {};
+
+    // Build a date → TSS map (sum multiple activities on the same day)
+    QHash<QDate, double> tssByDate;
+    QDate earliest = history.first().startTime.date();
+    for (const WorkoutHistorySummary &s : history) {
+        const QDate d = s.startTime.date();
+        tssByDate[d] += s.tss;
+        if (d < earliest)
+            earliest = d;
+    }
+
+    // Start the computation leadInDays before the first activity so the EMAs
+    // have time to warm up from zero.
+    const QDate from = earliest.addDays(-leadInDays);
+
+    const double kCtlDecay = 1.0 - std::exp(-1.0 / kCtlTc);
+    const double kAtlDecay = 1.0 - std::exp(-1.0 / kAtlTc);
+
+    double ctl = 0.0;
+    double atl = 0.0;
+
+    QList<PmcPoint> result;
+    result.reserve(from.daysTo(to) + 1);
+
+    for (QDate d = from; d <= to; d = d.addDays(1)) {
+        const double tss = tssByDate.value(d, 0.0);
+
+        PmcPoint p;
+        p.date = d;
+        p.tss  = tss;
+        p.tsb  = ctl - atl;   // yesterday's CTL - ATL
+
+        ctl += (tss - ctl) * kCtlDecay;
+        atl += (tss - atl) * kAtlDecay;
+
+        p.ctl  = ctl;
+        p.atl  = atl;
+
+        result.append(p);
+    }
+
+    return result;
+}
diff --git a/src/fitness/pmccalculator.h b/src/fitness/pmccalculator.h
new file mode 100644
index 00000000..13961638
--- /dev/null
+++ b/src/fitness/pmccalculator.h
@@ -0,0 +1,47 @@
+#ifndef PMCCALCULATOR_H
+#define PMCCALCULATOR_H
+
+#include <QDate>
+#include <QList>
+
+#include "workouthistorysummary.h"
+
+/// One day's entry on the Performance Management Chart.
+struct PmcPoint
+{
+    QDate  date;
+    double tss = 0.0;   ///< Total Training Stress for the day
+    double ctl = 0.0;   ///< Chronic Training Load  (42-day EMA, "fitness")
+    double atl = 0.0;   ///< Acute Training Load    (7-day EMA, "fatigue")
+    double tsb = 0.0;   ///< Training Stress Balance = CTL[prev] - ATL[prev] ("form")
+};
+
+/// Computes CTL, ATL and TSB from a list of workout summaries.
+///
+/// Uses the standard exponential moving averages:
+///   CTL[d] = CTL[d-1] + (TSS[d] - CTL[d-1]) * (1 - exp(-1/42))
+///   ATL[d] = ATL[d-1] + (TSS[d] - ATL[d-1]) * (1 - exp(-1/7))
+///   TSB[d] = CTL[d-1] - ATL[d-1]
+class PmcCalculator
+{
+public:
+    /// Compute the PMC curve from \a history.
+    ///
+    /// The returned list spans from the earliest activity date (or \a from,
+    /// whichever is earlier) to \a to (inclusive), one entry per calendar day.
+    ///
+    /// \param history   Parsed workout summaries (any order).
+    /// \param to        Last date to include.  Defaults to today.
+    /// \param leadInDays Number of days before the first activity to start the
+    ///                  computation (with TSS=0) so that CTL/ATL have time to
+    ///                  warm up.  Default: 42.
+    static QList<PmcPoint> compute(const QList<WorkoutHistorySummary> &history,
+                                   const QDate &to = QDate::currentDate(),
+                                   int leadInDays = 42);
+
+private:
+    static constexpr double kCtlTc = 42.0;
+    static constexpr double kAtlTc =  7.0;
+};
+
+#endif // PMCCALCULATOR_H
diff --git a/src/model/account.cpp b/src/model/account.cpp
index fdba7f99..de20343b 100644
--- a/src/model/account.cpp
+++ b/src/model/account.cpp
@@ -51,6 +51,10 @@ Account::Account(QObject *parent) : QObject(parent)  {
     // OAuth2 tokens — loaded to restore an existing OAuth session across restarts.
     intervals_icu_access_token  = settings.value("intervals_icu_access_token",  "").toString();
     intervals_icu_refresh_token = settings.value("intervals_icu_refresh_token", "").toString();
+    // Sensor dropout auto-pause
+    sensor_dropout_enabled   = settings.value("sensor_dropout_enabled",   true).toBool();
+    sensor_dropout_timeout_s = settings.value("sensor_dropout_timeout_s", 5   ).toInt();
+    battery_warning_threshold = settings.value("battery_warning_threshold", 20).toInt();
     settings.endGroup();
 
     // Load encrypted third-party service credentials from the platform credential store.
@@ -154,6 +158,16 @@ Account::Account(QObject *parent) : QObject(parent)  {
     sound_alert_cadence_under_target = false;
     sound_alert_cadence_above_target = false;
 
+    interval_summary_enabled    = true;
+    interval_summary_duration_s = 5;
+    {
+        QSettings s;
+        s.beginGroup("account");
+        interval_summary_enabled    = s.value("interval_summary_enabled",    true).toBool();
+        interval_summary_duration_s = s.value("interval_summary_duration_s", 5).toInt();
+        app_theme = s.value("app_theme", 2).toInt(); // default: System
+        s.endGroup();
+    }
 
     //-------------------------- not in DB ----------------------
     isOffline = false;
@@ -238,6 +252,40 @@ void Account::saveSelfloopsCredentials()
     CredentialStore::store("selfloops", "password", selfloops_pw);
 }
 
+void Account::saveSensorDropoutSettings()
+{
+    QSettings settings;
+    settings.beginGroup("account");
+    settings.setValue("sensor_dropout_enabled",   sensor_dropout_enabled);
+    settings.setValue("sensor_dropout_timeout_s", sensor_dropout_timeout_s);
+    settings.endGroup();
+}
+
+void Account::saveBatteryWarningThreshold()
+{
+    QSettings settings;
+    settings.beginGroup("account");
+    settings.setValue("battery_warning_threshold", battery_warning_threshold);
+    settings.endGroup();
+}
+
+void Account::saveIntervalSummarySettings()
+{
+    QSettings settings;
+    settings.beginGroup("account");
+    settings.setValue("interval_summary_enabled",    interval_summary_enabled);
+    settings.setValue("interval_summary_duration_s", interval_summary_duration_s);
+    settings.endGroup();
+}
+
+void Account::saveAppTheme()
+{
+    QSettings s;
+    s.beginGroup("account");
+    s.setValue("app_theme", app_theme);
+    s.endGroup();
+}
+
 
 
 
diff --git a/src/model/account.h b/src/model/account.h
index 67884f5e..8fb87cf2 100644
--- a/src/model/account.h
+++ b/src/model/account.h
@@ -21,6 +21,10 @@ class Account : public QObject
     void saveNbSecShowIntervalBefore(int nbSec);
     void saveErgSmoothingDuration(int seconds);
     void saveIntervalsIcuCredentials();
+    void saveSensorDropoutSettings();
+    void saveBatteryWarningThreshold();
+    void saveIntervalSummarySettings();
+    void saveAppTheme();
 
     /// Encrypt and persist Strava OAuth2 tokens to QSettings.
     /// Call after a successful token exchange or refresh.
@@ -107,8 +111,17 @@ class Account : public QObject
     bool stop_pairing_on_found;
     int nb_sec_pairing;
     int erg_smoothing_duration_s;  ///< Ramp duration (seconds) for ERG setpoint transitions; 0 = disabled.
+
+    /// Battery warning threshold (issue #156): warn when a sensor's battery
+    /// drops at or below this percentage (default 20, range 5–50).
+    int battery_warning_threshold;
+
     /* ----- */
 
+    // Sensor dropout auto-pause
+    bool sensor_dropout_enabled;   ///< Master toggle for auto-pause on sensor dropout
+    int  sensor_dropout_timeout_s; ///< Seconds before dropout triggers pause (default 5, range 2–30)
+
     int last_index_selected_config_workout;
     int last_tab_sub_config_selected;
     QString tab_display[8];
@@ -201,6 +214,11 @@ class Account : public QObject
     bool sound_alert_power_above_target;
     bool sound_alert_cadence_under_target;
     bool sound_alert_cadence_above_target;
+
+    bool interval_summary_enabled;
+    int  interval_summary_duration_s; ///< seconds to display overlay (2–15)
+
+    int app_theme; ///< 0=Light, 1=Dark, 2=System (default)
     //----
 
 
diff --git a/src/model/dataworkout.h b/src/model/dataworkout.h
index e62f2cc7..449febd4 100644
--- a/src/model/dataworkout.h
+++ b/src/model/dataworkout.h
@@ -52,6 +52,12 @@ class DataWorkout : public QObject
     int getLTHR();
     //-----------------
 
+    // Interval average accessors — valid until the next changeInterval() call
+    double getAvgIntervalPower() const { return avgIntervalPower; }
+    double getAvgIntervalHr()    const { return avgIntervalHr; }
+    double getAvgIntervalCad()   const { return avgIntervalCad; }
+    int    getNbPointsIntervalPower() const { return nbPointsIntervalPower; }
+
 
 
 
diff --git a/src/model/intervalsummaryutil.h b/src/model/intervalsummaryutil.h
new file mode 100644
index 00000000..e496492b
--- /dev/null
+++ b/src/model/intervalsummaryutil.h
@@ -0,0 +1,28 @@
+#ifndef INTERVALSUMMARYUTIL_H
+#define INTERVALSUMMARYUTIL_H
+
+/// Power-adherence classification for the per-interval summary overlay.
+/// Pure header-only utility — no Qt dependency — so it is trivially testable.
+namespace IntervalSummaryUtil {
+
+    enum class PowerAdherence {
+        Met,      ///< avg power within ±5 % of target
+        NearMiss, ///< avg power within ±10 % of target
+        Missed    ///< avg power outside ±10 % of target
+    };
+
+    /// Classify whether avgPower met the targetPower.
+    /// Returns Met if targetPower <= 0 (no power-based target).
+    inline PowerAdherence classifyPowerAdherence(double avgPower, double targetPower)
+    {
+        if (targetPower <= 0.0)
+            return PowerAdherence::Met;
+        const double ratio = avgPower / targetPower;
+        if (ratio >= 0.95 && ratio <= 1.05) return PowerAdherence::Met;
+        if (ratio >= 0.90 && ratio <= 1.10) return PowerAdherence::NearMiss;
+        return PowerAdherence::Missed;
+    }
+
+} // namespace IntervalSummaryUtil
+
+#endif // INTERVALSUMMARYUTIL_H
diff --git a/src/model/model.pri b/src/model/model.pri
index 566c69d1..ad623910 100644
--- a/src/model/model.pri
+++ b/src/model/model.pri
@@ -21,7 +21,8 @@ SOURCES += src/model/interval.cpp\
     $$PWD/course.cpp \
     $$PWD/coursetablemodel.cpp \
     $$PWD/sortfilterproxymodelcourse.cpp \
-    $$PWD/userstudio.cpp
+    $$PWD/userstudio.cpp \
+    $$PWD/workoutqueue.cpp
 
 HEADERS += src/model/interval.h\
     src/model/workout.h \
@@ -37,6 +38,7 @@ HEADERS += src/model/interval.h\
     src/model/zoneobject.h \
     src/model/powercurve.h \
     src/model/planobject.h \
+    src/model/intervalsummaryutil.h \
     $$PWD/radiotablemodel.h \
     $$PWD/radio.h \
     $$PWD/trackpoint.h \
@@ -44,6 +46,7 @@ HEADERS += src/model/interval.h\
     $$PWD/coursetablemodel.h \
     $$PWD/sortfilterproxymodelcourse.h \
     $$PWD/userstudio.h \
+    $$PWD/workoutqueue.h \
     $$PWD/workouthistorysummary.h
 
 
diff --git a/src/model/workoutqueue.cpp b/src/model/workoutqueue.cpp
new file mode 100644
index 00000000..f49b9d39
--- /dev/null
+++ b/src/model/workoutqueue.cpp
@@ -0,0 +1,93 @@
+#include "workoutqueue.h"
+
+#include <QSettings>
+#include <utility>
+
+WorkoutQueue::WorkoutQueue(QObject *parent) : QObject(parent)
+{
+    load();
+}
+
+void WorkoutQueue::addWorkout(const QString &filePath, const QString &name)
+{
+    m_filePaths.append(filePath);
+    m_names.append(name);
+    save();
+    emit queueChanged();
+}
+
+void WorkoutQueue::removeAt(int index)
+{
+    if (index < 0 || index >= m_filePaths.size()) return;
+    m_filePaths.removeAt(index);
+    m_names.removeAt(index);
+    save();
+    emit queueChanged();
+}
+
+void WorkoutQueue::moveUp(int index)
+{
+    if (index <= 0 || index >= m_filePaths.size()) return;
+    m_filePaths.swapItemsAt(index, index - 1);
+    m_names.swapItemsAt(index, index - 1);
+    save();
+    emit queueChanged();
+}
+
+void WorkoutQueue::moveDown(int index)
+{
+    if (index < 0 || index >= m_filePaths.size() - 1) return;
+    m_filePaths.swapItemsAt(index, index + 1);
+    m_names.swapItemsAt(index, index + 1);
+    save();
+    emit queueChanged();
+}
+
+void WorkoutQueue::clear()
+{
+    m_filePaths.clear();
+    m_names.clear();
+    save();
+    emit queueChanged();
+}
+
+QString WorkoutQueue::dequeueFilePath()
+{
+    if (m_filePaths.isEmpty()) return {};
+    QString path = m_filePaths.takeFirst();
+    if (!m_names.isEmpty()) m_names.takeFirst();
+    save();
+    emit queueChanged();
+    return path;
+}
+
+QString WorkoutQueue::dequeueName()
+{
+    if (m_names.isEmpty()) return {};
+    QString name = m_names.takeFirst();
+    if (!m_filePaths.isEmpty()) m_filePaths.takeFirst();
+    save();
+    emit queueChanged();
+    return name;
+}
+
+void WorkoutQueue::save() const
+{
+    QSettings s;
+    s.beginGroup("workoutQueue");
+    s.setValue("filePaths", m_filePaths);
+    s.setValue("names",     m_names);
+    s.endGroup();
+}
+
+void WorkoutQueue::load()
+{
+    QSettings s;
+    s.beginGroup("workoutQueue");
+    m_filePaths = s.value("filePaths").toStringList();
+    m_names     = s.value("names").toStringList();
+    s.endGroup();
+    // Defensive: keep lists in sync
+    while (m_names.size() < m_filePaths.size()) m_names.append(QString());
+    while (m_names.size() > m_filePaths.size()) m_names.removeLast();
+}
diff --git a/src/model/workoutqueue.h b/src/model/workoutqueue.h
new file mode 100644
index 00000000..53ec6ee9
--- /dev/null
+++ b/src/model/workoutqueue.h
@@ -0,0 +1,49 @@
+#ifndef WORKOUTQUEUE_H
+#define WORKOUTQUEUE_H
+
+#include <QObject>
+#include <QStringList>
+
+/// Manages a persistent ordered list of workout file paths to execute sequentially.
+/// The queue is serialised to QSettings under the key "workoutQueue/filePaths".
+class WorkoutQueue : public QObject
+{
+    Q_OBJECT
+public:
+    explicit WorkoutQueue(QObject *parent = nullptr);
+
+    void addWorkout(const QString &filePath, const QString &name);
+    void removeAt(int index);
+    void moveUp(int index);
+    void moveDown(int index);
+    void clear();
+
+    bool isEmpty() const { return m_filePaths.isEmpty(); }
+    int  count()   const { return m_filePaths.size(); }
+
+    QString filePath(int index) const { return m_filePaths.value(index); }
+    QString name(int index)     const { return m_names.value(index); }
+
+    QStringList filePaths() const { return m_filePaths; }
+    QStringList names()     const { return m_names; }
+
+    /// Consume (remove and return) the first workout file path in the queue.
+    /// Returns an empty string if the queue is empty.
+    QString dequeueFilePath();
+
+    /// Return the name of the first workout in the queue without removing it.
+    /// Returns an empty string if the queue is empty.
+    QString dequeueName();
+
+    void save() const;
+    void load();
+
+signals:
+    void queueChanged();
+
+private:
+    QStringList m_filePaths;
+    QStringList m_names;
+};
+
+#endif // WORKOUTQUEUE_H
diff --git a/src/ui/apptheme.h b/src/ui/apptheme.h
new file mode 100644
index 00000000..e62ff0f9
--- /dev/null
+++ b/src/ui/apptheme.h
@@ -0,0 +1,180 @@
+#ifndef APPTHEME_H
+#define APPTHEME_H
+
+#include <QApplication>
+#include <QGuiApplication>
+#include <QStyleHints>
+#include <QString>
+#include <QColor>
+#include <QPalette>
+
+/// Manages the two built-in application stylesheets (Light / Dark)
+/// and the automatic "System" mode that tracks the OS colour scheme.
+///
+/// Usage:
+///   AppTheme::apply(qApp, static_cast<AppTheme::Mode>(account->app_theme));
+class AppTheme : public QObject
+{
+    Q_OBJECT
+public:
+    enum Mode { Light = 0, Dark = 1, System = 2 };
+
+    /// Resolve System mode to the actual Light/Dark mode based on the OS.
+    static Mode resolveMode(Mode mode)
+    {
+        if (mode != System)
+            return mode;
+#if QT_VERSION >= QT_VERSION_CHECK(6, 5, 0)
+        return (QGuiApplication::styleHints()->colorScheme() == Qt::ColorScheme::Dark)
+               ? Dark : Light;
+#else
+        const QColor bg = QGuiApplication::palette().color(QPalette::Window);
+        return (bg.lightness() < 128) ? Dark : Light;
+#endif
+    }
+
+    /// Apply the stylesheet for the given mode to the application.
+    static void apply(QApplication *app, Mode mode)
+    {
+        const Mode resolved = resolveMode(mode);
+        if (resolved == Dark) {
+            app->setStyleSheet(darkStylesheet());
+        } else {
+            // Restore the original z_stylesheet-based light theme.
+            const QString base = qApp->property("lightStylesheet").toString();
+            app->setStyleSheet(base.isEmpty() ? lightStylesheet() : base);
+        }
+    }
+
+    /// The existing (unchanged) light stylesheet.
+    static QString lightStylesheet()
+    {
+        return QStringLiteral(
+"QMainWindow#MainWindow {"
+"  background: qlineargradient(spread:pad, x1:0, y1:0, x2:1, y2:0, stop:0 #2a2a2a, stop:1.0 #4b4b4b);"
+"}"
+"QLabel#label_headerMain { color: white; }"
+"QWidget#widget_fancyMenu {"
+"  border: 1px solid #313131;"
+"}"
+"QWidget#tab_workout1, #tab_workout2, #tab_profile1, #tab_achiev1, #tableView_workout,"
+"  #tab_create, #tableView_course, #tab_course, #tab_edit_course {"
+"  background-color: #f0f0f0;"
+"}"
+"QWidget#tabWidget_course, #tab_course, #tab_edit_course {"
+"  background-color: #f0f0f0;"
+"}"
+"QTableView#tableView_workout, QTableView#tableView_course {"
+"  gridline-color: gray;"
+"}"
+"QSplitter::handle {"
+"  background-color: qlineargradient(spread:pad, x1:0, y1:0, x2:1, y2:0,"
+"    stop:0 rgba(101,104,113,255), stop:0.5 rgba(101,104,113,235), stop:1.0 rgba(101,104,113,255));"
+"}"
+"QPushButton.boutonLogin {"
+"  font: bold; color: white; background-color: #5cb85c;"
+"  border: 2px solid #4cae4c; border-radius: 3px; padding: 5px; min-width: 80px;"
+"}"
+"QPushButton.boutonLogin:hover { background-color: #47a447; border: 2px solid #398439; }"
+"QPushButton.boutonLogin:pressed { border: 3px solid #398439; }"
+"QLabel.labelImageHr      { image: url(:/image/icon/heart2); }"
+"QLabel.labelImagePower   { image: url(:/image/icon/power2); }"
+"QLabel.labelImageCadence { image: url(:/image/icon/crank2); }"
+"QLabel.labelImageSpeed   { image: url(:/image/icon/speed); }"
+"QLabel.labelImageCalories{ image: url(:/image/icon/burn); }"
+"QLabel.label_clockgreen  { image: url(:/image/icon/clock_green); }"
+"QLabel.label_clockorange { image: url(:/image/icon/clock_orange); }"
+        );
+    }
+
+    /// Dark variant: darkens the content-area tabs, dialogs, and standard
+    /// controls while keeping the existing dark chrome untouched.
+    static QString darkStylesheet()
+    {
+        return QStringLiteral(
+// ── Main window chrome (same as light) ──────────────────────────────────
+"QMainWindow#MainWindow {"
+"  background: qlineargradient(spread:pad, x1:0, y1:0, x2:1, y2:0, stop:0 #1a1a1a, stop:1.0 #2e2e2e);"
+"}"
+"QLabel#label_headerMain { color: white; }"
+"QWidget#widget_fancyMenu { border: 1px solid #313131; }"
+// ── Content tab areas ────────────────────────────────────────────────────
+"QWidget#tab_workout1, #tab_workout2, #tab_profile1, #tab_achiev1, #tableView_workout,"
+"  #tab_create, #tableView_course, #tab_course, #tab_edit_course {"
+"  background-color: #242424;"
+"}"
+"QWidget#tabWidget_course, #tab_course, #tab_edit_course {"
+"  background-color: #242424;"
+"}"
+// ── General widget defaults ──────────────────────────────────────────────
+"QWidget { background-color: #2b2b2b; color: #e0e0e0; }"
+"QDialog { background-color: #2b2b2b; color: #e0e0e0; }"
+"QGroupBox { color: #e0e0e0; border: 1px solid #444; border-radius: 4px; margin-top: 8px; padding-top: 4px; }"
+"QGroupBox::title { subcontrol-origin: margin; left: 8px; color: #ccc; }"
+"QLabel { color: #e0e0e0; background-color: transparent; }"
+"QLineEdit, QTextEdit, QPlainTextEdit {"
+"  background-color: #3a3a3a; color: #e0e0e0; border: 1px solid #555; border-radius: 3px;"
+"}"
+"QLineEdit:focus, QTextEdit:focus { border: 1px solid #5a9fd4; }"
+"QComboBox {"
+"  background-color: #3a3a3a; color: #e0e0e0; border: 1px solid #555; border-radius: 3px; padding: 2px 4px;"
+"}"
+"QComboBox QAbstractItemView {"
+"  background-color: #3a3a3a; color: #e0e0e0; selection-background-color: #4a7ab5;"
+"}"
+"QSpinBox {"
+"  background-color: #3a3a3a; color: #e0e0e0; border: 1px solid #555; border-radius: 3px;"
+"}"
+"QPushButton {"
+"  background-color: #3d3d3d; color: #e0e0e0; border: 1px solid #555; border-radius: 3px; padding: 4px 10px;"
+"}"
+"QPushButton:hover { background-color: #4a4a4a; }"
+"QPushButton:pressed { background-color: #2a2a2a; }"
+"QPushButton:disabled { color: #777; border-color: #444; }"
+"QPushButton.boutonLogin {"
+"  font: bold; color: white; background-color: #4a8f4a;"
+"  border: 2px solid #3a7f3a; border-radius: 3px; padding: 5px; min-width: 80px;"
+"}"
+"QPushButton.boutonLogin:hover { background-color: #3a7f3a; }"
+"QCheckBox { color: #e0e0e0; }"
+"QCheckBox::indicator { width: 14px; height: 14px; border: 1px solid #666; border-radius: 2px; background: #3a3a3a; }"
+"QCheckBox::indicator:checked { background: #5a9fd4; border-color: #4a8fc4; }"
+"QTabWidget::pane { border: 1px solid #444; background: #2b2b2b; }"
+"QTabBar::tab { background: #3a3a3a; color: #ccc; border: 1px solid #444; padding: 6px 12px; }"
+"QTabBar::tab:selected { background: #2b2b2b; color: white; border-bottom: none; }"
+"QTabBar::tab:hover { background: #444; }"
+"QTableView, QListView, QTreeView {"
+"  background-color: #2e2e2e; alternate-background-color: #333; color: #e0e0e0;"
+"  gridline-color: #444; selection-background-color: #4a7ab5; selection-color: white;"
+"}"
+"QHeaderView::section {"
+"  background-color: #3a3a3a; color: #ccc; border: 1px solid #444; padding: 4px;"
+"}"
+"QScrollBar:vertical, QScrollBar:horizontal {"
+"  background: #2e2e2e; width: 10px; height: 10px; border: none;"
+"}"
+"QScrollBar::handle:vertical, QScrollBar::handle:horizontal {"
+"  background: #555; border-radius: 5px; min-height: 20px;"
+"}"
+"QScrollBar::handle:hover { background: #777; }"
+"QScrollBar::add-line, QScrollBar::sub-line { height: 0px; width: 0px; }"
+"QToolTip { background-color: #3a3a3a; color: #e0e0e0; border: 1px solid #555; }"
+"QMenuBar { background-color: #2b2b2b; color: #e0e0e0; }"
+"QMenuBar::item:selected { background: #3d3d3d; }"
+"QMenu { background-color: #2b2b2b; color: #e0e0e0; border: 1px solid #555; }"
+"QMenu::item:selected { background: #4a7ab5; }"
+"QStatusBar { background-color: #2b2b2b; color: #aaa; }"
+"QSplitter::handle { background: #444; }"
+"QTableView#tableView_workout, QTableView#tableView_course { gridline-color: #444; }"
+"QLabel.labelImageHr      { image: url(:/image/icon/heart2); }"
+"QLabel.labelImagePower   { image: url(:/image/icon/power2); }"
+"QLabel.labelImageCadence { image: url(:/image/icon/crank2); }"
+"QLabel.labelImageSpeed   { image: url(:/image/icon/speed); }"
+"QLabel.labelImageCalories{ image: url(:/image/icon/burn); }"
+"QLabel.label_clockgreen  { image: url(:/image/icon/clock_green); }"
+"QLabel.label_clockorange { image: url(:/image/icon/clock_orange); }"
+        );
+    }
+};
+
+#endif // APPTHEME_H
diff --git a/src/ui/criticalpowerdialog.cpp b/src/ui/criticalpowerdialog.cpp
new file mode 100644
index 00000000..4720ebb7
--- /dev/null
+++ b/src/ui/criticalpowerdialog.cpp
@@ -0,0 +1,186 @@
+#include "criticalpowerdialog.h"
+
+#include "mmpcalculator.h"
+
+#include <QVBoxLayout>
+#include <QHBoxLayout>
+#include <QLabel>
+#include <QDialogButtonBox>
+#include <QApplication>
+#include <QFrame>
+
+#include "qwt_plot.h"
+#include "qwt_plot_curve.h"
+#include "qwt_plot_grid.h"
+#include "qwt_scale_engine.h"
+#include "qwt_scale_draw.h"
+#include "qwt_text.h"
+#include "qwt_symbol.h"
+
+// ---------------------------------------------------------------------------
+// Custom scale draw for human-readable duration labels
+// ---------------------------------------------------------------------------
+class DurationScaleDraw : public QwtScaleDraw
+{
+public:
+    QwtText label(double value) const override
+    {
+        int sec = static_cast<int>(value + 0.5);
+        if (sec < 60)
+            return QwtText(QString::number(sec) + QStringLiteral("s"));
+        if (sec < 3600) {
+            int m = sec / 60, s = sec % 60;
+            if (s == 0)
+                return QwtText(QString::number(m) + QStringLiteral("m"));
+            return QwtText(QString("%1:%2").arg(m).arg(s, 2, 10, QChar('0')));
+        }
+        int h = sec / 3600, m = (sec % 3600) / 60;
+        if (m == 0)
+            return QwtText(QString::number(h) + QStringLiteral("h"));
+        return QwtText(QString("%1h%2").arg(h).arg(m, 2, 10, QChar('0')));
+    }
+};
+
+// ---------------------------------------------------------------------------
+// CriticalPowerDialog
+// ---------------------------------------------------------------------------
+
+CriticalPowerDialog::CriticalPowerDialog(const QList<WorkoutHistorySummary> &history,
+                                         QWidget *parent)
+    : QDialog(parent)
+    , m_history(history)
+{
+    setWindowTitle(tr("Critical Power Curve"));
+    setMinimumSize(640, 480);
+    setupUi();
+    calculate();
+}
+
+void CriticalPowerDialog::setupUi()
+{
+    m_plot = new QwtPlot(this);
+    m_plot->setTitle(tr("Mean Maximal Power"));
+    m_plot->setAxisTitle(QwtPlot::xBottom, tr("Duration"));
+    m_plot->setAxisTitle(QwtPlot::yLeft,   tr("Power (W)"));
+    m_plot->setAxisScaleEngine(QwtPlot::xBottom, new QwtLogScaleEngine());
+    m_plot->setAxisScaleDraw(QwtPlot::xBottom, new DurationScaleDraw());
+    m_plot->setCanvasBackground(Qt::white);
+
+    auto *grid = new QwtPlotGrid();
+    grid->setMajorPen(Qt::lightGray, 1, Qt::DashLine);
+    grid->attach(m_plot);
+
+    m_mmpCurve = new QwtPlotCurve(tr("MMP"));
+    m_mmpCurve->setStyle(QwtPlotCurve::Lines);
+    m_mmpCurve->setSymbol(new QwtSymbol(QwtSymbol::Ellipse,
+                                         QBrush(QColor(0, 114, 189)),
+                                         QPen(QColor(0, 114, 189)), QSize(6, 6)));
+    m_mmpCurve->setPen(QColor(0, 114, 189), 2);
+    m_mmpCurve->attach(m_plot);
+
+    m_cpCurve = new QwtPlotCurve(tr("CP Model"));
+    m_cpCurve->setStyle(QwtPlotCurve::Lines);
+    m_cpCurve->setPen(QColor(217, 83, 25), 2, Qt::DashLine);
+    m_cpCurve->attach(m_plot);
+
+    // Readout panel
+    auto *statsFrame = new QFrame(this);
+    statsFrame->setFrameShape(QFrame::StyledPanel);
+    auto *statsLayout = new QHBoxLayout(statsFrame);
+
+    m_cpLabel = new QLabel(tr("CP: —"), statsFrame);
+    m_cpLabel->setStyleSheet(QStringLiteral("font-weight: bold; font-size: 14px;"));
+
+    m_wPrimeLabel = new QLabel(tr("W': —"), statsFrame);
+    m_wPrimeLabel->setStyleSheet(QStringLiteral("font-weight: bold; font-size: 14px;"));
+
+    statsLayout->addStretch();
+    statsLayout->addWidget(m_cpLabel);
+    statsLayout->addSpacing(24);
+    statsLayout->addWidget(m_wPrimeLabel);
+    statsLayout->addStretch();
+
+    m_statusLabel = new QLabel(this);
+
+    auto *buttonBox = new QDialogButtonBox(QDialogButtonBox::Close, this);
+    connect(buttonBox, &QDialogButtonBox::rejected, this, &QDialog::reject);
+
+    auto *mainLayout = new QVBoxLayout(this);
+    mainLayout->addWidget(m_plot, 1);
+    mainLayout->addWidget(statsFrame);
+    mainLayout->addWidget(m_statusLabel);
+    mainLayout->addWidget(buttonBox);
+}
+
+void CriticalPowerDialog::calculate()
+{
+    if (m_history.isEmpty()) {
+        m_statusLabel->setText(tr("No activities to analyse."));
+        return;
+    }
+
+    m_statusLabel->setText(tr("Calculating…"));
+    qApp->processEvents();
+
+    QList<QString> paths;
+    for (const WorkoutHistorySummary &s : m_history) {
+        if (!s.filePath.isEmpty())
+            paths.append(s.filePath);
+    }
+
+    m_mmps    = MmpCalculator::computeMmp(paths, MMP_DURATIONS);
+    m_cpModel = MmpCalculator::fitCriticalPower(MMP_DURATIONS, m_mmps);
+
+    updatePlot(m_mmps);
+    updateLabels(m_cpModel);
+
+    int activitiesWithPower = 0;
+    for (double v : m_mmps) { if (v > 0) { ++activitiesWithPower; break; } }
+    if (activitiesWithPower == 0)
+        m_statusLabel->setText(tr("No power data found in %1 activit(y/ies).").arg(paths.size()));
+    else
+        m_statusLabel->setText(tr("Based on %n activit(y/ies).", "", paths.size()));
+}
+
+void CriticalPowerDialog::updatePlot(const QVector<double> &mmps)
+{
+    QVector<double> xs, ys;
+    for (int i = 0; i < MMP_DURATIONS.size() && i < mmps.size(); ++i) {
+        if (mmps[i] > 0) {
+            xs.append(static_cast<double>(MMP_DURATIONS[i]));
+            ys.append(mmps[i]);
+        }
+    }
+
+    if (!xs.isEmpty()) {
+        m_mmpCurve->setSamples(xs, ys);
+        m_plot->setAxisScale(QwtPlot::xBottom, xs.first(), xs.last());
+    }
+
+    // CP model curve (smooth, over full range of valid MMP durations)
+    if (m_cpModel.valid && !xs.isEmpty()) {
+        QVector<double> cxs, cys;
+        for (int i = 0; i < MMP_DURATIONS.size() && i < mmps.size(); ++i) {
+            if (mmps[i] > 0) {
+                double t = static_cast<double>(MMP_DURATIONS[i]);
+                cxs.append(t);
+                cys.append(m_cpModel.cp + m_cpModel.wPrime / t);
+            }
+        }
+        m_cpCurve->setSamples(cxs, cys);
+    }
+
+    m_plot->replot();
+}
+
+void CriticalPowerDialog::updateLabels(const CriticalPowerModel &model)
+{
+    if (model.valid) {
+        m_cpLabel->setText(tr("CP: %1 W").arg(qRound(model.cp)));
+        double wPrimeKj = model.wPrime / 1000.0;
+        m_wPrimeLabel->setText(tr("W': %1 kJ").arg(wPrimeKj, 0, 'f', 1));
+    } else {
+        m_cpLabel->setText(tr("CP: —"));
+        m_wPrimeLabel->setText(tr("W': —  (need ≥3 efforts at 2–30 min)"));
+    }
+}
diff --git a/src/ui/criticalpowerdialog.h b/src/ui/criticalpowerdialog.h
new file mode 100644
index 00000000..32e3ab0b
--- /dev/null
+++ b/src/ui/criticalpowerdialog.h
@@ -0,0 +1,46 @@
+#ifndef CRITICALPOWERDIALOG_H
+#define CRITICALPOWERDIALOG_H
+
+#include <QDialog>
+#include <QList>
+
+#include "workouthistorysummary.h"
+#include "mmpcalculator.h"
+
+class QLabel;
+class QwtPlot;
+class QwtPlotCurve;
+
+/**
+ * @brief Dialog displaying the Mean Maximal Power (MMP) curve and fitted
+ *        Critical Power (CP) model for a rider's history of FIT activities.
+ *
+ * Open from the Workout History tab via the "Critical Power" button.
+ */
+class CriticalPowerDialog : public QDialog
+{
+    Q_OBJECT
+
+public:
+    explicit CriticalPowerDialog(const QList<WorkoutHistorySummary> &history,
+                                 QWidget *parent = nullptr);
+
+private:
+    void setupUi();
+    void calculate();
+    void updatePlot(const QVector<double> &mmps);
+    void updateLabels(const CriticalPowerModel &model);
+
+    QList<WorkoutHistorySummary> m_history;
+    QVector<double>              m_mmps;
+    CriticalPowerModel           m_cpModel;
+
+    QwtPlot      *m_plot       = nullptr;
+    QwtPlotCurve *m_mmpCurve   = nullptr;
+    QwtPlotCurve *m_cpCurve    = nullptr;
+    QLabel       *m_cpLabel    = nullptr;
+    QLabel       *m_wPrimeLabel= nullptr;
+    QLabel       *m_statusLabel= nullptr;
+};
+
+#endif // CRITICALPOWERDIALOG_H
diff --git a/src/ui/dialogconfig.cpp b/src/ui/dialogconfig.cpp
index 3bfdba7a..4bafbfcf 100644
--- a/src/ui/dialogconfig.cpp
+++ b/src/ui/dialogconfig.cpp
@@ -10,9 +10,12 @@
 #include <QDesktopServices>
 #include <QSettings>
 #include <QMessageBox>
+#include <QApplication>
 
 #include "workoutdialog.h"
 #include "logger.h"
+#include "apptheme.h"
+#include "account.h"
 
 
 
@@ -1183,6 +1186,21 @@ QWidget *DialogConfig::setupLanguageTab()
     grpLayout->addWidget(labelRestartNote);
 
     layout->addWidget(grp);
+
+    // Theme group
+    auto *grpTheme = new QGroupBox(tr("Application Theme"), page);
+    auto *grpThemeLayout = new QVBoxLayout(grpTheme);
+
+    auto *themeRow = new QHBoxLayout();
+    themeRow->addWidget(new QLabel(tr("Theme:"), grpTheme));
+    comboTheme = new QComboBox(grpTheme);
+    comboTheme->addItem(tr("Light"),  0);
+    comboTheme->addItem(tr("Dark"),   1);
+    comboTheme->addItem(tr("System (follow OS)"), 2);
+    themeRow->addWidget(comboTheme, 1);
+    grpThemeLayout->addLayout(themeRow);
+
+    layout->addWidget(grpTheme);
     layout->addStretch();
 
     connect(comboLanguage, QOverload<int>::of(&QComboBox::currentIndexChanged), this, [this]() {
@@ -1204,6 +1222,13 @@ void DialogConfig::initLanguageTab()
     comboLanguage->blockSignals(true);
     comboLanguage->setCurrentIndex(langIdx < comboLanguage->count() ? langIdx : 0);
     comboLanguage->blockSignals(false);
+
+    if (comboTheme) {
+        auto *account = qApp->property("Account").value<Account*>();
+        const int theme = account ? account->app_theme : 2;
+        const int idx = comboTheme->findData(theme);
+        comboTheme->setCurrentIndex(idx >= 0 ? idx : 2);
+    }
 }
 
 void DialogConfig::saveLanguageTab()
@@ -1213,6 +1238,15 @@ void DialogConfig::saveLanguageTab()
     s.beginGroup("language_app");
     s.setValue("lang", comboLanguage->currentData().toInt());
     s.endGroup();
+
+    if (comboTheme) {
+        auto *account = qApp->property("Account").value<Account*>();
+        if (account) {
+            account->app_theme = comboTheme->currentData().toInt();
+            account->saveAppTheme();
+            AppTheme::apply(qApp, static_cast<AppTheme::Mode>(account->app_theme));
+        }
+    }
 }
 
 // ─── Studio tab (#134) ───────────────────────────────────────────────────────
@@ -1324,6 +1358,69 @@ QWidget *DialogConfig::setupTrainerTab()
     grpUploadsLayout->addWidget(uploadNote);
     layout->addWidget(grpUploads);
 
+    // ── Sensor Dropout ──────────────────────────────────────────────────────
+    auto *grpDropout = new QGroupBox(tr("Sensor Dropout"), page);
+    auto *dropoutLayout = new QVBoxLayout(grpDropout);
+
+    checkDropoutEnabled = new QCheckBox(tr("Auto-pause workout when sensor signal is lost"), grpDropout);
+    dropoutLayout->addWidget(checkDropoutEnabled);
+
+    auto *timeoutRow = new QHBoxLayout();
+    timeoutRow->addWidget(new QLabel(tr("Dropout timeout (seconds):"), grpDropout));
+    spinDropoutTimeout = new QSpinBox(grpDropout);
+    spinDropoutTimeout->setRange(2, 30);
+    spinDropoutTimeout->setSuffix(tr(" s"));
+    timeoutRow->addWidget(spinDropoutTimeout);
+    timeoutRow->addStretch();
+    dropoutLayout->addLayout(timeoutRow);
+
+    auto *dropoutNote = new QLabel(
+        tr("Workout resumes automatically 3 seconds after the signal is restored."), grpDropout);
+    dropoutNote->setStyleSheet("color: #888; font-style: italic;");
+    dropoutNote->setWordWrap(true);
+    dropoutLayout->addWidget(dropoutNote);
+
+    layout->addWidget(grpDropout);
+
+    // ── Battery Warning ─────────────────────────────────────────────────────
+    auto *grpBatt = new QGroupBox(tr("Battery Warning"), page);
+    auto *battLayout = new QVBoxLayout(grpBatt);
+
+    auto *battRow = new QHBoxLayout();
+    battRow->addWidget(new QLabel(tr("Warn when battery drops below:"), grpBatt));
+    spinBatteryThreshold = new QSpinBox(grpBatt);
+    spinBatteryThreshold->setRange(5, 50);
+    spinBatteryThreshold->setSuffix(tr(" %"));
+    battRow->addWidget(spinBatteryThreshold);
+    battRow->addStretch();
+    battLayout->addLayout(battRow);
+
+    auto *battNote = new QLabel(
+        tr("A toast notification is shown when a sensor reports a battery level "
+           "at or below this threshold."), grpBatt);
+    battNote->setStyleSheet("color: #888; font-style: italic;");
+    battNote->setWordWrap(true);
+    battLayout->addWidget(battNote);
+
+    layout->addWidget(grpBatt);
+
+    // Interval Summary Overlay group
+    auto *grpSummary = new QGroupBox(tr("Interval Summary Overlay"), page);
+    auto *grpSummaryLayout = new QVBoxLayout(grpSummary);
+
+    checkIntervalSummary = new QCheckBox(tr("Show summary overlay on interval transition"), grpSummary);
+    grpSummaryLayout->addWidget(checkIntervalSummary);
+
+    auto *durRow = new QHBoxLayout();
+    durRow->addWidget(new QLabel(tr("Display duration (seconds):"), grpSummary));
+    spinIntervalSummaryDuration = new QSpinBox(grpSummary);
+    spinIntervalSummaryDuration->setRange(2, 15);
+    spinIntervalSummaryDuration->setValue(5);
+    durRow->addWidget(spinIntervalSummaryDuration);
+    durRow->addStretch();
+    grpSummaryLayout->addLayout(durRow);
+
+    layout->addWidget(grpSummary);
     layout->addStretch();
     return page;
 }
@@ -1346,6 +1443,16 @@ void DialogConfig::initTrainerTab()
 
     if (checkIntervalsIcuAutoUpload)
         checkIntervalsIcuAutoUpload->setChecked(account->intervals_icu_auto_upload);
+
+    if (checkDropoutEnabled) checkDropoutEnabled->setChecked(account->sensor_dropout_enabled);
+    if (spinDropoutTimeout)  spinDropoutTimeout->setValue(account->sensor_dropout_timeout_s);
+
+    if (spinBatteryThreshold) spinBatteryThreshold->setValue(account->battery_warning_threshold);
+
+    if (checkIntervalSummary) {
+        checkIntervalSummary->setChecked(account->interval_summary_enabled);
+        spinIntervalSummaryDuration->setValue(account->interval_summary_duration_s);
+    }
 }
 
 void DialogConfig::saveTrainerTab()
@@ -1361,4 +1468,19 @@ void DialogConfig::saveTrainerTab()
         account->intervals_icu_auto_upload = checkIntervalsIcuAutoUpload->isChecked();
         account->saveIntervalsIcuCredentials();
     }
+
+    if (checkDropoutEnabled) account->sensor_dropout_enabled  = checkDropoutEnabled->isChecked();
+    if (spinDropoutTimeout)  account->sensor_dropout_timeout_s = spinDropoutTimeout->value();
+    account->saveSensorDropoutSettings();
+
+    if (spinBatteryThreshold) {
+        account->battery_warning_threshold = spinBatteryThreshold->value();
+        account->saveBatteryWarningThreshold();
+    }
+
+    if (checkIntervalSummary) {
+        account->interval_summary_enabled    = checkIntervalSummary->isChecked();
+        account->interval_summary_duration_s = spinIntervalSummaryDuration->value();
+        account->saveIntervalSummarySettings();
+    }
 }
diff --git a/src/ui/dialogconfig.h b/src/ui/dialogconfig.h
index 561fb63c..fe2df569 100644
--- a/src/ui/dialogconfig.h
+++ b/src/ui/dialogconfig.h
@@ -207,6 +207,9 @@ private :
     QComboBox    *comboLanguage     = nullptr;
     QLabel       *labelRestartNote  = nullptr;
 
+    // Theme controls (Language tab)
+    QComboBox    *comboTheme        = nullptr;
+
     // Studio tab controls
     QCheckBox    *checkStudioMode   = nullptr;
     QSpinBox     *spinNbRiders      = nullptr;
@@ -216,6 +219,17 @@ private :
     QComboBox    *comboTrainerModel      = nullptr;
     QSpinBox     *spinErgSmoothing       = nullptr;
     QCheckBox    *checkIntervalsIcuAutoUpload = nullptr;
+
+    // Trainer tab — Sensor dropout (issue #148)
+    QCheckBox    *checkDropoutEnabled    = nullptr;
+    QSpinBox     *spinDropoutTimeout     = nullptr;
+
+    // Trainer tab — Battery warning threshold (issue #156)
+    QSpinBox     *spinBatteryThreshold   = nullptr;
+
+    // Interval Summary overlay controls
+    QCheckBox    *checkIntervalSummary         = nullptr;
+    QSpinBox     *spinIntervalSummaryDuration  = nullptr;
 };
 
 #endif // DIALOGCONFIG_H
diff --git a/src/ui/historywidget.cpp b/src/ui/historywidget.cpp
index 462be8fb..5446c7c8 100644
--- a/src/ui/historywidget.cpp
+++ b/src/ui/historywidget.cpp
@@ -1,6 +1,9 @@
 #include "historywidget.h"
 #include "workouthistorymodel.h"
 #include "fitactivityreader.h"
+#include "criticalpowerdialog.h"
+#include "pmccalculator.h"
+#include "pmcdialog.h"
 #include "util.h"
 
 #include <QTableView>
@@ -44,10 +47,19 @@ void HistoryWidget::setupUi()
     m_refreshBtn->setMaximumWidth(120);
     connect(m_refreshBtn, &QPushButton::clicked, this, &HistoryWidget::loadHistory);
 
+    m_cpBtn = new QPushButton(tr("Critical Power Curve"), this);
+    connect(m_cpBtn, &QPushButton::clicked, this, &HistoryWidget::openCriticalPowerDialog);
+
+    m_pmcBtn = new QPushButton(tr("Performance Chart"), this);
+    m_pmcBtn->setMaximumWidth(160);
+    connect(m_pmcBtn, &QPushButton::clicked, this, &HistoryWidget::openPmcDialog);
+
     m_statusLabel = new QLabel(this);
 
     auto *toolBar = new QHBoxLayout();
     toolBar->addWidget(m_refreshBtn);
+    toolBar->addWidget(m_cpBtn);
+    toolBar->addWidget(m_pmcBtn);
     toolBar->addWidget(m_statusLabel);
     toolBar->addStretch();
 
@@ -96,3 +108,24 @@ void HistoryWidget::loadHistory()
     else
         m_statusLabel->setText(tr("%n activity(ies)", "", summaries.size()));
 }
+
+void HistoryWidget::openCriticalPowerDialog()
+{
+    if (!m_loaded)
+        loadHistory();
+
+    const QList<WorkoutHistorySummary> &history = m_model->history();
+    CriticalPowerDialog dlg(history, this);
+    dlg.exec();
+}
+
+void HistoryWidget::openPmcDialog()
+{
+    if (!m_loaded)
+        loadHistory();
+
+    const QList<PmcPoint> points = PmcCalculator::compute(m_model->history());
+    auto *dlg = new PmcDialog(points, this);
+    dlg->setAttribute(Qt::WA_DeleteOnClose);
+    dlg->exec();
+}
diff --git a/src/ui/historywidget.h b/src/ui/historywidget.h
index 8b41b3f3..2d2e0a45 100644
--- a/src/ui/historywidget.h
+++ b/src/ui/historywidget.h
@@ -25,15 +25,21 @@ public slots:
 protected:
     void showEvent(QShowEvent *event) override;
 
+private slots:
+    void openCriticalPowerDialog();
+    void openPmcDialog();
+
 private:
     void setupUi();
 
-    QTableView           *m_tableView    = nullptr;
-    WorkoutHistoryModel  *m_model        = nullptr;
-    QSortFilterProxyModel*m_proxy        = nullptr;
-    QLabel               *m_statusLabel  = nullptr;
-    QPushButton          *m_refreshBtn   = nullptr;
-    bool                  m_loaded       = false;
+    QTableView           *m_tableView       = nullptr;
+    WorkoutHistoryModel  *m_model           = nullptr;
+    QSortFilterProxyModel*m_proxy           = nullptr;
+    QLabel               *m_statusLabel     = nullptr;
+    QPushButton          *m_refreshBtn      = nullptr;
+    QPushButton          *m_cpBtn           = nullptr;
+    QPushButton          *m_pmcBtn          = nullptr;
+    bool                  m_loaded          = false;
 };
 
 #endif // HISTORYWIDGET_H
diff --git a/src/ui/main_workoutpage.cpp b/src/ui/main_workoutpage.cpp
index af36428f..812a5b0d 100644
--- a/src/ui/main_workoutpage.cpp
+++ b/src/ui/main_workoutpage.cpp
@@ -104,12 +104,15 @@ Main_WorkoutPage::Main_WorkoutPage(QWidget *parent) : QWidget(parent), ui(new Ui
     contextMenu->addSeparator();
     actionOpenFolder = contextMenu->addAction(QIcon(":/image/icon/folder"), tr("Open in folder"));
     actionExportPDF = contextMenu->addAction(QIcon(":/image/icon/pdf"), tr("Export to PDF"));
+    contextMenu->addSeparator();
+    actionAddToQueue = contextMenu->addAction(QIcon(":/image/icon/add"), tr("Add to Queue"));
 
     connect(actionEdit, SIGNAL(triggered()), this, SLOT(editWorkout()) );
     connect(actionDelete, SIGNAL(triggered()), this, SLOT(deleteWorkout()) );
     connect(actionSetAsDone, SIGNAL(triggered()), this, SLOT(setAsDone()) );
     connect(actionOpenFolder, SIGNAL(triggered()), this, SLOT(openFolderWorkout()) );
     connect(actionExportPDF, SIGNAL(triggered()), this, SLOT(exportToPdf()) );
+    connect(actionAddToQueue, SIGNAL(triggered()), this, SLOT(addToQueue()));
     actionEdit->setEnabled(false);
     actionDelete->setEnabled(false);
     actionOpenFolder->setEnabled(false);
@@ -362,6 +365,14 @@ void Main_WorkoutPage::exportToPdf() {
 
 }
 
+//--------------------------------------------------------------------------------------
+void Main_WorkoutPage::addToQueue() {
+
+    Workout workout = tableModel->getWorkoutAtRow(indexSourceSelected);
+    emit addWorkoutToQueue(workout);
+
+}
+
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////
 void Main_WorkoutPage::editWorkout() {
diff --git a/src/ui/main_workoutpage.h b/src/ui/main_workoutpage.h
index 00f5c5ae..0dc282c8 100644
--- a/src/ui/main_workoutpage.h
+++ b/src/ui/main_workoutpage.h
@@ -42,6 +42,7 @@ signals :
     void editWorkout(Workout);
 
     void executeWorkout(Workout);
+    void addWorkoutToQueue(const Workout &workout);
 
 
 
@@ -78,6 +79,7 @@ private slots:
     void setAsDone();
     void openFolderWorkout();
     void exportToPdf();
+    void addToQueue();
     void addWorkout(const Workout&);
     void overwriteWorkout(const Workout&);
 
@@ -114,6 +116,7 @@ private slots:
     QAction *actionSetAsDone;
     QAction *actionOpenFolder;
     QAction *actionExportPDF;
+    QAction *actionAddToQueue;
     QModelIndex indexSourceSelected;
 };
 
diff --git a/src/ui/mainwindow.cpp b/src/ui/mainwindow.cpp
index 18ff16f3..21b45f2a 100644
--- a/src/ui/mainwindow.cpp
+++ b/src/ui/mainwindow.cpp
@@ -11,6 +11,8 @@
 #include <QFileDialog>
 #include <QTimer>
 #include <QDir>
+#include <QGuiApplication>
+#include <QStyleHints>
 
 #include "util.h"
 #include "logger.h"
@@ -38,6 +40,8 @@
 #include "updatedialog.h"
 #include "versiondao.h"
 #include "dialogkeyboardshortcuts.h"
+#include "workoutcountdowndialog.h"
+#include "apptheme.h"
 
 #include <QDir>
 #include <QMenu>
@@ -195,6 +199,12 @@ MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent), ui(new Ui::MainWi
     ui->tabWidget_workout->tabBar()->setObjectName("tabBarWorkout");
     setStyleSheet(qApp->styleSheet());
 
+#if QT_VERSION >= QT_VERSION_CHECK(6, 5, 0)
+    // Track OS colour-scheme changes for System theme mode.
+    connect(QGuiApplication::styleHints(), &QStyleHints::colorSchemeChanged, this,
+            &MainWindow::slotSystemThemeChanged);
+#endif
+
 
     //Load userStudio xml file to VecUserStudio
     XmlUtil *xmlUtil = new XmlUtil(settings->language, this);
@@ -315,6 +325,21 @@ MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent), ui(new Ui::MainWi
             this, [this](const QString &err) {
                 QMessageBox::warning(this, tr("Intervals.icu Sync Failed"), err);
             });
+
+    // ── Workout Queue (#152) ─────────────────────────────────────────────────
+    m_workoutQueue = new WorkoutQueue(this);
+    m_queuePanel   = new QueuePanelWidget(m_workoutQueue, this);
+
+    m_queueDock = new QDockWidget(tr("Workout Queue"), this);
+    m_queueDock->setObjectName(QStringLiteral("workoutQueueDock"));
+    m_queueDock->setAllowedAreas(Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea);
+    m_queueDock->setWidget(m_queuePanel);
+    m_queueDock->setMinimumWidth(220);
+    addDockWidget(Qt::RightDockWidgetArea, m_queueDock);
+    m_queueDock->hide();
+
+    connect(ui->tab_workout1, &Main_WorkoutPage::addWorkoutToQueue,
+            this, &MainWindow::addWorkoutToQueue);
 }
 
 
@@ -1580,6 +1605,29 @@ void MainWindow::on_actionHistory_triggered()
 }
 
 
+//------------------------------------------------------
+void MainWindow::on_actionToggleQueue_triggered()
+{
+    if (m_queueDock->isVisible())
+        m_queueDock->hide();
+    else
+        m_queueDock->show();
+}
+
+
+//------------------------------------------------------
+void MainWindow::addWorkoutToQueue(const Workout &workout)
+{
+    m_workoutQueue->addWorkout(workout.getFilePath(), workout.getName());
+    m_queueDock->show();
+    ui->widget_bottomMenu->setGeneralMessage(
+        tr("\"%1\" added to queue (%2 workout(s)).")
+            .arg(workout.getName())
+            .arg(m_workoutQueue->count()),
+        4000);
+}
+
+
 
 //------------------------------------------------------
 void MainWindow::on_actionCreate_New_triggered()
@@ -1650,6 +1698,20 @@ void MainWindow::executeWorkout(Workout workout) {
         simHub->stopDecodingMsg();
         delete simHub;
         ui->webView_achiev->reload();
+
+        // Auto-advance to next queued workout if one exists
+        if (!m_workoutQueue->isEmpty()) {
+            QString nextName = m_workoutQueue->name(0);
+            QString nextPath = m_workoutQueue->filePath(0);
+            WorkoutCountdownDialog countdown(nextName, 60, this);
+            if (countdown.exec() == QDialog::Accepted) {
+                m_workoutQueue->dequeueFilePath();
+                XmlUtil xmlNext(settings->language);
+                Workout next = xmlNext.parseSingleWorkoutXml(nextPath);
+                if (!next.getName().isEmpty())
+                    executeWorkout(next);
+            }
+        }
         return;
     }
 
@@ -1702,6 +1764,7 @@ void MainWindow::executeWorkout(Workout workout) {
     connect(btleHub, SIGNAL(signal_speed(int,double)),         &w, SLOT(TrainerSpeedDataReceived(int,double)));
     connect(btleHub, SIGNAL(signal_power(int,int)),            &w, SLOT(PowerDataReceived(int,int)));
     connect(btleHub, SIGNAL(signal_oxygen(int,double,double)), &w, SLOT(OxygenValueChanged(int,double,double)));
+    connect(btleHub, &BtleHub::signal_battery, &w, &WorkoutDialog::batteryStatusReceived);
 
     // Surface BLE disconnections mid-workout so WorkoutDialog can pause and
     // the user sees the DOM reconnect overlay (WASM) or a status message.
@@ -1733,6 +1796,20 @@ void MainWindow::executeWorkout(Workout workout) {
     delete btleHub;
 
     ui->webView_achiev->reload();
+
+    // Auto-advance to next queued workout if one exists
+    if (!m_workoutQueue->isEmpty()) {
+        QString nextName = m_workoutQueue->name(0);
+        QString nextPath = m_workoutQueue->filePath(0);
+        WorkoutCountdownDialog countdown(nextName, 60, this);
+        if (countdown.exec() == QDialog::Accepted) {
+            m_workoutQueue->dequeueFilePath();
+            XmlUtil xmlNext(settings->language);
+            Workout next = xmlNext.parseSingleWorkoutXml(nextPath);
+            if (!next.getName().isEmpty())
+                executeWorkout(next);
+        }
+    }
 }
 
 
@@ -1946,6 +2023,15 @@ void MainWindow::onNetworkOnlineChanged(bool isOnline)
 #endif
 }
 
+void MainWindow::slotSystemThemeChanged()
+{
+    auto *account = qApp->property("Account").value<Account*>();
+    if (!account) return;
+    // Only react when the user has chosen "System" mode.
+    if (account->app_theme == 2 /*System*/)
+        AppTheme::apply(qApp, AppTheme::System);
+}
+
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 void MainWindow::slotTrainingPeaksRefreshFinished()
diff --git a/src/ui/mainwindow.h b/src/ui/mainwindow.h
index 5b33f0c6..939a5b08 100644
--- a/src/ui/mainwindow.h
+++ b/src/ui/mainwindow.h
@@ -5,6 +5,7 @@
 #include <QTranslator>
 #include <QNetworkReply>
 #include <QThread>
+#include <QDockWidget>
 #ifndef GC_WASM_BUILD
 #if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
 #include <QtWebEngineCore/QWebEngineDownloadRequest>
@@ -32,6 +33,11 @@
 #endif
 
 
+#include "workoutqueue.h"
+#include "queuepanelwidget.h"
+
+class WorkoutCountdownDialog; // forward
+
 namespace Ui {
 class MainWindow;
 }
@@ -57,9 +63,6 @@ signals :
     void ftpAndTabProfileChanged();
 
 
-
-
-
 public slots:
 
     void executeWorkout(Workout workout);
@@ -128,6 +131,8 @@ private slots:
     void on_actionWorkout_triggered();
     void on_actionOpen_Course_Folder_triggered();
     void on_actionHistory_triggered();
+    void on_actionToggleQueue_triggered();
+    void addWorkoutToQueue(const Workout &workout);
 
 
     void on_actionCreate_New_triggered();
@@ -176,6 +181,8 @@ private slots:
     // Screenshot mode — captures a sequence of PNG files then quits the app.
     void screenshotNextStep();
 
+    void slotSystemThemeChanged();
+
 private:
     void loadSettings();
     void saveSettings();
@@ -255,6 +262,10 @@ private slots:
     WorkoutDialog *m_ssWorkoutDlg = nullptr;
     SimulatorHub  *m_ssSimHub     = nullptr;
 
+    // Workout queue (#152)
+    WorkoutQueue     *m_workoutQueue   = nullptr;
+    QueuePanelWidget *m_queuePanel     = nullptr;
+    QDockWidget      *m_queueDock      = nullptr;
 };
 
 #endif // MAINWINDOW_H
diff --git a/src/ui/plots/workoutplot.cpp b/src/ui/plots/workoutplot.cpp
index 5866fe55..c6ccae3d 100644
--- a/src/ui/plots/workoutplot.cpp
+++ b/src/ui/plots/workoutplot.cpp
@@ -572,6 +572,9 @@ void WorkoutPlot::setAlertMessage(bool fadeIn, bool fadeOut, QString text, int t
 
 }
 
+void WorkoutPlot::removeAlertMessage() {
+    labelAlertMessage->fadeOut(300);
+}
 
 
 
diff --git a/src/ui/plots/workoutplot.h b/src/ui/plots/workoutplot.h
index d1232852..f314c728 100644
--- a/src/ui/plots/workoutplot.h
+++ b/src/ui/plots/workoutplot.h
@@ -58,6 +58,7 @@ class WorkoutPlot : public QwtPlot
     void setMessage(QString msg);
     void setDisplayIntervalMessage(bool fadeIn, QString text, int timeToDisplay);
     void setAlertMessage(bool fadeIn, bool fadeOut, QString text, int timeToDisplay);
+    void removeAlertMessage();
     void removeMainMessage();
 
 
diff --git a/src/ui/pmcdialog.cpp b/src/ui/pmcdialog.cpp
new file mode 100644
index 00000000..ee2f3792
--- /dev/null
+++ b/src/ui/pmcdialog.cpp
@@ -0,0 +1,160 @@
+#include "pmcdialog.h"
+
+#include <QPen>
+#include <QColor>
+#include <QVBoxLayout>
+#include <QHBoxLayout>
+#include <QLabel>
+#include <QGroupBox>
+#include <QDialogButtonBox>
+#include <QDate>
+
+#include "qwt_plot.h"
+#include "qwt_plot_curve.h"
+#include "qwt_plot_marker.h"
+#include "qwt_plot_grid.h"
+#include "qwt_scale_draw.h"
+#include "qwt_text.h"
+
+// ── X-axis scale: Julian day → "dd MMM yy" ──────────────────────────────────
+
+class DateScaleDraw : public QwtScaleDraw
+{
+public:
+    QwtText label(double v) const override
+    {
+        const QDate d = QDate::fromJulianDay(static_cast<qint64>(v));
+        return d.toString(QStringLiteral("d MMM yy"));
+    }
+};
+
+// ── PmcDialog ────────────────────────────────────────────────────────────────
+
+PmcDialog::PmcDialog(const QList<PmcPoint> &points, QWidget *parent)
+    : QDialog(parent)
+{
+    setWindowTitle(tr("Performance Management Chart"));
+    setMinimumSize(800, 480);
+    setupUi(points);
+}
+
+void PmcDialog::setupUi(const QList<PmcPoint> &points)
+{
+    // ── plot ──────────────────────────────────────────────────────────────────
+    m_plot = new QwtPlot(this);
+    m_plot->setAxisTitle(QwtPlot::xBottom, tr("Date"));
+    m_plot->setAxisTitle(QwtPlot::yLeft,   tr("Load / Form"));
+    m_plot->setAxisScaleDraw(QwtPlot::xBottom, new DateScaleDraw());
+
+    // Show x-axis labels at reasonable intervals
+    m_plot->setAxisMaxMajor(QwtPlot::xBottom, 10);
+
+    auto *grid = new QwtPlotGrid();
+    grid->setMajorPen(QPen(Qt::gray, 0, Qt::DashLine));
+    grid->attach(m_plot);
+
+    buildCurves(points);
+
+    // ── info labels ───────────────────────────────────────────────────────────
+    m_ctlLabel = new QLabel(this);
+    m_atlLabel = new QLabel(this);
+    m_tsbLabel = new QLabel(this);
+
+    auto *infoBox = new QGroupBox(tr("Today"), this);
+    auto *infoLayout = new QHBoxLayout(infoBox);
+    infoLayout->addWidget(m_ctlLabel);
+    infoLayout->addWidget(m_atlLabel);
+    infoLayout->addWidget(m_tsbLabel);
+    infoLayout->addStretch();
+
+    buildInfoLabels(points);
+
+    // ── simple color legend ───────────────────────────────────────────────────
+    auto *legendLabel = new QLabel(
+        QStringLiteral("<font color='#4a90d9'>&#9644; CTL (Fitness)</font>&nbsp;&nbsp;"
+                       "<font color='#e05050'>&#9644; ATL (Fatigue)</font>&nbsp;&nbsp;"
+                       "<font color='#2ea055'>&#9146; TSB (Form)</font>"), this);
+    legendLabel->setAlignment(Qt::AlignCenter);
+
+    // ── close button ──────────────────────────────────────────────────────────
+    auto *buttons = new QDialogButtonBox(QDialogButtonBox::Close, this);
+    connect(buttons, &QDialogButtonBox::rejected, this, &QDialog::accept);
+
+    // ── layout ────────────────────────────────────────────────────────────────
+    auto *mainLayout = new QVBoxLayout(this);
+    mainLayout->addWidget(m_plot, 1);
+    mainLayout->addWidget(legendLabel);
+    mainLayout->addWidget(infoBox);
+    mainLayout->addWidget(buttons);
+}
+
+void PmcDialog::buildCurves(const QList<PmcPoint> &points)
+{
+    if (points.isEmpty())
+        return;
+
+    QVector<double> xs, ctls, atls, tsbs;
+    xs.reserve(points.size());
+    ctls.reserve(points.size());
+    atls.reserve(points.size());
+    tsbs.reserve(points.size());
+
+    for (const PmcPoint &p : points) {
+        const double x = static_cast<double>(p.date.toJulianDay());
+        xs   << x;
+        ctls << p.ctl;
+        atls << p.atl;
+        tsbs << p.tsb;
+    }
+
+    // CTL — blue
+    m_ctlCurve = new QwtPlotCurve(tr("CTL (Fitness)"));
+    m_ctlCurve->setSamples(xs, ctls);
+    m_ctlCurve->setPen(QPen(QColor(0x4A, 0x90, 0xD9), 2));
+    m_ctlCurve->setRenderHint(QwtPlotItem::RenderAntialiased);
+    m_ctlCurve->attach(m_plot);
+
+    // ATL — red
+    m_atlCurve = new QwtPlotCurve(tr("ATL (Fatigue)"));
+    m_atlCurve->setSamples(xs, atls);
+    m_atlCurve->setPen(QPen(QColor(0xE0, 0x50, 0x50), 2));
+    m_atlCurve->setRenderHint(QwtPlotItem::RenderAntialiased);
+    m_atlCurve->attach(m_plot);
+
+    // TSB — green, dashed
+    m_tsbCurve = new QwtPlotCurve(tr("TSB (Form)"));
+    m_tsbCurve->setSamples(xs, tsbs);
+    QPen tsbPen(QColor(0x2E, 0xA0, 0x55), 1.5, Qt::DashLine);
+    m_tsbCurve->setPen(tsbPen);
+    m_tsbCurve->setRenderHint(QwtPlotItem::RenderAntialiased);
+    m_tsbCurve->attach(m_plot);
+
+    // Zero reference line for TSB
+    m_zeroLine = new QwtPlotMarker();
+    m_zeroLine->setLineStyle(QwtPlotMarker::HLine);
+    m_zeroLine->setYValue(0.0);
+    m_zeroLine->setLinePen(QPen(Qt::darkGray, 0, Qt::SolidLine));
+    m_zeroLine->attach(m_plot);
+
+    m_plot->replot();
+}
+
+void PmcDialog::buildInfoLabels(const QList<PmcPoint> &points)
+{
+    if (points.isEmpty()) {
+        m_ctlLabel->setText(tr("CTL: —"));
+        m_atlLabel->setText(tr("ATL: —"));
+        m_tsbLabel->setText(tr("TSB: —"));
+        return;
+    }
+
+    const PmcPoint &last = points.last();
+    m_ctlLabel->setText(tr("CTL: <b>%1</b>").arg(last.ctl, 0, 'f', 1));
+    m_atlLabel->setText(tr("ATL: <b>%1</b>").arg(last.atl, 0, 'f', 1));
+
+    const QString tsbColor = last.tsb >= 0 ? QStringLiteral("#2ea055") : QStringLiteral("#e05050");
+    m_tsbLabel->setText(
+        tr("TSB: <b><span style='color:%1'>%2</span></b>")
+            .arg(tsbColor)
+            .arg(last.tsb, 0, 'f', 1));
+}
diff --git a/src/ui/pmcdialog.h b/src/ui/pmcdialog.h
new file mode 100644
index 00000000..1804d7c9
--- /dev/null
+++ b/src/ui/pmcdialog.h
@@ -0,0 +1,42 @@
+#ifndef PMCDIALOG_H
+#define PMCDIALOG_H
+
+#include <QDialog>
+#include <QList>
+
+#include "pmccalculator.h"
+
+class QwtPlot;
+class QwtPlotCurve;
+class QwtPlotMarker;
+class QLabel;
+
+/// Performance Management Chart dialog.
+///
+/// Displays Chronic Training Load (CTL / fitness), Acute Training Load
+/// (ATL / fatigue) and Training Stress Balance (TSB / form) over time,
+/// computed from the user's workout history.
+class PmcDialog : public QDialog
+{
+    Q_OBJECT
+
+public:
+    explicit PmcDialog(const QList<PmcPoint> &points, QWidget *parent = nullptr);
+
+private:
+    void setupUi(const QList<PmcPoint> &points);
+    void buildCurves(const QList<PmcPoint> &points);
+    void buildInfoLabels(const QList<PmcPoint> &points);
+
+    QwtPlot       *m_plot    = nullptr;
+    QwtPlotCurve  *m_ctlCurve = nullptr;
+    QwtPlotCurve  *m_atlCurve = nullptr;
+    QwtPlotCurve  *m_tsbCurve = nullptr;
+    QwtPlotMarker *m_zeroLine = nullptr;
+
+    QLabel *m_ctlLabel = nullptr;
+    QLabel *m_atlLabel = nullptr;
+    QLabel *m_tsbLabel = nullptr;
+};
+
+#endif // PMCDIALOG_H
diff --git a/src/ui/queuepanelwidget.cpp b/src/ui/queuepanelwidget.cpp
new file mode 100644
index 00000000..e333c177
--- /dev/null
+++ b/src/ui/queuepanelwidget.cpp
@@ -0,0 +1,101 @@
+#include "queuepanelwidget.h"
+
+#include <QVBoxLayout>
+#include <QHBoxLayout>
+
+QueuePanelWidget::QueuePanelWidget(WorkoutQueue *queue, QWidget *parent)
+    : QWidget(parent)
+    , m_queue(queue)
+{
+    setWindowTitle(tr("Workout Queue"));
+
+    auto *layout = new QVBoxLayout(this);
+    layout->setContentsMargins(6, 6, 6, 6);
+    layout->setSpacing(4);
+
+    auto *titleLbl = new QLabel(tr("<b>Workout Queue</b>"), this);
+    layout->addWidget(titleLbl);
+
+    m_list = new QListWidget(this);
+    m_list->setDragDropMode(QAbstractItemView::InternalMove);
+    layout->addWidget(m_list, 1);
+
+    // Button row
+    auto *btnRow = new QHBoxLayout();
+    m_upBtn   = new QPushButton(tr("▲"), this);
+    m_downBtn = new QPushButton(tr("▼"), this);
+    m_removeBtn = new QPushButton(tr("Remove"), this);
+    m_clearBtn  = new QPushButton(tr("Clear"), this);
+    m_upBtn->setMaximumWidth(32);
+    m_downBtn->setMaximumWidth(32);
+    m_upBtn->setToolTip(tr("Move selected workout up"));
+    m_downBtn->setToolTip(tr("Move selected workout down"));
+    m_removeBtn->setToolTip(tr("Remove selected workout from queue"));
+    m_clearBtn->setToolTip(tr("Clear entire queue"));
+    btnRow->addWidget(m_upBtn);
+    btnRow->addWidget(m_downBtn);
+    btnRow->addWidget(m_removeBtn);
+    btnRow->addStretch();
+    btnRow->addWidget(m_clearBtn);
+    layout->addLayout(btnRow);
+
+    m_statusLbl = new QLabel(this);
+    m_statusLbl->setStyleSheet("color: #888; font-style: italic;");
+    layout->addWidget(m_statusLbl);
+
+    connect(m_removeBtn, &QPushButton::clicked, this, &QueuePanelWidget::onRemove);
+    connect(m_upBtn,     &QPushButton::clicked, this, &QueuePanelWidget::onMoveUp);
+    connect(m_downBtn,   &QPushButton::clicked, this, &QueuePanelWidget::onMoveDown);
+    connect(m_clearBtn,  &QPushButton::clicked, this, &QueuePanelWidget::onClear);
+
+    connect(m_queue, &WorkoutQueue::queueChanged, this, &QueuePanelWidget::refresh);
+    refresh();
+}
+
+void QueuePanelWidget::refresh()
+{
+    m_list->clear();
+    for (int i = 0; i < m_queue->count(); ++i)
+        m_list->addItem(QString("%1. %2").arg(i + 1).arg(m_queue->name(i)));
+
+    const bool hasItems = !m_queue->isEmpty();
+    m_removeBtn->setEnabled(hasItems);
+    m_upBtn->setEnabled(hasItems);
+    m_downBtn->setEnabled(hasItems);
+    m_clearBtn->setEnabled(hasItems);
+
+    if (m_queue->isEmpty()) {
+        m_statusLbl->setText(tr("Queue is empty."));
+    } else {
+        m_statusLbl->setText(tr("%1 workout(s) queued").arg(m_queue->count()));
+    }
+}
+
+void QueuePanelWidget::onRemove()
+{
+    int row = m_list->currentRow();
+    if (row >= 0) m_queue->removeAt(row);
+}
+
+void QueuePanelWidget::onMoveUp()
+{
+    int row = m_list->currentRow();
+    if (row > 0) {
+        m_queue->moveUp(row);
+        m_list->setCurrentRow(row - 1);
+    }
+}
+
+void QueuePanelWidget::onMoveDown()
+{
+    int row = m_list->currentRow();
+    if (row >= 0 && row < m_queue->count() - 1) {
+        m_queue->moveDown(row);
+        m_list->setCurrentRow(row + 1);
+    }
+}
+
+void QueuePanelWidget::onClear()
+{
+    m_queue->clear();
+}
diff --git a/src/ui/queuepanelwidget.h b/src/ui/queuepanelwidget.h
new file mode 100644
index 00000000..b38b2ad1
--- /dev/null
+++ b/src/ui/queuepanelwidget.h
@@ -0,0 +1,36 @@
+#ifndef QUEUEPANELWIDGET_H
+#define QUEUEPANELWIDGET_H
+
+#include <QWidget>
+#include <QListWidget>
+#include <QLabel>
+#include <QPushButton>
+
+#include "workoutqueue.h"
+
+/// Sidebar panel showing the current workout queue.
+/// Supports removing entries and reordering via Move Up / Move Down.
+class QueuePanelWidget : public QWidget
+{
+    Q_OBJECT
+public:
+    explicit QueuePanelWidget(WorkoutQueue *queue, QWidget *parent = nullptr);
+
+private slots:
+    void refresh();
+    void onRemove();
+    void onMoveUp();
+    void onMoveDown();
+    void onClear();
+
+private:
+    WorkoutQueue  *m_queue      = nullptr;
+    QListWidget   *m_list       = nullptr;
+    QLabel        *m_statusLbl  = nullptr;
+    QPushButton   *m_removeBtn  = nullptr;
+    QPushButton   *m_upBtn      = nullptr;
+    QPushButton   *m_downBtn    = nullptr;
+    QPushButton   *m_clearBtn   = nullptr;
+};
+
+#endif // QUEUEPANELWIDGET_H
diff --git a/src/ui/ui.pri b/src/ui/ui.pri
index 75b92b5c..741d51c3 100644
--- a/src/ui/ui.pri
+++ b/src/ui/ui.pri
@@ -21,6 +21,10 @@ $$PWD/workoutdialog.cpp \
     $$PWD/workouthistorymodel.cpp \
     $$PWD/historywidget.cpp \
     $$PWD/dialogkeyboardshortcuts.cpp \
+    $$PWD/criticalpowerdialog.cpp \
+    $$PWD/pmcdialog.cpp \
+    $$PWD/workoutcountdowndialog.cpp \
+    $$PWD/queuepanelwidget.cpp \
     #$$PWD/main_coursepage.cpp
 
 HEADERS += $$PWD/mainwindow.h\
@@ -39,6 +43,11 @@ $$PWD/workoutdialog.h \
     $$PWD/workouthistorymodel.h \
     $$PWD/historywidget.h \
     $$PWD/dialogkeyboardshortcuts.h \
+    $$PWD/criticalpowerdialog.h \
+    $$PWD/pmcdialog.h \
+    $$PWD/workoutcountdowndialog.h \
+    $$PWD/queuepanelwidget.h \
+    $$PWD/apptheme.h \
     #$$PWD/main_coursepage.h
 
 FORMS    += $$PWD/mainwindow.ui \
diff --git a/src/ui/workoutcountdowndialog.cpp b/src/ui/workoutcountdowndialog.cpp
new file mode 100644
index 00000000..a2261e0d
--- /dev/null
+++ b/src/ui/workoutcountdowndialog.cpp
@@ -0,0 +1,78 @@
+#include "workoutcountdowndialog.h"
+
+#include <QVBoxLayout>
+#include <QHBoxLayout>
+
+WorkoutCountdownDialog::WorkoutCountdownDialog(const QString &nextWorkoutName,
+                                               int countdownSeconds,
+                                               QWidget *parent)
+    : QDialog(parent)
+    , m_remaining(countdownSeconds)
+    , m_workoutName(nextWorkoutName)
+{
+    setWindowTitle(tr("Next Workout"));
+    setWindowFlags(windowFlags() & ~Qt::WindowContextHelpButtonHint);
+    setMinimumWidth(380);
+
+    auto *layout = new QVBoxLayout(this);
+    layout->setSpacing(16);
+    layout->setContentsMargins(20, 20, 20, 20);
+
+    m_label = new QLabel(this);
+    m_label->setAlignment(Qt::AlignCenter);
+    m_label->setWordWrap(true);
+    QFont f = m_label->font();
+    f.setPointSize(f.pointSize() + 2);
+    m_label->setFont(f);
+    layout->addWidget(m_label);
+
+    auto *btnRow = new QHBoxLayout();
+    m_startBtn  = new QPushButton(tr("Start Now"), this);
+    m_cancelBtn = new QPushButton(tr("Cancel Queue"), this);
+    m_startBtn->setDefault(true);
+    btnRow->addStretch();
+    btnRow->addWidget(m_startBtn);
+    btnRow->addWidget(m_cancelBtn);
+    layout->addLayout(btnRow);
+
+    connect(m_startBtn,  &QPushButton::clicked, this, &WorkoutCountdownDialog::onStartNow);
+    connect(m_cancelBtn, &QPushButton::clicked, this, &WorkoutCountdownDialog::onCancel);
+
+    m_timer = new QTimer(this);
+    m_timer->setInterval(1000);
+    connect(m_timer, &QTimer::timeout, this, &WorkoutCountdownDialog::tick);
+    m_timer->start();
+
+    updateLabel();
+}
+
+void WorkoutCountdownDialog::updateLabel()
+{
+    m_label->setText(tr("Next workout:\n<b>%1</b>\n\nStarting in <b>%2</b> second(s)…")
+                     .arg(m_workoutName)
+                     .arg(m_remaining));
+}
+
+void WorkoutCountdownDialog::tick()
+{
+    --m_remaining;
+    if (m_remaining <= 0) {
+        onStartNow();
+        return;
+    }
+    updateLabel();
+}
+
+void WorkoutCountdownDialog::onStartNow()
+{
+    m_result = Result::StartNow;
+    m_timer->stop();
+    accept();
+}
+
+void WorkoutCountdownDialog::onCancel()
+{
+    m_result = Result::Cancelled;
+    m_timer->stop();
+    reject();
+}
diff --git a/src/ui/workoutcountdowndialog.h b/src/ui/workoutcountdowndialog.h
new file mode 100644
index 00000000..dbdfd131
--- /dev/null
+++ b/src/ui/workoutcountdowndialog.h
@@ -0,0 +1,41 @@
+#ifndef WORKOUTCOUNTDOWNDIALOG_H
+#define WORKOUTCOUNTDOWNDIALOG_H
+
+#include <QDialog>
+#include <QLabel>
+#include <QPushButton>
+#include <QTimer>
+
+/// Displays a countdown before auto-advancing to the next queued workout.
+/// The user can start immediately ("Start Now") or cancel the remaining queue.
+class WorkoutCountdownDialog : public QDialog
+{
+    Q_OBJECT
+public:
+    enum class Result { StartNow, Cancelled };
+
+    explicit WorkoutCountdownDialog(const QString &nextWorkoutName,
+                                    int countdownSeconds = 60,
+                                    QWidget *parent = nullptr);
+
+    Result dialogResult() const { return m_result; }
+
+private slots:
+    void tick();
+    void onStartNow();
+    void onCancel();
+
+private:
+    QLabel      *m_label     = nullptr;
+    QPushButton *m_startBtn  = nullptr;
+    QPushButton *m_cancelBtn = nullptr;
+    QTimer      *m_timer     = nullptr;
+
+    int     m_remaining;
+    QString m_workoutName;
+    Result  m_result = Result::Cancelled;
+
+    void updateLabel();
+};
+
+#endif // WORKOUTCOUNTDOWNDIALOG_H
diff --git a/src/ui/workoutdialog.cpp b/src/ui/workoutdialog.cpp
index 7a4f03e9..09edd193 100644
--- a/src/ui/workoutdialog.cpp
+++ b/src/ui/workoutdialog.cpp
@@ -18,6 +18,7 @@
 #include <QLabel>
 #include <QFileDialog>
 #include <QFileInfo>
+#include <QDateTime>
 
 #include "interval.h"
 #include "workout.h"
@@ -42,6 +43,7 @@
 #include "selfloops_service.h"
 #include "intervalsicuservice.h"
 #include "extrequest.h"
+#include "intervalsummaryutil.h"
 
 
 
@@ -204,6 +206,12 @@ WorkoutDialog::WorkoutDialog(Workout workout,  QList<Radio> lstRadio, QVector<Us
     timerIgnoreClickPlot->start(1000);
     connect(timerIgnoreClickPlot, SIGNAL(timeout()), this, SLOT(ignoreClickPlot()) );
 
+    // Sensor dropout watchdog — fires every second while WorkoutDialog is open.
+    m_dropoutWatchdog = new QTimer(this);
+    m_dropoutWatchdog->setInterval(1000);
+    connect(m_dropoutWatchdog, &QTimer::timeout, this, &WorkoutDialog::checkSensorDropout);
+    m_dropoutWatchdog->start();
+
 
     /// Sounds timer
     timerCheckToActivateSound = new QTimer(this);
@@ -753,19 +761,26 @@ void WorkoutDialog::startCalibrationPM() {
 
 
 //------------------------------------------------------------------------------------------------------------
-void WorkoutDialog::batteryStatusReceived(QString sensorType, int level, int antID) {
+void WorkoutDialog::batteryStatusReceived(QString sensorType, int percentage) {
 
-    qDebug() << "batteryStatusReceived" << sensorType << "level:" << level;
+    qDebug() << "batteryStatusReceived" << sensorType << "level:" << percentage << "%";
 
-    labelBatteryStatus->setVisible(true);
+    // Check against configurable threshold
+    if (percentage > account->battery_warning_threshold)
+        return;
 
-    QString levelStr;
-    if (level == 0)
-        levelStr = tr("critical");
-    else  //1
-        levelStr = tr("low");
+    // Suppress re-warning unless level dropped ≥ 5% below the last warned level
+    if (m_warnedBatteryLevels.contains(sensorType)) {
+        int lastWarned = m_warnedBatteryLevels.value(sensorType);
+        if (percentage > lastWarned - 5)
+            return;
+    }
 
-    labelBatteryStatus->setText(tr("Battery Warning: ") + sensorType  + "(ID: " + QString::number(antID) + tr(") Battery is ") + levelStr);
+    m_warnedBatteryLevels[sensorType] = percentage;
+
+    labelBatteryStatus->setVisible(true);
+    labelBatteryStatus->setText(
+        tr("%1 sensor battery: %2%").arg(sensorType).arg(percentage));
     labelBatteryStatus->fadeInAndFadeOutAfterPause(400, 1000, 15000);
 }
 
@@ -1614,6 +1629,62 @@ void WorkoutDialog::onBleConnectionError(const QString &errorString)
     }
 }
 
+///////////////////////////////////////////////////////////////////////////////////////////////////////
+void WorkoutDialog::checkSensorDropout()
+{
+    if (!account->sensor_dropout_enabled) return;
+    if (account->enable_studio_mode) return;
+    if (!isWorkoutStarted || isWorkoutOver) return;
+
+    const qint64 now = QDateTime::currentMSecsSinceEpoch();
+    const qint64 timeout_ms = (qint64)account->sensor_dropout_timeout_s * 1000;
+
+    // Only check a sensor if we've ever received data from it (m_last*Ms > 0)
+    const bool powerLost = (m_lastPowerMs > 0) && (now - m_lastPowerMs) > timeout_ms;
+    const bool signalLost = powerLost;   // future: add HR option here
+
+    if (!m_dropoutPaused) {
+        if (!isWorkoutPaused && signalLost) {
+            m_dropoutPaused = true;
+            m_recoveryCountdown = 0;
+            LOG_INFO("WorkoutDialog", "Sensor dropout detected — auto-pausing workout");
+            start_or_pause_workout();  // pause
+            ui->widget_workoutPlot->setAlertMessage(false, false,
+                tr("Sensor signal lost — workout paused"), 0);
+        }
+        return;
+    }
+
+    // We are in dropout-pause state: check for recovery
+    if (signalLost) {
+        // Signal still absent (or dropped again during countdown)
+        if (m_recoveryCountdown > 0) {
+            m_recoveryCountdown = 0;
+            ui->widget_workoutPlot->setAlertMessage(false, false,
+                tr("Sensor signal lost — workout paused"), 0);
+        }
+    } else {
+        // Signal has returned
+        if (m_recoveryCountdown == 0) {
+            m_recoveryCountdown = 3;
+            ui->widget_workoutPlot->setAlertMessage(false, false,
+                tr("Signal recovered — resuming in 3…"), 0);
+        } else {
+            m_recoveryCountdown--;
+            if (m_recoveryCountdown == 0) {
+                m_dropoutPaused = false;
+                LOG_INFO("WorkoutDialog", "Sensor recovered — auto-resuming workout");
+                ui->widget_workoutPlot->removeAlertMessage();
+                if (isWorkoutPaused)
+                    start_or_pause_workout();  // resume
+            } else {
+                ui->widget_workoutPlot->setAlertMessage(false, false,
+                    tr("Signal recovered — resuming in %1…").arg(m_recoveryCountdown), 0);
+            }
+        }
+    }
+}
+
 void WorkoutDialog::start_or_pause_workout() {
 
 
@@ -1649,6 +1720,14 @@ void WorkoutDialog::start_or_pause_workout() {
         ui->widget_workoutPlot->removeMainMessage();
         isWorkoutPaused = false;
 
+        // Clear dropout state if user manually resumes
+        if (m_dropoutPaused) {
+            m_dropoutPaused = false;
+            m_recoveryCountdown = 0;
+            m_lastPowerMs = QDateTime::currentMSecsSinceEpoch(); // reset to avoid immediate re-trigger
+            ui->widget_workoutPlot->removeAlertMessage();
+        }
+
         setWidgetsStopped(false);
         emit resumeClock();
         emit playPlayer();
@@ -1715,6 +1794,10 @@ void WorkoutDialog::HrDataReceived(int userID, int value) {
     if (value < 0)
         return;
 
+    // Track for sensor dropout detection
+    if (!account->enable_studio_mode && isWorkoutStarted && !isWorkoutOver)
+        m_lastHrMs = QDateTime::currentMSecsSinceEpoch();
+
 
     // Mark pairing as done
     if (!account->enable_studio_mode && !hrPairingDone) {
@@ -1989,6 +2072,10 @@ void WorkoutDialog::PowerDataReceived(int userID, int value) {
     if (value < 0)
         return;
 
+    // Track for sensor dropout detection (non-studio, user 1 only)
+    if (!account->enable_studio_mode && isWorkoutStarted && !isWorkoutOver)
+        m_lastPowerMs = QDateTime::currentMSecsSinceEpoch();
+
     // Send power To Clock
     emit sendPowerData(userID, value);
 
@@ -3744,6 +3831,20 @@ void WorkoutDialog::changeIntervalsDataWorkout(double timeStarted, double timeNo
 
     qDebug () << "changeIntervalsDataWorkout! - timeStarted" << timeStarted << "timeNow" << timeNow << "timePaused_msec" << timePaused_msec << "workoutOver" << workoutOver << "testInterval" << testInterval;
 
+    // Capture interval summary stats BEFORE changeInterval() resets them.
+    double summaryAvgPower = 0.0, summaryAvgHr = 0.0, summaryAvgCad = 0.0;
+    double intervalDuration = timeNow - timeStarted;
+    double targetPowerFraction = currentIntervalObj.getFTP_start();
+    bool showSummary = !account->enable_studio_mode
+                       && !workoutOver
+                       && account->interval_summary_enabled
+                       && intervalDuration >= 10.0;
+    if (showSummary) {
+        summaryAvgPower = arrDataWorkout[0]->getAvgIntervalPower();
+        summaryAvgHr    = arrDataWorkout[0]->getAvgIntervalHr();
+        summaryAvgCad   = arrDataWorkout[0]->getAvgIntervalCad();
+    }
+
     if (account->enable_studio_mode) {
         for (int i=0; i<account->nb_user_studio; i++) {
             //            qDebug() << "change interval for this user" << i;
@@ -3755,6 +3856,10 @@ void WorkoutDialog::changeIntervalsDataWorkout(double timeStarted, double timeNo
         arrDataWorkout[0]->changeInterval(timeStarted, timeNow, timePaused_msec, workoutOver, testInterval);
     }
 
+    if (showSummary)
+        showIntervalSummaryOverlay(summaryAvgPower, summaryAvgHr, summaryAvgCad,
+                                   static_cast<int>(intervalDuration), targetPowerFraction);
+
     lastIntervalEndTime_msec = timeElapsed_sec;
     lastIntervalTotalTimePausedWorkout_msec = totalTimePausedWorkout_msec;
 }
@@ -3775,6 +3880,51 @@ void WorkoutDialog::initDataWorkout() {
 }
 
 
+/////////////////////////////////////////////////////////////////////////////////////////////////////
+void WorkoutDialog::showIntervalSummaryOverlay(double avgPower, double avgHr, double avgCad,
+                                               int durationSec, double targetPowerFraction)
+{
+    const double targetWatts = targetPowerFraction * account->FTP;
+    const auto adherence = IntervalSummaryUtil::classifyPowerAdherence(avgPower, targetWatts);
+
+    QString colorHex;
+    switch (adherence) {
+    case IntervalSummaryUtil::PowerAdherence::Met:      colorHex = "#4CAF50"; break; // green
+    case IntervalSummaryUtil::PowerAdherence::NearMiss: colorHex = "#FF9800"; break; // amber
+    default:                                            colorHex = "#F44336"; break; // red
+    }
+
+    const int mins = durationSec / 60;
+    const int secs = durationSec % 60;
+    const QString duration = (mins > 0)
+        ? QString("%1:%2").arg(mins).arg(secs, 2, 10, QChar('0'))
+        : QString("%1s").arg(secs);
+
+    const int powerPct = (account->FTP > 0)
+        ? qRound(avgPower * 100.0 / account->FTP)
+        : 0;
+
+    // Build HTML summary shown in the existing interval-message overlay
+    QString html = QString(
+        "<div style='text-align:center; line-height:1.5;'>"
+        "<b>%1</b><br>"
+        "<span style='color:%2;font-size:1.2em;'>&#9679; %3 W (%4%% FTP)</span><br>"
+        "<span>HR: %5 bpm &nbsp;&nbsp; Cad: %6 rpm</span><br>"
+        "<span style='color:#aaa;font-size:0.85em;'>%7</span>"
+        "</div>")
+        .arg(tr("Interval Complete"))
+        .arg(colorHex)
+        .arg(qRound(avgPower))
+        .arg(powerPct)
+        .arg(qRound(avgHr))
+        .arg(qRound(avgCad))
+        .arg(duration);
+
+    ui->widget_workoutPlot->setDisplayIntervalMessage(
+        true, html, account->interval_summary_duration_s);
+}
+
+
 
 
 
diff --git a/src/ui/workoutdialog.h b/src/ui/workoutdialog.h
index 395bb379..f92ae35b 100644
--- a/src/ui/workoutdialog.h
+++ b/src/ui/workoutdialog.h
@@ -4,6 +4,7 @@
 #include <QDialog>
 #include <QTime>
 #include <QTimer>
+#include <QHash>
 #include <QKeyEvent>
 #include <QNetworkReply>
 
@@ -148,7 +149,7 @@ public slots:
     void lapButtonPressed();
 
 
-    void batteryStatusReceived(QString sensorType, int level, int antID);
+    void batteryStatusReceived(QString sensorType, int percentage);
 
     void startCalibrateFEC();
     void startCalibrationPM();
@@ -169,6 +170,8 @@ public slots:
     // already shows the Reconnect button; this slot logs and pauses the workout.
     void onBleConnectionError(const QString &errorString);
 
+    void checkSensorDropout();   ///< 1-Hz watchdog for sensor dropout auto-pause
+
     void ignoreClickPlot();
 
     void activateSoundBool();
@@ -233,6 +236,8 @@ private slots:
     void initDataWorkout();
     void connectDataWorkout();
     void createUserStudioWidget();
+    void showIntervalSummaryOverlay(double avgPower, double avgHr, double avgCad,
+                                    int durationSec, double targetPowerFraction);
 
     void sendUserInfoToClock();
 
@@ -508,6 +513,18 @@ private slots:
 
     int currentWorkoutDifficultyPercentage; //0 = Normal
 
+    ///------ Sensor dropout auto-pause ----------------------
+    qint64 m_lastPowerMs       = 0;  ///< Timestamp (ms) of last valid power reading
+    qint64 m_lastHrMs          = 0;  ///< Timestamp (ms) of last valid HR reading
+    bool   m_dropoutPaused     = false; ///< True when workout is paused due to dropout
+    int    m_recoveryCountdown = 0;  ///< Countdown (s) before auto-resume after recovery
+    QTimer *m_dropoutWatchdog  = nullptr;
+    ///-------------------------------------------------------
+
+    /// Battery warning tracking (issue #156): sensorType → last warned percentage.
+    /// A warning is suppressed for a sensor unless the level drops ≥ 5 % below
+    /// the level at which the last warning was shown.
+    QHash<QString, int> m_warnedBatteryLevels;
 
     WorkoutPlot *mainPlot;
     friend class DialogConfig;
diff --git a/src/ui/workouthistorymodel.h b/src/ui/workouthistorymodel.h
index 99d10b23..a3265641 100644
--- a/src/ui/workouthistorymodel.h
+++ b/src/ui/workouthistorymodel.h
@@ -28,6 +28,7 @@ class WorkoutHistoryModel : public QAbstractTableModel
     explicit WorkoutHistoryModel(QObject *parent = nullptr);
 
     void setHistory(const QList<WorkoutHistorySummary> &history);
+    const QList<WorkoutHistorySummary> &history() const { return m_history; }
 
     int rowCount(const QModelIndex &parent = QModelIndex()) const override;
     int columnCount(const QModelIndex &parent = QModelIndex()) const override;
diff --git a/tests/btle/tst_btle_hub.cpp b/tests/btle/tst_btle_hub.cpp
index de83b8e1..09e60266 100644
--- a/tests/btle/tst_btle_hub.cpp
+++ b/tests/btle/tst_btle_hub.cpp
@@ -23,6 +23,7 @@
 
 #include "../../src/btle/btle_hub.h"
 #include "../../src/btle/simulator_hub.h"
+#include "../../src/model/intervalsummaryutil.h"
 #include "btle_device_simulator.h"
 
 // ─────────────────────────────────────────────────────────────────────────────
@@ -95,6 +96,23 @@ private slots:
     void testSimulator_noOpSetLoad();
     void testSimulator_noOpSetSlope();
 
+    // ── Battery Level parsing ─────────────────────────────────────────────────
+    void testBattery_aboveThreshold_noSignal();
+    void testBattery_atThreshold_emits();
+    void testBattery_belowThreshold_emits();
+    void testBattery_tooShort_ignored();
+    void testBattery_clamped();
+
+    // ── Interval summary power-adherence classification ───────────────────────
+    void testIntervalSummary_met_exactTarget();
+    void testIntervalSummary_met_upperBoundary();
+    void testIntervalSummary_met_lowerBoundary();
+    void testIntervalSummary_nearMiss_upperBoundary();
+    void testIntervalSummary_nearMiss_lowerBoundary();
+    void testIntervalSummary_missed_above();
+    void testIntervalSummary_missed_below();
+    void testIntervalSummary_zeroTarget_returnsMet();
+
 private:
     BtleHub *hub = nullptr;
 };
@@ -792,6 +810,107 @@ void TstBtleHub::testSimulator_noOpSetSlope()
     QCOMPARE(spySpd.count(), 0);
 }
 
+// ─────────────────────────────────────────────────────────────────────────────
+// Battery Level parsing tests (issue #156)
+// ─────────────────────────────────────────────────────────────────────────────
+
+/// Empty payload — must be silently ignored, no signal emitted.
+void TstBtleHub::testBattery_tooShort_ignored()
+{
+    QSignalSpy spy(hub, &BtleHub::signal_battery);
+    hub->simulateNotification(BTLE_UUID_BATTERY_LEVEL, QByteArray());
+    QCOMPARE(spy.count(), 0);
+}
+
+/// Nominal battery level (85%) — signal emitted with correct percentage.
+void TstBtleHub::testBattery_belowThreshold_emits()
+{
+    QSignalSpy spy(hub, &BtleHub::signal_battery);
+    hub->simulateNotification(BTLE_UUID_BATTERY_LEVEL, QByteArray(1, char(15)));
+    QCOMPARE(spy.count(), 1);
+    QCOMPARE(spy.at(0).at(1).toInt(), 15);
+}
+
+/// At the threshold boundary (exactly threshold value) — signal emitted.
+void TstBtleHub::testBattery_atThreshold_emits()
+{
+    QSignalSpy spy(hub, &BtleHub::signal_battery);
+    hub->simulateNotification(BTLE_UUID_BATTERY_LEVEL, QByteArray(1, char(20)));
+    QCOMPARE(spy.count(), 1);
+    QCOMPARE(spy.at(0).at(1).toInt(), 20);
+}
+
+/// Above threshold (75%) — signal still emitted (threshold filtering is in WorkoutDialog).
+void TstBtleHub::testBattery_aboveThreshold_noSignal()
+{
+    QSignalSpy spy(hub, &BtleHub::signal_battery);
+    hub->simulateNotification(BTLE_UUID_BATTERY_LEVEL, QByteArray(1, char(75)));
+    // BtleHub emits for any reading; WorkoutDialog applies the threshold
+    QCOMPARE(spy.count(), 1);
+    QCOMPARE(spy.at(0).at(1).toInt(), 75);
+}
+
+/// Value > 100 must be clamped to 100.
+void TstBtleHub::testBattery_clamped()
+{
+    QSignalSpy spy(hub, &BtleHub::signal_battery);
+    hub->simulateNotification(BTLE_UUID_BATTERY_LEVEL, QByteArray(1, char(200)));
+    QCOMPARE(spy.count(), 1);
+    QCOMPARE(spy.at(0).at(1).toInt(), 100);
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Interval summary — power-adherence classification
+// ─────────────────────────────────────────────────────────────────────────────
+using PA = IntervalSummaryUtil::PowerAdherence;
+
+void TstBtleHub::testIntervalSummary_met_exactTarget()
+{
+    QCOMPARE(IntervalSummaryUtil::classifyPowerAdherence(200.0, 200.0), PA::Met);
+}
+
+void TstBtleHub::testIntervalSummary_met_upperBoundary()
+{
+    // exactly +5% → still Met
+    QCOMPARE(IntervalSummaryUtil::classifyPowerAdherence(210.0, 200.0), PA::Met);
+}
+
+void TstBtleHub::testIntervalSummary_met_lowerBoundary()
+{
+    // exactly -5% → still Met
+    QCOMPARE(IntervalSummaryUtil::classifyPowerAdherence(190.0, 200.0), PA::Met);
+}
+
+void TstBtleHub::testIntervalSummary_nearMiss_upperBoundary()
+{
+    // +7% → NearMiss
+    QCOMPARE(IntervalSummaryUtil::classifyPowerAdherence(214.0, 200.0), PA::NearMiss);
+}
+
+void TstBtleHub::testIntervalSummary_nearMiss_lowerBoundary()
+{
+    // -7% → NearMiss
+    QCOMPARE(IntervalSummaryUtil::classifyPowerAdherence(186.0, 200.0), PA::NearMiss);
+}
+
+void TstBtleHub::testIntervalSummary_missed_above()
+{
+    // +15% → Missed
+    QCOMPARE(IntervalSummaryUtil::classifyPowerAdherence(230.0, 200.0), PA::Missed);
+}
+
+void TstBtleHub::testIntervalSummary_missed_below()
+{
+    // -15% → Missed
+    QCOMPARE(IntervalSummaryUtil::classifyPowerAdherence(170.0, 200.0), PA::Missed);
+}
+
+void TstBtleHub::testIntervalSummary_zeroTarget_returnsMet()
+{
+    // no power target (e.g. HR-only or free-ride interval) → always Met
+    QCOMPARE(IntervalSummaryUtil::classifyPowerAdherence(0.0, 0.0), PA::Met);
+}
+
 // ─────────────────────────────────────────────────────────────────────────────
 QTEST_MAIN(TstBtleHub)
 #include "tst_btle_hub.moc"
diff --git a/tests/playwright/wasm_btle_api.spec.js b/tests/playwright/wasm_btle_api.spec.js
index 7efe0215..8a8fda83 100644
--- a/tests/playwright/wasm_btle_api.spec.js
+++ b/tests/playwright/wasm_btle_api.spec.js
@@ -89,7 +89,7 @@ async function waitForCanvas(page) {
       const canvas = document.querySelector('#qt-canvas-wrapper');
       return canvas && canvas.style.visibility !== 'hidden';
     },
-    { timeout: 30000 }
+    { timeout: 45000 }
   );
   // Trigger BLE scan via the test helper registered by BtleHubWasm::ctor.
   // In a real browser this would require a user gesture; the mock injected by
@@ -111,7 +111,7 @@ async function waitForCanvas(page) {
         Array.isArray(calls.writeValueWithResponse) &&
         calls.writeValueWithResponse.length > 0;
     },
-    { timeout: 15000 }
+    { timeout: 45000 }
   );
 }
 
@@ -119,6 +119,11 @@ async function waitForCanvas(page) {
 
 test.describe('WASM BLE API — Web Bluetooth call verification', () => {
 
+  // These tests load the deployed WASM app and trigger a full BLE scan + GATT
+  // setup flow.  The WASM binary can take 30–50 s to load and initialise on
+  // CI runners, so give each test 120 s (2×default) instead of the global 60 s.
+  test.describe.configure({ timeout: 120_000 });
+
   // ── requestDevice service filters ──────────────────────────────────────────
   test('requestDevice is called with correct service filter UUIDs', async ({ page }) => {
     await injectRecordingBluetoothMock(page);
@@ -131,6 +136,11 @@ test.describe('WASM BLE API — Web Bluetooth call verification', () => {
 
     const recorded = await page.evaluate(() => window._btleApiCalls);
 
+    // Diagnostic: log the full BLE call record when requestDevice was not triggered
+    if (!recorded.requestDeviceFilters) {
+      console.error('BLE scan was not initiated. window._btleApiCalls:', JSON.stringify(recorded));
+    }
+
     // requestDevice must have been called by js_scanAndConnect
     expect(recorded.requestDeviceFilters,
       'navigator.bluetooth.requestDevice() was not called — BLE scan was not initiated')
diff --git a/tests/playwright/wasm_webapp.spec.js b/tests/playwright/wasm_webapp.spec.js
index 383cf152..886b6695 100644
--- a/tests/playwright/wasm_webapp.spec.js
+++ b/tests/playwright/wasm_webapp.spec.js
@@ -242,6 +242,45 @@ test.describe('Browser compatibility guard', () => {
   });
 });
 
+// ── PWA / manifest checks ─────────────────────────────────────────────────
+test.describe('PWA support', () => {
+  test('manifest.json returns 200', async ({ request }) => {
+    const res = await request.get(`${BASE_URL}/manifest.json`);
+    expect(res.status(), 'manifest.json should be deployed (200)').toBe(200);
+  });
+
+  test('manifest.json has required PWA fields', async ({ request }) => {
+    const res = await request.get(`${BASE_URL}/manifest.json`);
+    expect(res.status()).toBe(200);
+    const manifest = await res.json();
+    expect(manifest.name, 'manifest must have a name').toBeTruthy();
+    expect(manifest.short_name, 'manifest must have a short_name').toBeTruthy();
+    expect(manifest.start_url, 'manifest must have a start_url').toBeTruthy();
+    expect(manifest.display, 'manifest must have a display mode').toBeTruthy();
+    expect(manifest.icons, 'manifest must have icons array').toBeDefined();
+    expect(Array.isArray(manifest.icons)).toBe(true);
+    expect(manifest.icons.length, 'manifest must have at least one icon').toBeGreaterThan(0);
+  });
+
+  test('service-worker.js returns 200', async ({ request }) => {
+    const res = await request.get(`${BASE_URL}/service-worker.js`);
+    expect(res.status(), 'service-worker.js should be deployed (200)').toBe(200);
+  });
+
+  test('app/index.html links to manifest', async ({ request }) => {
+    const res = await request.get(APP_URL);
+    expect(res.status()).toBe(200);
+    const html = await res.text();
+    expect(html, 'index.html should contain manifest link').toContain('manifest.json');
+  });
+
+  test('app/index.html has theme-color meta tag', async ({ request }) => {
+    const res = await request.get(APP_URL);
+    const html = await res.text();
+    expect(html, 'index.html should have theme-color meta tag').toContain('theme-color');
+  });
+});
+
 // ── BLE reconnect overlay checks ──────────────────────────────────────────
 test.describe('BLE reconnect overlay', () => {
   test('reconnect overlay is present in the DOM and hidden by default', async ({ page }) => {