expose: buy/sell_price_now follow the live dual-tariff slot

Subscribe the separate DSMR tariff topic (dsmr/meter-stats/electricity_tariff,
1=dal/off-peak, 2=normal/peak), keep the latest slot in memory, and make the
manual-contract buy/sell_price_now sensors show the matching tariff's price
(tariff 1 -> dal, 2/unknown -> normal). Tibber (single 15-min price) unchanged.
Billing is untouched (register-split already handles tariffs correctly).

- new config dsmr_tariff_topic; subscribe managed by apply_dsmr_subscription
  (restart-free on config save). In-memory tariff is lock-guarded.
- import_cost_total / export_revenue_total cumulative getters unchanged.

app/services/config_page.py

@@ -138,6 +138,12 @@ CONFIG_FIELDS: tuple[ConfigField, ...] = (
         "DSMR Sample Interval (s)",
         input_type="number",
     ),
+    ConfigField(
+        "DSMR",
+        "DSMR_TARIFF_TOPIC",
+        "dsmr_tariff_topic",
+        "DSMR Tariff Topic",
+    ),
     ConfigField(
         "Tibber",
         "TIBBER_API_TOKEN",
@@ -348,6 +354,7 @@ def _settings_payload(settings: Settings) -> dict[str, Any]:
         "dsmr_ingest_enabled": settings.dsmr_ingest_enabled,
         "dsmr_mqtt_topic": settings.dsmr_mqtt_topic,
         "dsmr_sample_interval_s": settings.dsmr_sample_interval_s,
+        "dsmr_tariff_topic": settings.dsmr_tariff_topic,
         "tibber_api_token": settings.tibber_api_token,
         "tibber_home_id": settings.tibber_home_id,
     }

app/services/dsmr_ingest.py

@@ -32,6 +32,7 @@ from __future__ import annotations
 
 import json
 import logging
+import threading
 from datetime import datetime, timezone
 from typing import TYPE_CHECKING
 
@@ -51,17 +52,81 @@ logger = logging.getLogger(__name__)
 # change can unsubscribe the old topic before subscribing the new one.
 _current_dsmr_topic: str | None = None
 
+# Tracks the DSMR tariff topic currently subscribed via the MQTT manager.
+_current_tariff_topic: str | None = None
+
+# Current electricity tariff: 1 = dal/off-peak, 2 = normal/peak.
+# Written by the paho network thread, read by the publish job — guarded by a lock.
+_current_tariff: int | None = None
+_tariff_lock = threading.Lock()
+
+
+def get_current_tariff() -> int | None:
+    """Return the most recently received electricity tariff (1 or 2), or None."""
+    with _tariff_lock:
+        return _current_tariff
+
+
+def set_current_tariff(value: int | None) -> None:
+    """Set the current electricity tariff (1 or 2), or clear it with None."""
+    with _tariff_lock:
+        global _current_tariff
+        _current_tariff = value
+
+
+def handle_tariff_message(payload_bytes: bytes) -> None:
+    """Parse one DSMR tariff MQTT payload and update the in-memory tariff state.
+
+    Called from the paho network thread; *must* swallow all exceptions so that
+    a bad payload never crashes the loop or drops the broker connection.
+
+    Accepts payload as bytes or str (paho can deliver either).  Ignores
+    whitespace.  Only accepts integer values 1 or 2; anything else is discarded
+    and the previous known tariff is preserved.
+
+    Parameters
+    ----------
+    payload_bytes:
+        Raw bytes from the MQTT message (may also be a str in some paho versions).
+    """
+    try:
+        # Decode bytes → str if needed; strip surrounding whitespace.
+        if isinstance(payload_bytes, (bytes, bytearray)):
+            raw = payload_bytes.decode("utf-8", errors="replace").strip()
+        else:
+            raw = str(payload_bytes).strip()
+
+        value = int(raw)
+        if value not in (1, 2):
+            logger.debug(
+                "dsmr_ingest.handle_tariff_message: unexpected tariff value %d (expected 1 or 2, ignored).",
+                value,
+            )
+            return
+
+        set_current_tariff(value)
+        logger.debug("dsmr_ingest.handle_tariff_message: tariff updated to %d.", value)
+
+    except Exception:
+        # Malformed payload (e.g. non-numeric); swallow silently to protect network thread.
+        logger.debug(
+            "dsmr_ingest.handle_tariff_message: could not parse payload %r (ignored).",
+            payload_bytes,
+        )
+
 
 def apply_dsmr_subscription(settings: "Settings") -> None:
-    """(Re)apply the DSMR MQTT subscription to match *settings* — restart-free.
+    """(Re)apply the DSMR MQTT subscriptions to match *settings* — restart-free.
 
     Call this at startup and after every config save.  It makes the live MQTT
-    subscription reflect the current ``dsmr_ingest_enabled`` / ``dsmr_mqtt_topic``
-    / ``dsmr_sample_interval_s`` settings without an app restart:
+    subscriptions reflect the current ``dsmr_ingest_enabled`` / ``dsmr_mqtt_topic``
+    / ``dsmr_sample_interval_s`` / ``dsmr_tariff_topic`` settings without an app
+    restart:
 
-    - **Disabled** → unsubscribe any active DSMR subscription.
+    - **Disabled** → unsubscribe any active DSMR and tariff subscriptions.
     - **Enabled** → (re)subscribe to ``dsmr_mqtt_topic`` with a handler bound to
       a *fresh* settings snapshot, so a changed sample interval also takes effect.
+      Also subscribe to ``dsmr_tariff_topic`` when non-empty.
     - **Topic changed** → unsubscribe the old topic before subscribing the new one.
 
     Idempotent and safe to call when MQTT is not connected (the subscription is
@@ -70,15 +135,23 @@ def apply_dsmr_subscription(settings: "Settings") -> None:
     # Imported here (not at module top) to avoid a circular import at app start.
     from app.integrations.mqtt import mqtt_manager
 
-    global _current_dsmr_topic
+    global _current_dsmr_topic, _current_tariff_topic
 
     if not settings.dsmr_ingest_enabled:
         if _current_dsmr_topic is not None:
             mqtt_manager.unsubscribe(_current_dsmr_topic)
             logger.info("DSMR ingest disabled — unsubscribed from topic=%s.", _current_dsmr_topic)
             _current_dsmr_topic = None
+        if _current_tariff_topic is not None:
+            mqtt_manager.unsubscribe(_current_tariff_topic)
+            logger.info(
+                "DSMR ingest disabled — unsubscribed from tariff topic=%s.",
+                _current_tariff_topic,
+            )
+            _current_tariff_topic = None
         return
 
+    # --- Main DSMR telegram topic ---
     topic = settings.dsmr_mqtt_topic
     if _current_dsmr_topic is not None and _current_dsmr_topic != topic:
         mqtt_manager.unsubscribe(_current_dsmr_topic)
@@ -90,6 +163,24 @@ def apply_dsmr_subscription(settings: "Settings") -> None:
     _current_dsmr_topic = topic
     logger.info("DSMR ingest enabled — subscribed to topic=%s.", topic)
 
+    # --- DSMR tariff topic (dual-tariff slot indicator) ---
+    tariff_topic = settings.dsmr_tariff_topic if settings.dsmr_tariff_topic else ""
+    if tariff_topic:
+        if _current_tariff_topic is not None and _current_tariff_topic != tariff_topic:
+            mqtt_manager.unsubscribe(_current_tariff_topic)
+        mqtt_manager.subscribe(tariff_topic, lambda payload: handle_tariff_message(payload))
+        _current_tariff_topic = tariff_topic
+        logger.info("DSMR tariff topic — subscribed to topic=%s.", tariff_topic)
+    else:
+        # tariff_topic is empty → unsubscribe any existing tariff subscription.
+        if _current_tariff_topic is not None:
+            mqtt_manager.unsubscribe(_current_tariff_topic)
+            logger.info(
+                "DSMR tariff topic cleared — unsubscribed from topic=%s.",
+                _current_tariff_topic,
+            )
+            _current_tariff_topic = None
+
 
 def handle_message(payload_bytes: bytes, settings: "Settings") -> None:
     """Parse one DSMR MQTT payload and persist it if it passes the sample filter.