docs: add version snapshot v0.27.0 and cleanup old versions [skip ci]

homeassistant==2026.3.4 requires Python>=3.14.2. The lint workflow was
specifying Python 3.13, and uv venv was ignoring actions/setup-python and
picking up the system Python (3.14.0) instead.

Changes:
- lint.yml: python-version 3.13 → 3.14
- bootstrap: uv venv now uses $(which python) to respect
  actions/setup-python and local pyenv/asdf setups

Impact: lint workflow no longer fails with Python version unsatisfiable
dependency error when installing homeassistant.

.devcontainer/devcontainer.json

@@ -1,10 +1,11 @@
 {
     "name": "jpawlowski/hass.tibber_prices",
-    "image": "mcr.microsoft.com/devcontainers/python:3.13",
+    "image": "mcr.microsoft.com/devcontainers/python:3.14",
     "postCreateCommand": "bash .devcontainer/setup-git.sh && scripts/setup/setup",
     "postStartCommand": "scripts/motd",
     "containerEnv": {
-        "PYTHONASYNCIODEBUG": "1"
+        "PYTHONASYNCIODEBUG": "1",
+        "TIBBER_PRICES_DEV": "1"
     },
     "forwardPorts": [
         8123,
@@ -69,7 +70,7 @@
                 ],
                 "python.defaultInterpreterPath": "${workspaceFolder}/.venv/bin/python",
                 "python.analysis.extraPaths": [
-                    "${workspaceFolder}/.venv/lib/python3.13/site-packages"
+                    "${workspaceFolder}/.venv/lib/python3.14/site-packages"
                 ],
                 "python.terminal.activateEnvironment": true,
                 "python.terminal.activateEnvInCurrentTerminal": true,

.github/workflows/auto-tag.yml

@@ -43,13 +43,13 @@ jobs:
             echo "✗ Tag v${{ steps.manifest.outputs.version }} does not exist yet"
           fi
 
-      - name: Validate version format
+      - name: Validate version format (stable or beta)
         if: steps.tag_check.outputs.exists == 'false'
         run: |
           VERSION="${{ steps.manifest.outputs.version }}"
-          if ! echo "$VERSION" | grep -qE '^[0-9]+\.[0-9]+\.[0-9]+$'; then
+          if ! echo "$VERSION" | grep -qE '^[0-9]+\.[0-9]+\.[0-9]+(b[0-9]+)?$'; then
             echo "❌ Invalid version format: $VERSION"
-            echo "Expected format: X.Y.Z (e.g., 1.0.0)"
+            echo "Expected format: X.Y.Z or X.Y.ZbN (e.g., 1.0.0, 0.25.0b0)"
             exit 1
           fi
           echo "✓ Version format valid: $VERSION"

.github/workflows/docusaurus.yml

@@ -33,6 +33,17 @@ jobs:
         with:
           fetch-depth: 0  # Needed for version timestamps
 
+      - name: Detect prerelease tag (beta/rc)
+        id: taginfo
+        run: |
+          if [[ "${GITHUB_REF}" =~ ^refs/tags/v[0-9]+\.[0-9]+\.[0-9]+(b[0-9]+|rc[0-9]+)$ ]]; then
+            echo "is_prerelease=true" >> "$GITHUB_OUTPUT"
+            echo "Detected prerelease tag: ${GITHUB_REF}"
+          else
+            echo "is_prerelease=false" >> "$GITHUB_OUTPUT"
+            echo "Stable tag or branch: ${GITHUB_REF}"
+          fi
+
       - uses: actions/setup-node@v6
         with:
           node-version: 24
@@ -47,7 +58,7 @@ jobs:
         run: npm ci
 
       - name: Create user docs version snapshot on tag
-        if: startsWith(github.ref, 'refs/tags/v')
+        if: startsWith(github.ref, 'refs/tags/v') && steps.taginfo.outputs.is_prerelease != 'true'
         working-directory: docs/user
         run: |
           TAG_VERSION=${GITHUB_REF#refs/tags/}
@@ -61,7 +72,7 @@ jobs:
           fi
 
       - name: Cleanup old user docs versions
-        if: startsWith(github.ref, 'refs/tags/v')
+        if: startsWith(github.ref, 'refs/tags/v') && steps.taginfo.outputs.is_prerelease != 'true'
         working-directory: docs/user
         run: |
           chmod +x ../cleanup-old-versions.sh
@@ -80,7 +91,7 @@ jobs:
         run: npm ci
 
       - name: Create developer docs version snapshot on tag
-        if: startsWith(github.ref, 'refs/tags/v')
+        if: startsWith(github.ref, 'refs/tags/v') && steps.taginfo.outputs.is_prerelease != 'true'
         working-directory: docs/developer
         run: |
           TAG_VERSION=${GITHUB_REF#refs/tags/}
@@ -94,7 +105,7 @@ jobs:
           fi
 
       - name: Cleanup old developer docs versions
-        if: startsWith(github.ref, 'refs/tags/v')
+        if: startsWith(github.ref, 'refs/tags/v') && steps.taginfo.outputs.is_prerelease != 'true'
         working-directory: docs/developer
         run: |
           chmod +x ../cleanup-old-versions.sh
@@ -118,7 +129,7 @@ jobs:
 
       # COMMIT VERSION SNAPSHOTS
       - name: Commit version snapshots back to repository
-        if: startsWith(github.ref, 'refs/tags/v')
+        if: startsWith(github.ref, 'refs/tags/v') && steps.taginfo.outputs.is_prerelease != 'true'
         run: |
           TAG_VERSION=${GITHUB_REF#refs/tags/}
 
@@ -140,7 +151,7 @@ jobs:
 
       # DEPLOY TO GITHUB PAGES
       - name: Setup Pages
-        uses: actions/configure-pages@v5
+        uses: actions/configure-pages@v6
 
       - name: Upload artifact
         uses: actions/upload-pages-artifact@v4
@@ -149,4 +160,4 @@ jobs:
 
       - name: Deploy to GitHub Pages
         id: deployment
-        uses: actions/deploy-pages@v4
+        uses: actions/deploy-pages@v5

.github/workflows/lint.yml

@@ -29,12 +29,12 @@ jobs:
         uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
 
       - name: Set up Python
-        uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
+        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
         with:
-          python-version: "3.13"
+          python-version: "3.14"
 
       - name: Install uv
-        uses: astral-sh/setup-uv@ed21f2f24f8dd64503750218de024bcf64c7250a  # v7.1.5
+        uses: astral-sh/setup-uv@37802adc94f370d6bfd71619e3f0bf239e1f3b78  # v7.6.0
         with:
           version: "0.9.3"
 

.github/workflows/release.yml

@@ -135,10 +135,20 @@ jobs:
           FEAT=$(echo "$COMMITS" | grep -cE "^feat(\(.+\))?:" || true)
           FIX=$(echo "$COMMITS" | grep -cE "^fix(\(.+\))?:" || true)
 
-          # Parse versions
+          parse_version() {
+            local version="$1"
+            if [[ $version =~ ^([0-9]+)\.([0-9]+)\.([0-9]+)(b[0-9]+)?$ ]]; then
+              echo "${BASH_REMATCH[1]} ${BASH_REMATCH[2]} ${BASH_REMATCH[3]} ${BASH_REMATCH[4]}"
+            else
+              echo "Invalid version format: $version" >&2
+              exit 1
+            fi
+          }
+
+          # Parse versions (support beta/prerelease suffix like 0.25.0b0)
           PREV_VERSION="${PREV_TAG#v}"
-          IFS='.' read -r PREV_MAJOR PREV_MINOR PREV_PATCH <<< "$PREV_VERSION"
-          IFS='.' read -r MAJOR MINOR PATCH <<< "$TAG_VERSION"
+          read -r PREV_MAJOR PREV_MINOR PREV_PATCH PREV_PRERELEASE <<< "$(parse_version "$PREV_VERSION")"
+          read -r MAJOR MINOR PATCH PRERELEASE <<< "$(parse_version "$TAG_VERSION")"
 
           WARNING=""
           SUGGESTION=""
@@ -245,7 +255,7 @@ jobs:
           name: ${{ steps.release_notes.outputs.title }}
           body: ${{ steps.release_notes.outputs.notes }}
           draft: false
-          prerelease: false
+          prerelease: ${{ contains(github.ref, 'b') }}
           generate_release_notes: false  # We provide our own
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/validate.yml

@@ -32,7 +32,7 @@ jobs:
         uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
 
       - name: Run hassfest validation
-        uses: home-assistant/actions/hassfest@87c064c607f3c5cc673a24258d0c98d23033bfc3 # master
+        uses: home-assistant/actions/hassfest@d56d093b9ab8d2105bc0cb6ee9bcc0ef4ec8b96d # master
 
   hacs: # https://github.com/hacs/action
     name: HACS validation

AGENTS.md

@@ -1838,12 +1838,12 @@ This is a Home Assistant standard to avoid naming conflicts between integrations
 # ✅ CORRECT - Integration prefix + semantic purpose
 class TibberPricesApiClient:              # Integration + semantic role
 class TibberPricesDataUpdateCoordinator:  # Integration + semantic role
-class TibberPricesDataFetcher:            # Integration + semantic role
+class TibberPricesPriceDataManager:       # Integration + semantic role
 class TibberPricesSensor:                 # Integration + entity type
 class TibberPricesEntity:                 # Integration + entity type
 
 # ❌ INCORRECT - Missing integration prefix
-class DataFetcher:         # Should be: TibberPricesDataFetcher
+class PriceDataManager:    # Should be: TibberPricesPriceDataManager
 class TimeService:         # Should be: TibberPricesTimeService
 class PeriodCalculator:    # Should be: TibberPricesPeriodCalculator
 
@@ -1855,11 +1855,11 @@ class TibberPricesSensorCalculatorTrend:   # Too verbose, import path shows loca
 **IMPORTANT:** Do NOT include package hierarchy in class names. Python's import system provides the namespace:
 ```python
 # The import path IS the full namespace:
-from custom_components.tibber_prices.coordinator.data_fetching import TibberPricesDataFetcher
+from custom_components.tibber_prices.coordinator.price_data_manager import TibberPricesPriceDataManager
 from custom_components.tibber_prices.sensor.calculators.trend import TibberPricesTrendCalculator
 
 # Adding package names to class would be redundant:
-# TibberPricesCoordinatorDataFetcher  ❌ NO - unnecessarily verbose
+# TibberPricesCoordinatorPriceDataManager  ❌ NO - unnecessarily verbose
 # TibberPricesSensorCalculatorsTrendCalculator  ❌ NO - ridiculously long
 ```
 
@@ -1905,14 +1905,14 @@ result = _InternalHelper().process()
 
 **Example of genuine private class use case:**
 ```python
-# In coordinator/data_fetching.py
+# In coordinator/price_data_manager.py
 class _ApiRetryStateMachine:
     """Internal state machine for retry logic. Never used outside this file."""
     def __init__(self, max_retries: int) -> None:
         self._attempts = 0
         self._max_retries = max_retries
 
-    # Only used by DataFetcher methods in this file
+    # Only used by PriceDataManager methods in this file
 ```
 
 In practice, most "helper" logic should be **functions**, not classes. Reserve classes for stateful components.

config/configuration.yaml

@@ -49,6 +49,8 @@ logger:
     custom_components.tibber_prices.coordinator.period_handlers.period_overlap.details: info
     # Outlier flex capping
     custom_components.tibber_prices.coordinator.period_handlers.core.details: info
+    # Level filtering details (min_distance scaling)
+    custom_components.tibber_prices.coordinator.period_handlers.level_filtering.details: info
 
     # Interval pool details (cache operations, GC):
     # Cache lookup/miss, gap detection, fetch group additions

custom_components/tibber_prices/__init__.py

@@ -47,6 +47,8 @@ if TYPE_CHECKING:
 PLATFORMS: list[Platform] = [
     Platform.SENSOR,
     Platform.BINARY_SENSOR,
+    Platform.NUMBER,
+    Platform.SWITCH,
 ]
 
 # Configuration schema for configuration.yaml
@@ -126,14 +128,15 @@ async def _migrate_config_options(hass: HomeAssistant, entry: ConfigEntry) -> No
     migration_performed = False
     migrated = dict(entry.options)
 
-    # Migration: Set currency_display_mode to minor for existing configs
-    # New configs get currency-appropriate defaults from schema.
-    # This preserves legacy behavior where all prices were in subunit currency.
+    # Migration: Set currency_display_mode to subunit for legacy configs
+    # New configs (created after v1.1.0) get currency-appropriate defaults via get_default_options().
+    # This migration preserves legacy behavior where all prices were in subunit currency (cents/øre).
+    # Only runs for old config entries that don't have this option explicitly set.
     if CONF_CURRENCY_DISPLAY_MODE not in migrated:
         migrated[CONF_CURRENCY_DISPLAY_MODE] = DISPLAY_MODE_SUBUNIT
         migration_performed = True
         LOGGER.info(
-            "[%s] Migrated config: Set currency_display_mode=%s (legacy default for existing configs)",
+            "[%s] Migrated legacy config: Set currency_display_mode=%s (preserves pre-v1.1.0 behavior)",
             entry.title,
             DISPLAY_MODE_SUBUNIT,
         )
@@ -276,7 +279,8 @@ async def async_setup_entry(
     # https://developers.home-assistant.io/docs/integration_fetching_data#coordinated-single-api-poll-for-data-for-all-entities
     if entry.state == ConfigEntryState.SETUP_IN_PROGRESS:
         await coordinator.async_config_entry_first_refresh()
-        entry.async_on_unload(entry.add_update_listener(async_reload_entry))
+        # Note: Options update listener is registered in coordinator.__init__
+        # (handles cache invalidation + refresh without full reload)
     else:
         await coordinator.async_refresh()
 
@@ -296,6 +300,9 @@ async def async_unload_entry(
         await async_save_pool_state(hass, entry.entry_id, pool_state)
         LOGGER.debug("[%s] Interval pool state saved on unload", entry.title)
 
+        # Shutdown interval pool (cancels background tasks)
+        await entry.runtime_data.interval_pool.async_shutdown()
+
     unload_ok = await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
 
     if unload_ok and entry.runtime_data is not None:

custom_components/tibber_prices/api/helpers.py

@@ -340,7 +340,8 @@ def flatten_price_info(subscription: dict) -> list[dict]:
         A flat list containing all price dictionaries (startsAt, total, level).
 
     """
-    price_info_range = subscription.get("priceInfoRange", {})
+    # Use 'or {}' to handle None values (API may return None during maintenance)
+    price_info_range = subscription.get("priceInfoRange") or {}
 
     # Transform priceInfoRange edges data (extract historical quarter-hourly prices)
     # This contains 192 intervals (2 days) starting from day before yesterday midnight
@@ -355,8 +356,6 @@ def flatten_price_info(subscription: dict) -> list[dict]:
             historical_prices.append(edge["node"])
 
     # Return all intervals as a single flattened array
-    return (
-        historical_prices
-        + subscription.get("priceInfo", {}).get("today", [])
-        + subscription.get("priceInfo", {}).get("tomorrow", [])
-    )
+    # Use 'or {}' to handle None values (API may return None during maintenance)
+    price_info = subscription.get("priceInfo") or {}
+    return historical_prices + (price_info.get("today") or []) + (price_info.get("tomorrow") or [])

custom_components/tibber_prices/binary_sensor/attributes.py

@@ -207,6 +207,8 @@ def add_price_attributes(attributes: dict, current_period: dict, factor: int) ->
         attributes["price_max"] = round(current_period["price_max"] * factor, precision)
     if "price_spread" in current_period:
         attributes["price_spread"] = round(current_period["price_spread"] * factor, precision)
+    if "price_coefficient_variation_%" in current_period:
+        attributes["price_coefficient_variation_%"] = current_period["price_coefficient_variation_%"]
     if "volatility" in current_period:
         attributes["volatility"] = current_period["volatility"]  # Volatility is not a price, keep as-is
 

custom_components/tibber_prices/config_flow.py

@@ -14,6 +14,7 @@ from .config_flow_handlers.schemas import (
     get_best_price_schema,
     get_options_init_schema,
     get_peak_price_schema,
+    get_price_level_schema,
     get_price_rating_schema,
     get_price_trend_schema,
     get_reauth_confirm_schema,
@@ -41,6 +42,7 @@ __all__ = [
     "get_best_price_schema",
     "get_options_init_schema",
     "get_peak_price_schema",
+    "get_price_level_schema",
     "get_price_rating_schema",
     "get_price_trend_schema",
     "get_reauth_confirm_schema",

custom_components/tibber_prices/config_flow_handlers/__init__.py

@@ -27,6 +27,7 @@ from custom_components.tibber_prices.config_flow_handlers.schemas import (
     get_best_price_schema,
     get_options_init_schema,
     get_peak_price_schema,
+    get_price_level_schema,
     get_price_rating_schema,
     get_price_trend_schema,
     get_reauth_confirm_schema,
@@ -56,6 +57,7 @@ __all__ = [
     "get_best_price_schema",
     "get_options_init_schema",
     "get_peak_price_schema",
+    "get_price_level_schema",
     "get_price_rating_schema",
     "get_price_trend_schema",
     "get_reauth_confirm_schema",

custom_components/tibber_prices/config_flow_handlers/entity_check.py

@@ -0,0 +1,243 @@
+"""
+Entity check utilities for options flow.
+
+This module provides functions to check if relevant entities are enabled
+for specific options flow steps. If no relevant entities are enabled,
+a warning can be displayed to users.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+from custom_components.tibber_prices.const import DOMAIN
+from homeassistant.helpers.entity_registry import async_get as async_get_entity_registry
+
+if TYPE_CHECKING:
+    from homeassistant.config_entries import ConfigEntry
+    from homeassistant.core import HomeAssistant
+
+_LOGGER = logging.getLogger(__name__)
+
+# Maximum number of example sensors to show in warning message
+MAX_EXAMPLE_SENSORS = 3
+# Threshold for using "and" vs "," in formatted names
+NAMES_SIMPLE_JOIN_THRESHOLD = 2
+
+# Mapping of options flow steps to affected sensor keys
+# These are the entity keys (from sensor/definitions.py and binary_sensor/definitions.py)
+# that are affected by each settings page
+STEP_TO_SENSOR_KEYS: dict[str, list[str]] = {
+    # Price Rating settings affect all rating sensors
+    "current_interval_price_rating": [
+        # Interval rating sensors
+        "current_interval_price_rating",
+        "next_interval_price_rating",
+        "previous_interval_price_rating",
+        # Rolling hour rating sensors
+        "current_hour_price_rating",
+        "next_hour_price_rating",
+        # Daily rating sensors
+        "yesterday_price_rating",
+        "today_price_rating",
+        "tomorrow_price_rating",
+    ],
+    # Price Level settings affect level sensors and period binary sensors
+    "price_level": [
+        # Interval level sensors
+        "current_interval_price_level",
+        "next_interval_price_level",
+        "previous_interval_price_level",
+        # Rolling hour level sensors
+        "current_hour_price_level",
+        "next_hour_price_level",
+        # Daily level sensors
+        "yesterday_price_level",
+        "today_price_level",
+        "tomorrow_price_level",
+        # Binary sensors that use level filtering
+        "best_price_period",
+        "peak_price_period",
+    ],
+    # Volatility settings affect volatility sensors
+    "volatility": [
+        "today_volatility",
+        "tomorrow_volatility",
+        "next_24h_volatility",
+        "today_tomorrow_volatility",
+        # Also affects trend sensors (adaptive thresholds)
+        "current_price_trend",
+        "next_price_trend_change",
+        "price_trend_1h",
+        "price_trend_2h",
+        "price_trend_3h",
+        "price_trend_4h",
+        "price_trend_5h",
+        "price_trend_6h",
+        "price_trend_8h",
+        "price_trend_12h",
+    ],
+    # Best Price settings affect best price binary sensor and timing sensors
+    "best_price": [
+        # Binary sensor
+        "best_price_period",
+        # Timing sensors
+        "best_price_end_time",
+        "best_price_period_duration",
+        "best_price_remaining_minutes",
+        "best_price_progress",
+        "best_price_next_start_time",
+        "best_price_next_in_minutes",
+    ],
+    # Peak Price settings affect peak price binary sensor and timing sensors
+    "peak_price": [
+        # Binary sensor
+        "peak_price_period",
+        # Timing sensors
+        "peak_price_end_time",
+        "peak_price_period_duration",
+        "peak_price_remaining_minutes",
+        "peak_price_progress",
+        "peak_price_next_start_time",
+        "peak_price_next_in_minutes",
+    ],
+    # Price Trend settings affect trend sensors
+    "price_trend": [
+        "current_price_trend",
+        "next_price_trend_change",
+        "price_trend_1h",
+        "price_trend_2h",
+        "price_trend_3h",
+        "price_trend_4h",
+        "price_trend_5h",
+        "price_trend_6h",
+        "price_trend_8h",
+        "price_trend_12h",
+    ],
+}
+
+
+def check_relevant_entities_enabled(
+    hass: HomeAssistant,
+    config_entry: ConfigEntry,
+    step_id: str,
+) -> tuple[bool, list[str]]:
+    """
+    Check if any relevant entities for a settings step are enabled.
+
+    Args:
+        hass: Home Assistant instance
+        config_entry: Current config entry
+        step_id: The options flow step ID
+
+    Returns:
+        Tuple of (has_enabled_entities, list_of_example_sensor_names)
+        - has_enabled_entities: True if at least one relevant entity is enabled
+        - list_of_example_sensor_names: List of example sensor keys for the warning message
+
+    """
+    sensor_keys = STEP_TO_SENSOR_KEYS.get(step_id)
+    if not sensor_keys:
+        # No mapping for this step - no check needed
+        return True, []
+
+    entity_registry = async_get_entity_registry(hass)
+    entry_id = config_entry.entry_id
+
+    enabled_count = 0
+    example_sensors: list[str] = []
+
+    for entity in entity_registry.entities.values():
+        # Check if entity belongs to our integration and config entry
+        if entity.config_entry_id != entry_id:
+            continue
+        if entity.platform != DOMAIN:
+            continue
+
+        # Extract the sensor key from unique_id
+        # unique_id format: "{home_id}_{sensor_key}" or "{entry_id}_{sensor_key}"
+        unique_id = entity.unique_id or ""
+        # The sensor key is after the last underscore that separates the ID prefix
+        # We check if any of our target keys is contained in the unique_id
+        for sensor_key in sensor_keys:
+            if unique_id.endswith(f"_{sensor_key}") or unique_id == sensor_key:
+                # Found a matching entity
+                if entity.disabled_by is None:
+                    # Entity is enabled
+                    enabled_count += 1
+                    break
+                # Entity is disabled - add to examples (max MAX_EXAMPLE_SENSORS)
+                if len(example_sensors) < MAX_EXAMPLE_SENSORS and sensor_key not in example_sensors:
+                    example_sensors.append(sensor_key)
+                break
+
+    # If we found enabled entities, return success
+    if enabled_count > 0:
+        return True, []
+
+    # No enabled entities - return the example sensors for the warning
+    # If we haven't collected any examples yet, use the first from the mapping
+    if not example_sensors:
+        example_sensors = sensor_keys[:MAX_EXAMPLE_SENSORS]
+
+    return False, example_sensors
+
+
+def format_sensor_names_for_warning(sensor_keys: list[str]) -> str:
+    """
+    Format sensor keys into human-readable names for warning message.
+
+    Args:
+        sensor_keys: List of sensor keys
+
+    Returns:
+        Formatted string like "Best Price Period, Best Price End Time, ..."
+
+    """
+    # Convert snake_case keys to Title Case names
+    names = []
+    for key in sensor_keys:
+        # Replace underscores with spaces and title case
+        name = key.replace("_", " ").title()
+        names.append(name)
+
+    if len(names) <= NAMES_SIMPLE_JOIN_THRESHOLD:
+        return " and ".join(names)
+
+    return ", ".join(names[:-1]) + ", and " + names[-1]
+
+
+def check_chart_data_export_enabled(
+    hass: HomeAssistant,
+    config_entry: ConfigEntry,
+) -> bool:
+    """
+    Check if the Chart Data Export sensor is enabled.
+
+    Args:
+        hass: Home Assistant instance
+        config_entry: Current config entry
+
+    Returns:
+        True if the Chart Data Export sensor is enabled, False otherwise
+
+    """
+    entity_registry = async_get_entity_registry(hass)
+    entry_id = config_entry.entry_id
+
+    for entity in entity_registry.entities.values():
+        # Check if entity belongs to our integration and config entry
+        if entity.config_entry_id != entry_id:
+            continue
+        if entity.platform != DOMAIN:
+            continue
+
+        # Check for chart_data_export sensor
+        unique_id = entity.unique_id or ""
+        if unique_id.endswith("_chart_data_export") or unique_id == "chart_data_export":
+            # Found the entity - check if enabled
+            return entity.disabled_by is None
+
+    # Entity not found (shouldn't happen, but treat as disabled)
+    return False

custom_components/tibber_prices/config_flow_handlers/options_flow.py

@@ -3,19 +3,28 @@
 from __future__ import annotations
 
 import logging
-from typing import TYPE_CHECKING, Any, ClassVar
+from copy import deepcopy
+from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
     from collections.abc import Mapping
 
+from custom_components.tibber_prices.config_flow_handlers.entity_check import (
+    check_chart_data_export_enabled,
+    check_relevant_entities_enabled,
+    format_sensor_names_for_warning,
+)
 from custom_components.tibber_prices.config_flow_handlers.schemas import (
+    ConfigOverrides,
     get_best_price_schema,
     get_chart_data_export_schema,
     get_display_settings_schema,
     get_options_init_schema,
     get_peak_price_schema,
+    get_price_level_schema,
     get_price_rating_schema,
     get_price_trend_schema,
+    get_reset_to_defaults_schema,
     get_volatility_schema,
 )
 from custom_components.tibber_prices.config_flow_handlers.validators import (
@@ -30,6 +39,8 @@ from custom_components.tibber_prices.config_flow_handlers.validators import (
     validate_price_rating_thresholds,
     validate_price_trend_falling,
     validate_price_trend_rising,
+    validate_price_trend_strongly_falling,
+    validate_price_trend_strongly_rising,
     validate_relaxation_attempts,
     validate_volatility_threshold_high,
     validate_volatility_threshold_moderate,
@@ -51,6 +62,8 @@ from custom_components.tibber_prices.const import (
     CONF_PRICE_RATING_THRESHOLD_LOW,
     CONF_PRICE_TREND_THRESHOLD_FALLING,
     CONF_PRICE_TREND_THRESHOLD_RISING,
+    CONF_PRICE_TREND_THRESHOLD_STRONGLY_FALLING,
+    CONF_PRICE_TREND_THRESHOLD_STRONGLY_RISING,
     CONF_RELAXATION_ATTEMPTS_BEST,
     CONF_RELAXATION_ATTEMPTS_PEAK,
     CONF_VOLATILITY_THRESHOLD_HIGH,
@@ -60,8 +73,11 @@ from custom_components.tibber_prices.const import (
     DEFAULT_VOLATILITY_THRESHOLD_MODERATE,
     DEFAULT_VOLATILITY_THRESHOLD_VERY_HIGH,
     DOMAIN,
+    async_get_translation,
+    get_default_options,
 )
 from homeassistant.config_entries import ConfigFlowResult, OptionsFlow
+from homeassistant.helpers import entity_registry as er
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -69,23 +85,34 @@ _LOGGER = logging.getLogger(__name__)
 class TibberPricesOptionsFlowHandler(OptionsFlow):
     """Handle options for tibber_prices entries."""
 
-    # Step progress tracking
-    _TOTAL_STEPS: ClassVar[int] = 8
-    _STEP_INFO: ClassVar[dict[str, int]] = {
-        "init": 1,
-        "display_settings": 2,
-        "current_interval_price_rating": 3,
-        "volatility": 4,
-        "best_price": 5,
-        "peak_price": 6,
-        "price_trend": 7,
-        "chart_data_export": 8,
-    }
-
     def __init__(self) -> None:
         """Initialize options flow."""
         self._options: dict[str, Any] = {}
 
+    def _merge_section_data(self, user_input: dict[str, Any]) -> None:
+        """
+        Merge section data from form input into options.
+
+        Home Assistant forms with section() return nested dicts like:
+        {"section_name": {"setting1": value1, "setting2": value2}}
+
+        We need to preserve this structure in config_entry.options.
+
+        Args:
+            user_input: Nested user input from form with sections
+
+        """
+        for section_key, section_data in user_input.items():
+            if isinstance(section_data, dict):
+                # This is a section - ensure the section exists in options
+                if section_key not in self._options:
+                    self._options[section_key] = {}
+                # Update the section with new values
+                self._options[section_key].update(section_data)
+            else:
+                # This is a direct value - keep it as is
+                self._options[section_key] = section_data
+
     def _migrate_config_options(self, options: Mapping[str, Any]) -> dict[str, Any]:
         """
         Migrate deprecated config options to current format.
@@ -100,7 +127,10 @@ class TibberPricesOptionsFlowHandler(OptionsFlow):
             Migrated options dict with deprecated keys removed/renamed
 
         """
-        migrated = dict(options)
+        # CRITICAL: Use deepcopy to avoid modifying the original config_entry.options
+        # If we use dict(options), nested dicts are still referenced, causing
+        # self._options modifications to leak into config_entry.options
+        migrated = deepcopy(dict(options))
         migration_performed = False
 
         # Migration 1: Rename relaxation_step_* to relaxation_attempts_*
@@ -144,41 +174,314 @@ class TibberPricesOptionsFlowHandler(OptionsFlow):
 
         return migrated
 
-    def _get_step_description_placeholders(self, step_id: str) -> dict[str, str]:
-        """Get description placeholders with step progress."""
-        if step_id not in self._STEP_INFO:
-            return {}
+    def _save_options_if_changed(self) -> bool:
+        """
+        Save options only if they actually changed.
 
-        step_num = self._STEP_INFO[step_id]
+        Returns:
+            True if options were updated, False if no changes detected
 
-        # Get translations loaded by Home Assistant
-        standard_translations_key = f"{DOMAIN}_standard_translations_{self.hass.config.language}"
-        translations = self.hass.data.get(standard_translations_key, {})
+        """
+        # Compare old and new options
+        if self.config_entry.options != self._options:
+            self.hass.config_entries.async_update_entry(
+                self.config_entry,
+                options=self._options,
+            )
+            return True
+        return False
 
-        # Get step progress text from translations with placeholders
-        step_progress_template = translations.get("common", {}).get("step_progress", "Step {step_num} of {total_steps}")
-        step_progress = step_progress_template.format(step_num=step_num, total_steps=self._TOTAL_STEPS)
+    def _get_entity_warning_placeholders(self, step_id: str) -> dict[str, str]:
+        """
+        Get description placeholders for entity availability warning.
 
+        Checks if any relevant entities for the step are enabled.
+        If not, adds a warning placeholder to display in the form description.
+
+        Args:
+            step_id: The options flow step ID
+
+        Returns:
+            Dictionary with placeholder keys for the form description
+
+        """
+        has_enabled, example_sensors = check_relevant_entities_enabled(self.hass, self.config_entry, step_id)
+
+        if has_enabled:
+            # No warning needed - return empty placeholder
+            return {"entity_warning": ""}
+
+        # Build warning message with example sensor names
+        sensor_names = format_sensor_names_for_warning(example_sensors)
         return {
-            "step_progress": step_progress,
+            "entity_warning": f"\n\n⚠️ **Note:** No sensors affected by these settings are currently enabled. "
+            f"To use these settings, first enable relevant sensors like *{sensor_names}* "
+            f"in **Settings → Devices & Services → Tibber Prices → Entities**."
         }
 
-    async def async_step_init(self, user_input: dict[str, Any] | None = None) -> ConfigFlowResult:
-        """Manage the options - General Settings."""
-        # Initialize options from config_entry on first call
-        if not self._options:
-            # Migrate deprecated config options before processing
+    def _get_enabled_config_entities(self) -> set[str]:
+        """
+        Get config keys that have their config entity enabled.
+
+        Checks the entity registry for number/switch entities that override
+        config values. Returns the config_key for each enabled entity.
+
+        Returns:
+            Set of config keys (e.g., "best_price_flex", "enable_min_periods_best")
+
+        """
+        enabled_keys: set[str] = set()
+        ent_reg = er.async_get(self.hass)
+
+        _LOGGER.debug(
+            "Checking for enabled config override entities for entry %s",
+            self.config_entry.entry_id,
+        )
+
+        # Map entity keys to their config keys
+        # Entity keys are defined in number/definitions.py and switch/definitions.py
+        override_entities = {
+            # Number entities (best price)
+            "number.best_price_flex_override": "best_price_flex",
+            "number.best_price_min_distance_override": "best_price_min_distance_from_avg",
+            "number.best_price_min_period_length_override": "best_price_min_period_length",
+            "number.best_price_min_periods_override": "min_periods_best",
+            "number.best_price_relaxation_attempts_override": "relaxation_attempts_best",
+            "number.best_price_gap_count_override": "best_price_max_level_gap_count",
+            # Number entities (peak price)
+            "number.peak_price_flex_override": "peak_price_flex",
+            "number.peak_price_min_distance_override": "peak_price_min_distance_from_avg",
+            "number.peak_price_min_period_length_override": "peak_price_min_period_length",
+            "number.peak_price_min_periods_override": "min_periods_peak",
+            "number.peak_price_relaxation_attempts_override": "relaxation_attempts_peak",
+            "number.peak_price_gap_count_override": "peak_price_max_level_gap_count",
+            # Switch entities
+            "switch.best_price_enable_relaxation_override": "enable_min_periods_best",
+            "switch.peak_price_enable_relaxation_override": "enable_min_periods_peak",
+        }
+
+        # Check each possible override entity
+        for entity_id_suffix, config_key in override_entities.items():
+            # Entity IDs include device name, so we need to search by unique_id pattern
+            # The unique_id follows pattern: {config_entry_id}_{entity_key}
+            domain, entity_key = entity_id_suffix.split(".", 1)
+
+            # Find entity by iterating through registry
+            for entity_entry in ent_reg.entities.values():
+                if (
+                    entity_entry.domain == domain
+                    and entity_entry.config_entry_id == self.config_entry.entry_id
+                    and entity_entry.unique_id
+                    and entity_entry.unique_id.endswith(entity_key)
+                    and not entity_entry.disabled
+                ):
+                    _LOGGER.debug(
+                        "Found enabled config override entity: %s -> config_key=%s",
+                        entity_entry.entity_id,
+                        config_key,
+                    )
+                    enabled_keys.add(config_key)
+                    break
+
+        _LOGGER.debug("Enabled config override keys: %s", enabled_keys)
+        return enabled_keys
+
+    def _get_active_overrides(self) -> ConfigOverrides:
+        """
+        Build override dict from enabled config entities.
+
+        Returns a dict structure compatible with schema functions.
+        """
+        enabled_keys = self._get_enabled_config_entities()
+        if not enabled_keys:
+            _LOGGER.debug("No enabled config override entities found")
+            return {}
+
+        # Build structure expected by schema: {section: {key: True}}
+        # Section doesn't matter for read_only check, we just need the key present
+        overrides: ConfigOverrides = {"_enabled": {}}
+        for key in enabled_keys:
+            overrides["_enabled"][key] = True
+
+        _LOGGER.debug("Active overrides structure: %s", overrides)
+        return overrides
+
+    def _get_override_warning_placeholder(self, step_id: str, overrides: ConfigOverrides) -> dict[str, str]:
+        """
+        Get description placeholder for config override warning.
+
+        Args:
+            step_id: The options flow step ID (e.g., "best_price", "peak_price")
+            overrides: Active overrides dictionary
+
+        Returns:
+            Dictionary with 'override_warning' placeholder
+
+        """
+        # Define which config keys belong to each step
+        step_keys: dict[str, set[str]] = {
+            "best_price": {
+                "best_price_flex",
+                "best_price_min_distance_from_avg",
+                "best_price_min_period_length",
+                "min_periods_best",
+                "relaxation_attempts_best",
+                "enable_min_periods_best",
+            },
+            "peak_price": {
+                "peak_price_flex",
+                "peak_price_min_distance_from_avg",
+                "peak_price_min_period_length",
+                "min_periods_peak",
+                "relaxation_attempts_peak",
+                "enable_min_periods_peak",
+            },
+        }
+
+        keys_to_check = step_keys.get(step_id, set())
+        enabled_keys = overrides.get("_enabled", {})
+        override_count = sum(1 for k in enabled_keys if k in keys_to_check)
+
+        if override_count > 0:
+            field_word = "field is" if override_count == 1 else "fields are"
+            return {
+                "override_warning": (
+                    f"\n\n🔒 **{override_count} {field_word} managed by configuration entities** "
+                    "(grayed out). Disable the config entity to edit here, "
+                    "or change the value directly via the entity."
+                )
+            }
+        return {"override_warning": ""}
+
+    async def _get_override_translations(self) -> dict[str, Any]:
+        """
+        Load override translations from common section.
+
+        Uses the system language setting from Home Assistant.
+        Note: HA Options Flow does not provide user_id in context,
+        so we cannot determine the individual user's language preference.
+
+        Returns:
+            Dictionary with override_warning_template, override_warning_and,
+            and override_field_label_* keys for each config field.
+
+        """
+        # Use system language - HA Options Flow context doesn't include user_id
+        language = self.hass.config.language or "en"
+        _LOGGER.debug("Loading override translations for language: %s", language)
+        translations: dict[str, Any] = {}
+
+        # Load template and connector from common section
+        template = await async_get_translation(self.hass, ["common", "override_warning_template"], language)
+        _LOGGER.debug("Loaded template: %s", template)
+        if template:
+            translations["override_warning_template"] = template
+
+        and_connector = await async_get_translation(self.hass, ["common", "override_warning_and"], language)
+        if and_connector:
+            translations["override_warning_and"] = and_connector
+
+        # Load flat field label translations
+        field_keys = [
+            "best_price_min_period_length",
+            "best_price_max_level_gap_count",
+            "best_price_flex",
+            "best_price_min_distance_from_avg",
+            "enable_min_periods_best",
+            "min_periods_best",
+            "relaxation_attempts_best",
+            "peak_price_min_period_length",
+            "peak_price_max_level_gap_count",
+            "peak_price_flex",
+            "peak_price_min_distance_from_avg",
+            "enable_min_periods_peak",
+            "min_periods_peak",
+            "relaxation_attempts_peak",
+        ]
+        for field_key in field_keys:
+            translation_key = f"override_field_label_{field_key}"
+            label = await async_get_translation(self.hass, ["common", translation_key], language)
+            if label:
+                translations[translation_key] = label
+
+        return translations
+
+    async def async_step_init(self, _user_input: dict[str, Any] | None = None) -> ConfigFlowResult:
+        """Manage the options - show menu."""
+        # Always reload options from config_entry to get latest saved state
+        # This ensures changes from previous steps are visible
         self._options = self._migrate_config_options(self.config_entry.options)
 
+        # Show menu with all configuration categories
+        return self.async_show_menu(
+            step_id="init",
+            menu_options=[
+                "general_settings",
+                "display_settings",
+                "current_interval_price_rating",
+                "price_level",
+                "volatility",
+                "best_price",
+                "peak_price",
+                "price_trend",
+                "chart_data_export",
+                "reset_to_defaults",
+                "finish",
+            ],
+        )
+
+    async def async_step_reset_to_defaults(self, user_input: dict[str, Any] | None = None) -> ConfigFlowResult:
+        """Reset all settings to factory defaults."""
         if user_input is not None:
+            # Check if user confirmed the reset
+            if user_input.get("confirm_reset", False):
+                # Get currency from config_entry.data (this is immutable and safe)
+                currency_code = self.config_entry.data.get("currency", None)
+
+                # Completely replace options with fresh defaults (factory reset)
+                # This discards ALL old data including legacy structures
+                self._options = get_default_options(currency_code)
+
+                # Force save the new options
+                self._save_options_if_changed()
+
+                _LOGGER.info(
+                    "Factory reset performed for config entry '%s' - all settings restored to defaults",
+                    self.config_entry.title,
+                )
+
+                # Show success message and return to menu
+                return self.async_abort(reason="reset_successful")
+
+            # User didn't check the box - they want to cancel
+            # Show info message (not error) and return to menu
+            return self.async_abort(reason="reset_cancelled")
+
+        # Show confirmation form with checkbox
+        return self.async_show_form(
+            step_id="reset_to_defaults",
+            data_schema=get_reset_to_defaults_schema(),
+        )
+
+    async def async_step_finish(self, _user_input: dict[str, Any] | None = None) -> ConfigFlowResult:
+        """Close the options flow."""
+        # Use empty reason to close without any message
+        return self.async_abort(reason="finished")
+
+    async def async_step_general_settings(self, user_input: dict[str, Any] | None = None) -> ConfigFlowResult:
+        """Configure general settings."""
+        if user_input is not None:
+            # Update options with new values
             self._options.update(user_input)
-            return await self.async_step_display_settings()
+            # Save options only if changed (triggers listeners automatically)
+            self._save_options_if_changed()
+            # Return to menu for more changes
+            return await self.async_step_init()
 
         return self.async_show_form(
-            step_id="init",
+            step_id="general_settings",
             data_schema=get_options_init_schema(self.config_entry.options),
             description_placeholders={
-                **self._get_step_description_placeholders("init"),
                 "user_login": self.config_entry.data.get("user_login", "N/A"),
             },
         )
@@ -194,13 +497,16 @@ class TibberPricesOptionsFlowHandler(OptionsFlow):
                 currency_code = tibber_data.coordinator.data.get("currency")
 
         if user_input is not None:
+            # Update options with new values
             self._options.update(user_input)
-            return await self.async_step_current_interval_price_rating()
+            # async_create_entry automatically handles change detection and listener triggering
+            self._save_options_if_changed()
+            # Return to menu for more changes
+            return await self.async_step_init()
 
         return self.async_show_form(
             step_id="display_settings",
             data_schema=get_display_settings_schema(self.config_entry.options, currency_code),
-            description_placeholders=self._get_step_description_placeholders("display_settings"),
         )
 
     async def async_step_current_interval_price_rating(
@@ -210,6 +516,9 @@ class TibberPricesOptionsFlowHandler(OptionsFlow):
         errors: dict[str, str] = {}
 
         if user_input is not None:
+            # Schema is now flattened - fields come directly in user_input
+            # But we still need to store them in nested structure for coordinator
+
             # Validate low price rating threshold
             if CONF_PRICE_RATING_THRESHOLD_LOW in user_input and not validate_price_rating_threshold_low(
                 user_input[CONF_PRICE_RATING_THRESHOLD_LOW]
@@ -223,26 +532,51 @@ class TibberPricesOptionsFlowHandler(OptionsFlow):
                 errors[CONF_PRICE_RATING_THRESHOLD_HIGH] = "invalid_price_rating_high"
 
             # Cross-validate both thresholds together (LOW must be < HIGH)
-            if not errors and not validate_price_rating_thresholds(
-                user_input.get(
+            if not errors:
+                # Get current values directly from options (now flat)
+                low_val = user_input.get(
                     CONF_PRICE_RATING_THRESHOLD_LOW, self._options.get(CONF_PRICE_RATING_THRESHOLD_LOW, -10)
-                ),
-                user_input.get(
+                )
+                high_val = user_input.get(
                     CONF_PRICE_RATING_THRESHOLD_HIGH, self._options.get(CONF_PRICE_RATING_THRESHOLD_HIGH, 10)
-                ),
-            ):
+                )
+                if not validate_price_rating_thresholds(low_val, high_val):
                     # This should never happen given the range constraints, but add error for safety
                     errors["base"] = "invalid_price_rating_thresholds"
 
             if not errors:
+                # Store flat data directly in options (no section wrapping)
                 self._options.update(user_input)
-                return await self.async_step_volatility()
+                # async_create_entry automatically handles change detection and listener triggering
+                self._save_options_if_changed()
+            # Return to menu for more changes
+            return await self.async_step_init()
 
         return self.async_show_form(
             step_id="current_interval_price_rating",
             data_schema=get_price_rating_schema(self.config_entry.options),
-            description_placeholders=self._get_step_description_placeholders("current_interval_price_rating"),
             errors=errors,
+            description_placeholders=self._get_entity_warning_placeholders("current_interval_price_rating"),
+        )
+
+    async def async_step_price_level(self, user_input: dict[str, Any] | None = None) -> ConfigFlowResult:
+        """Configure Tibber price level gap tolerance (smoothing for API 'level' field)."""
+        errors: dict[str, str] = {}
+
+        if user_input is not None:
+            # No validation needed - slider constraints ensure valid range
+            # Store flat data directly in options
+            self._options.update(user_input)
+            # async_create_entry automatically handles change detection and listener triggering
+            self._save_options_if_changed()
+            # Return to menu for more changes
+            return await self.async_step_init()
+
+        return self.async_show_form(
+            step_id="price_level",
+            data_schema=get_price_level_schema(self.config_entry.options),
+            errors=errors,
+            description_placeholders=self._get_entity_warning_placeholders("price_level"),
         )
 
     async def async_step_best_price(self, user_input: dict[str, Any] | None = None) -> ConfigFlowResult:
@@ -250,47 +584,74 @@ class TibberPricesOptionsFlowHandler(OptionsFlow):
         errors: dict[str, str] = {}
 
         if user_input is not None:
+            # Extract settings from sections
+            period_settings = user_input.get("period_settings", {})
+            flexibility_settings = user_input.get("flexibility_settings", {})
+            relaxation_settings = user_input.get("relaxation_and_target_periods", {})
+
             # Validate period length
-            if CONF_BEST_PRICE_MIN_PERIOD_LENGTH in user_input and not validate_period_length(
-                user_input[CONF_BEST_PRICE_MIN_PERIOD_LENGTH]
+            if CONF_BEST_PRICE_MIN_PERIOD_LENGTH in period_settings and not validate_period_length(
+                period_settings[CONF_BEST_PRICE_MIN_PERIOD_LENGTH]
             ):
                 errors[CONF_BEST_PRICE_MIN_PERIOD_LENGTH] = "invalid_period_length"
 
             # Validate flex percentage
-            if CONF_BEST_PRICE_FLEX in user_input and not validate_flex_percentage(user_input[CONF_BEST_PRICE_FLEX]):
+            if CONF_BEST_PRICE_FLEX in flexibility_settings and not validate_flex_percentage(
+                flexibility_settings[CONF_BEST_PRICE_FLEX]
+            ):
                 errors[CONF_BEST_PRICE_FLEX] = "invalid_flex"
 
             # Validate distance from average (Best Price uses negative values)
-            if CONF_BEST_PRICE_MIN_DISTANCE_FROM_AVG in user_input and not validate_best_price_distance_percentage(
-                user_input[CONF_BEST_PRICE_MIN_DISTANCE_FROM_AVG]
+            if (
+                CONF_BEST_PRICE_MIN_DISTANCE_FROM_AVG in flexibility_settings
+                and not validate_best_price_distance_percentage(
+                    flexibility_settings[CONF_BEST_PRICE_MIN_DISTANCE_FROM_AVG]
+                )
             ):
                 errors[CONF_BEST_PRICE_MIN_DISTANCE_FROM_AVG] = "invalid_best_price_distance"
 
             # Validate minimum periods count
-            if CONF_MIN_PERIODS_BEST in user_input and not validate_min_periods(user_input[CONF_MIN_PERIODS_BEST]):
+            if CONF_MIN_PERIODS_BEST in relaxation_settings and not validate_min_periods(
+                relaxation_settings[CONF_MIN_PERIODS_BEST]
+            ):
                 errors[CONF_MIN_PERIODS_BEST] = "invalid_min_periods"
 
             # Validate gap count
-            if CONF_BEST_PRICE_MAX_LEVEL_GAP_COUNT in user_input and not validate_gap_count(
-                user_input[CONF_BEST_PRICE_MAX_LEVEL_GAP_COUNT]
+            if CONF_BEST_PRICE_MAX_LEVEL_GAP_COUNT in period_settings and not validate_gap_count(
+                period_settings[CONF_BEST_PRICE_MAX_LEVEL_GAP_COUNT]
             ):
                 errors[CONF_BEST_PRICE_MAX_LEVEL_GAP_COUNT] = "invalid_gap_count"
 
             # Validate relaxation attempts
-            if CONF_RELAXATION_ATTEMPTS_BEST in user_input and not validate_relaxation_attempts(
-                user_input[CONF_RELAXATION_ATTEMPTS_BEST]
+            if CONF_RELAXATION_ATTEMPTS_BEST in relaxation_settings and not validate_relaxation_attempts(
+                relaxation_settings[CONF_RELAXATION_ATTEMPTS_BEST]
             ):
                 errors[CONF_RELAXATION_ATTEMPTS_BEST] = "invalid_relaxation_attempts"
 
             if not errors:
-                self._options.update(user_input)
-                return await self.async_step_peak_price()
+                # Merge section data into options
+                self._merge_section_data(user_input)
+                # async_create_entry automatically handles change detection and listener triggering
+                self._save_options_if_changed()
+            # Return to menu for more changes
+            return await self.async_step_init()
+
+        overrides = self._get_active_overrides()
+        placeholders = self._get_entity_warning_placeholders("best_price")
+        placeholders.update(self._get_override_warning_placeholder("best_price", overrides))
+
+        # Load translations for override warnings
+        override_translations = await self._get_override_translations()
 
         return self.async_show_form(
             step_id="best_price",
-            data_schema=get_best_price_schema(self.config_entry.options),
-            description_placeholders=self._get_step_description_placeholders("best_price"),
+            data_schema=get_best_price_schema(
+                self.config_entry.options,
+                overrides=overrides,
+                translations=override_translations,
+            ),
             errors=errors,
+            description_placeholders=placeholders,
         )
 
     async def async_step_peak_price(self, user_input: dict[str, Any] | None = None) -> ConfigFlowResult:
@@ -298,47 +659,71 @@ class TibberPricesOptionsFlowHandler(OptionsFlow):
         errors: dict[str, str] = {}
 
         if user_input is not None:
+            # Extract settings from sections
+            period_settings = user_input.get("period_settings", {})
+            flexibility_settings = user_input.get("flexibility_settings", {})
+            relaxation_settings = user_input.get("relaxation_and_target_periods", {})
+
             # Validate period length
-            if CONF_PEAK_PRICE_MIN_PERIOD_LENGTH in user_input and not validate_period_length(
-                user_input[CONF_PEAK_PRICE_MIN_PERIOD_LENGTH]
+            if CONF_PEAK_PRICE_MIN_PERIOD_LENGTH in period_settings and not validate_period_length(
+                period_settings[CONF_PEAK_PRICE_MIN_PERIOD_LENGTH]
             ):
                 errors[CONF_PEAK_PRICE_MIN_PERIOD_LENGTH] = "invalid_period_length"
 
             # Validate flex percentage (peak uses negative values)
-            if CONF_PEAK_PRICE_FLEX in user_input and not validate_flex_percentage(user_input[CONF_PEAK_PRICE_FLEX]):
+            if CONF_PEAK_PRICE_FLEX in flexibility_settings and not validate_flex_percentage(
+                flexibility_settings[CONF_PEAK_PRICE_FLEX]
+            ):
                 errors[CONF_PEAK_PRICE_FLEX] = "invalid_flex"
 
             # Validate distance from average (Peak Price uses positive values)
-            if CONF_PEAK_PRICE_MIN_DISTANCE_FROM_AVG in user_input and not validate_distance_percentage(
-                user_input[CONF_PEAK_PRICE_MIN_DISTANCE_FROM_AVG]
+            if CONF_PEAK_PRICE_MIN_DISTANCE_FROM_AVG in flexibility_settings and not validate_distance_percentage(
+                flexibility_settings[CONF_PEAK_PRICE_MIN_DISTANCE_FROM_AVG]
             ):
                 errors[CONF_PEAK_PRICE_MIN_DISTANCE_FROM_AVG] = "invalid_peak_price_distance"
 
             # Validate minimum periods count
-            if CONF_MIN_PERIODS_PEAK in user_input and not validate_min_periods(user_input[CONF_MIN_PERIODS_PEAK]):
+            if CONF_MIN_PERIODS_PEAK in relaxation_settings and not validate_min_periods(
+                relaxation_settings[CONF_MIN_PERIODS_PEAK]
+            ):
                 errors[CONF_MIN_PERIODS_PEAK] = "invalid_min_periods"
 
             # Validate gap count
-            if CONF_PEAK_PRICE_MAX_LEVEL_GAP_COUNT in user_input and not validate_gap_count(
-                user_input[CONF_PEAK_PRICE_MAX_LEVEL_GAP_COUNT]
+            if CONF_PEAK_PRICE_MAX_LEVEL_GAP_COUNT in period_settings and not validate_gap_count(
+                period_settings[CONF_PEAK_PRICE_MAX_LEVEL_GAP_COUNT]
             ):
                 errors[CONF_PEAK_PRICE_MAX_LEVEL_GAP_COUNT] = "invalid_gap_count"
 
             # Validate relaxation attempts
-            if CONF_RELAXATION_ATTEMPTS_PEAK in user_input and not validate_relaxation_attempts(
-                user_input[CONF_RELAXATION_ATTEMPTS_PEAK]
+            if CONF_RELAXATION_ATTEMPTS_PEAK in relaxation_settings and not validate_relaxation_attempts(
+                relaxation_settings[CONF_RELAXATION_ATTEMPTS_PEAK]
             ):
                 errors[CONF_RELAXATION_ATTEMPTS_PEAK] = "invalid_relaxation_attempts"
 
             if not errors:
-                self._options.update(user_input)
-                return await self.async_step_price_trend()
+                # Merge section data into options
+                self._merge_section_data(user_input)
+                # async_create_entry automatically handles change detection and listener triggering
+                self._save_options_if_changed()
+            # Return to menu for more changes
+            return await self.async_step_init()
+
+        overrides = self._get_active_overrides()
+        placeholders = self._get_entity_warning_placeholders("peak_price")
+        placeholders.update(self._get_override_warning_placeholder("peak_price", overrides))
+
+        # Load translations for override warnings
+        override_translations = await self._get_override_translations()
 
         return self.async_show_form(
             step_id="peak_price",
-            data_schema=get_peak_price_schema(self.config_entry.options),
-            description_placeholders=self._get_step_description_placeholders("peak_price"),
+            data_schema=get_peak_price_schema(
+                self.config_entry.options,
+                overrides=overrides,
+                translations=override_translations,
+            ),
             errors=errors,
+            description_placeholders=placeholders,
         )
 
     async def async_step_price_trend(self, user_input: dict[str, Any] | None = None) -> ConfigFlowResult:
@@ -346,6 +731,9 @@ class TibberPricesOptionsFlowHandler(OptionsFlow):
         errors: dict[str, str] = {}
 
         if user_input is not None:
+            # Schema is now flattened - fields come directly in user_input
+            # Store them flat in options (no nested structure)
+
             # Validate rising trend threshold
             if CONF_PRICE_TREND_THRESHOLD_RISING in user_input and not validate_price_trend_rising(
                 user_input[CONF_PRICE_TREND_THRESHOLD_RISING]
@@ -358,28 +746,93 @@ class TibberPricesOptionsFlowHandler(OptionsFlow):
             ):
                 errors[CONF_PRICE_TREND_THRESHOLD_FALLING] = "invalid_price_trend_falling"
 
+            # Validate strongly rising trend threshold
+            if CONF_PRICE_TREND_THRESHOLD_STRONGLY_RISING in user_input and not validate_price_trend_strongly_rising(
+                user_input[CONF_PRICE_TREND_THRESHOLD_STRONGLY_RISING]
+            ):
+                errors[CONF_PRICE_TREND_THRESHOLD_STRONGLY_RISING] = "invalid_price_trend_strongly_rising"
+
+            # Validate strongly falling trend threshold
+            if CONF_PRICE_TREND_THRESHOLD_STRONGLY_FALLING in user_input and not validate_price_trend_strongly_falling(
+                user_input[CONF_PRICE_TREND_THRESHOLD_STRONGLY_FALLING]
+            ):
+                errors[CONF_PRICE_TREND_THRESHOLD_STRONGLY_FALLING] = "invalid_price_trend_strongly_falling"
+
+            # Cross-validation: Ensure rising < strongly_rising and falling > strongly_falling
             if not errors:
+                rising = user_input.get(CONF_PRICE_TREND_THRESHOLD_RISING)
+                strongly_rising = user_input.get(CONF_PRICE_TREND_THRESHOLD_STRONGLY_RISING)
+                falling = user_input.get(CONF_PRICE_TREND_THRESHOLD_FALLING)
+                strongly_falling = user_input.get(CONF_PRICE_TREND_THRESHOLD_STRONGLY_FALLING)
+
+                if rising is not None and strongly_rising is not None and rising >= strongly_rising:
+                    errors[CONF_PRICE_TREND_THRESHOLD_STRONGLY_RISING] = (
+                        "invalid_trend_strongly_rising_less_than_rising"
+                    )
+                if falling is not None and strongly_falling is not None and falling <= strongly_falling:
+                    errors[CONF_PRICE_TREND_THRESHOLD_STRONGLY_FALLING] = (
+                        "invalid_trend_strongly_falling_greater_than_falling"
+                    )
+
+            if not errors:
+                # Store flat data directly in options (no section wrapping)
                 self._options.update(user_input)
-                return await self.async_step_chart_data_export()
+                # async_create_entry automatically handles change detection and listener triggering
+                self._save_options_if_changed()
+            # Return to menu for more changes
+            return await self.async_step_init()
 
         return self.async_show_form(
             step_id="price_trend",
             data_schema=get_price_trend_schema(self.config_entry.options),
-            description_placeholders=self._get_step_description_placeholders("price_trend"),
             errors=errors,
+            description_placeholders=self._get_entity_warning_placeholders("price_trend"),
         )
 
     async def async_step_chart_data_export(self, user_input: dict[str, Any] | None = None) -> ConfigFlowResult:
         """Info page for chart data export sensor."""
         if user_input is not None:
-            # No validation needed - just an info page
-            return self.async_create_entry(title="", data=self._options)
+            # No changes to save - just return to menu
+            return await self.async_step_init()
 
-        # Show info-only form (no input fields)
+        # Check if the chart data export sensor is enabled
+        is_enabled = check_chart_data_export_enabled(self.hass, self.config_entry)
+
+        # Show info-only form with status-dependent description
         return self.async_show_form(
             step_id="chart_data_export",
             data_schema=get_chart_data_export_schema(self.config_entry.options),
-            description_placeholders=self._get_step_description_placeholders("chart_data_export"),
+            description_placeholders={
+                "sensor_status_info": self._get_chart_export_status_info(is_enabled=is_enabled),
+            },
+        )
+
+    def _get_chart_export_status_info(self, *, is_enabled: bool) -> str:
+        """Get the status info block for chart data export sensor."""
+        if is_enabled:
+            return (
+                "✅ **Status: Sensor is enabled**\n\n"
+                "The Chart Data Export sensor is currently active and providing data as attributes.\n\n"
+                "**Configuration (optional):**\n\n"
+                "Default settings work out-of-the-box (today+tomorrow, 15-minute intervals, prices only).\n\n"
+                "For customization, add to **`configuration.yaml`**:\n\n"
+                "```yaml\n"
+                "tibber_prices:\n"
+                "  chart_export:\n"
+                "    day:\n"
+                "      - today\n"
+                "      - tomorrow\n"
+                "    include_level: true\n"
+                "    include_rating_level: true\n"
+                "```\n\n"
+                "**All parameters:** See `tibber_prices.get_chartdata` service documentation"
+            )
+        return (
+            "❌ **Status: Sensor is disabled**\n\n"
+            "**Enable the sensor:**\n\n"
+            "1. Open **Settings → Devices & Services → Tibber Prices**\n"
+            "2. Select your home → Find **'Chart Data Export'** (Diagnostic section)\n"
+            "3. **Enable the sensor** (disabled by default)"
         )
 
     async def async_step_volatility(self, user_input: dict[str, Any] | None = None) -> ConfigFlowResult:
@@ -387,6 +840,8 @@ class TibberPricesOptionsFlowHandler(OptionsFlow):
         errors: dict[str, str] = {}
 
         if user_input is not None:
+            # Schema is now flattened - fields come directly in user_input
+
             # Validate moderate volatility threshold
             if CONF_VOLATILITY_THRESHOLD_MODERATE in user_input and not validate_volatility_threshold_moderate(
                 user_input[CONF_VOLATILITY_THRESHOLD_MODERATE]
@@ -407,30 +862,34 @@ class TibberPricesOptionsFlowHandler(OptionsFlow):
 
             # Cross-validation: Ensure MODERATE < HIGH < VERY_HIGH
             if not errors:
-                existing_options = self.config_entry.options
+                # Get current values directly from options (now flat)
                 moderate = user_input.get(
                     CONF_VOLATILITY_THRESHOLD_MODERATE,
-                    existing_options.get(CONF_VOLATILITY_THRESHOLD_MODERATE, DEFAULT_VOLATILITY_THRESHOLD_MODERATE),
+                    self._options.get(CONF_VOLATILITY_THRESHOLD_MODERATE, DEFAULT_VOLATILITY_THRESHOLD_MODERATE),
                 )
                 high = user_input.get(
                     CONF_VOLATILITY_THRESHOLD_HIGH,
-                    existing_options.get(CONF_VOLATILITY_THRESHOLD_HIGH, DEFAULT_VOLATILITY_THRESHOLD_HIGH),
+                    self._options.get(CONF_VOLATILITY_THRESHOLD_HIGH, DEFAULT_VOLATILITY_THRESHOLD_HIGH),
                 )
                 very_high = user_input.get(
                     CONF_VOLATILITY_THRESHOLD_VERY_HIGH,
-                    existing_options.get(CONF_VOLATILITY_THRESHOLD_VERY_HIGH, DEFAULT_VOLATILITY_THRESHOLD_VERY_HIGH),
+                    self._options.get(CONF_VOLATILITY_THRESHOLD_VERY_HIGH, DEFAULT_VOLATILITY_THRESHOLD_VERY_HIGH),
                 )
 
                 if not validate_volatility_thresholds(moderate, high, very_high):
                     errors["base"] = "invalid_volatility_thresholds"
 
             if not errors:
+                # Store flat data directly in options (no section wrapping)
                 self._options.update(user_input)
-                return await self.async_step_best_price()
+                # async_create_entry automatically handles change detection and listener triggering
+                self._save_options_if_changed()
+            # Return to menu for more changes
+            return await self.async_step_init()
 
         return self.async_show_form(
             step_id="volatility",
             data_schema=get_volatility_schema(self.config_entry.options),
-            description_placeholders=self._get_step_description_placeholders("volatility"),
             errors=errors,
+            description_placeholders=self._get_entity_warning_placeholders("volatility"),
         )

custom_components/tibber_prices/config_flow_handlers/schemas.py

@@ -28,10 +28,15 @@ from custom_components.tibber_prices.const import (
     CONF_PEAK_PRICE_MIN_DISTANCE_FROM_AVG,
     CONF_PEAK_PRICE_MIN_LEVEL,
     CONF_PEAK_PRICE_MIN_PERIOD_LENGTH,
+    CONF_PRICE_LEVEL_GAP_TOLERANCE,
+    CONF_PRICE_RATING_GAP_TOLERANCE,
+    CONF_PRICE_RATING_HYSTERESIS,
     CONF_PRICE_RATING_THRESHOLD_HIGH,
     CONF_PRICE_RATING_THRESHOLD_LOW,
     CONF_PRICE_TREND_THRESHOLD_FALLING,
     CONF_PRICE_TREND_THRESHOLD_RISING,
+    CONF_PRICE_TREND_THRESHOLD_STRONGLY_FALLING,
+    CONF_PRICE_TREND_THRESHOLD_STRONGLY_RISING,
     CONF_RELAXATION_ATTEMPTS_BEST,
     CONF_RELAXATION_ATTEMPTS_PEAK,
     CONF_VIRTUAL_TIME_OFFSET_DAYS,
@@ -56,10 +61,15 @@ from custom_components.tibber_prices.const import (
     DEFAULT_PEAK_PRICE_MIN_DISTANCE_FROM_AVG,
     DEFAULT_PEAK_PRICE_MIN_LEVEL,
     DEFAULT_PEAK_PRICE_MIN_PERIOD_LENGTH,
+    DEFAULT_PRICE_LEVEL_GAP_TOLERANCE,
+    DEFAULT_PRICE_RATING_GAP_TOLERANCE,
+    DEFAULT_PRICE_RATING_HYSTERESIS,
     DEFAULT_PRICE_RATING_THRESHOLD_HIGH,
     DEFAULT_PRICE_RATING_THRESHOLD_LOW,
     DEFAULT_PRICE_TREND_THRESHOLD_FALLING,
     DEFAULT_PRICE_TREND_THRESHOLD_RISING,
+    DEFAULT_PRICE_TREND_THRESHOLD_STRONGLY_FALLING,
+    DEFAULT_PRICE_TREND_THRESHOLD_STRONGLY_RISING,
     DEFAULT_RELAXATION_ATTEMPTS_BEST,
     DEFAULT_RELAXATION_ATTEMPTS_PEAK,
     DEFAULT_VIRTUAL_TIME_OFFSET_DAYS,
@@ -73,20 +83,30 @@ from custom_components.tibber_prices.const import (
     MAX_GAP_COUNT,
     MAX_MIN_PERIOD_LENGTH,
     MAX_MIN_PERIODS,
+    MAX_PRICE_LEVEL_GAP_TOLERANCE,
+    MAX_PRICE_RATING_GAP_TOLERANCE,
+    MAX_PRICE_RATING_HYSTERESIS,
     MAX_PRICE_RATING_THRESHOLD_HIGH,
     MAX_PRICE_RATING_THRESHOLD_LOW,
     MAX_PRICE_TREND_FALLING,
     MAX_PRICE_TREND_RISING,
+    MAX_PRICE_TREND_STRONGLY_FALLING,
+    MAX_PRICE_TREND_STRONGLY_RISING,
     MAX_RELAXATION_ATTEMPTS,
     MAX_VOLATILITY_THRESHOLD_HIGH,
     MAX_VOLATILITY_THRESHOLD_MODERATE,
     MAX_VOLATILITY_THRESHOLD_VERY_HIGH,
     MIN_GAP_COUNT,
     MIN_PERIOD_LENGTH,
+    MIN_PRICE_LEVEL_GAP_TOLERANCE,
+    MIN_PRICE_RATING_GAP_TOLERANCE,
+    MIN_PRICE_RATING_HYSTERESIS,
     MIN_PRICE_RATING_THRESHOLD_HIGH,
     MIN_PRICE_RATING_THRESHOLD_LOW,
     MIN_PRICE_TREND_FALLING,
     MIN_PRICE_TREND_RISING,
+    MIN_PRICE_TREND_STRONGLY_FALLING,
+    MIN_PRICE_TREND_STRONGLY_RISING,
     MIN_RELAXATION_ATTEMPTS,
     MIN_VOLATILITY_THRESHOLD_HIGH,
     MIN_VOLATILITY_THRESHOLD_MODERATE,
@@ -96,8 +116,11 @@ from custom_components.tibber_prices.const import (
 )
 from homeassistant.const import CONF_ACCESS_TOKEN
 from homeassistant.data_entry_flow import section
+from homeassistant.helpers import selector
 from homeassistant.helpers.selector import (
     BooleanSelector,
+    ConstantSelector,
+    ConstantSelectorConfig,
     NumberSelector,
     NumberSelectorConfig,
     NumberSelectorMode,
@@ -110,6 +133,155 @@ from homeassistant.helpers.selector import (
     TextSelectorType,
 )
 
+# Type alias for config override structure: {section: {config_key: value}}
+ConfigOverrides = dict[str, dict[str, Any]]
+
+
+def is_field_overridden(
+    config_key: str,
+    config_section: str,  # noqa: ARG001 - kept for API compatibility
+    overrides: ConfigOverrides | None,
+) -> bool:
+    """
+    Check if a config field has an active runtime override.
+
+    Args:
+        config_key: The configuration key to check (e.g., "best_price_flex")
+        config_section: Unused, kept for API compatibility
+        overrides: Dictionary of active overrides (with "_enabled" key)
+
+    Returns:
+        True if this field is being overridden by a config entity, False otherwise
+
+    """
+    if overrides is None:
+        return False
+    # Check if key is in the _enabled section (from entity registry check)
+    return config_key in overrides.get("_enabled", {})
+
+
+# Override translations structure from common section
+# This will be loaded at runtime and passed to schema functions
+OverrideTranslations = dict[str, Any]  # Type alias
+
+# Fallback labels when translations not available
+# Used only as fallback - translations should be loaded from common.override_field_labels
+DEFAULT_FIELD_LABELS: dict[str, str] = {
+    # Best Price
+    CONF_BEST_PRICE_MIN_PERIOD_LENGTH: "Minimum Period Length",
+    CONF_BEST_PRICE_MAX_LEVEL_GAP_COUNT: "Gap Tolerance",
+    CONF_BEST_PRICE_FLEX: "Flexibility",
+    CONF_BEST_PRICE_MIN_DISTANCE_FROM_AVG: "Minimum Distance",
+    CONF_ENABLE_MIN_PERIODS_BEST: "Achieve Minimum Count",
+    CONF_MIN_PERIODS_BEST: "Minimum Periods",
+    CONF_RELAXATION_ATTEMPTS_BEST: "Relaxation Attempts",
+    # Peak Price
+    CONF_PEAK_PRICE_MIN_PERIOD_LENGTH: "Minimum Period Length",
+    CONF_PEAK_PRICE_MAX_LEVEL_GAP_COUNT: "Gap Tolerance",
+    CONF_PEAK_PRICE_FLEX: "Flexibility",
+    CONF_PEAK_PRICE_MIN_DISTANCE_FROM_AVG: "Minimum Distance",
+    CONF_ENABLE_MIN_PERIODS_PEAK: "Achieve Minimum Count",
+    CONF_MIN_PERIODS_PEAK: "Minimum Periods",
+    CONF_RELAXATION_ATTEMPTS_PEAK: "Relaxation Attempts",
+}
+
+# Section to config keys mapping for override detection
+SECTION_CONFIG_KEYS: dict[str, dict[str, list[str]]] = {
+    "best_price": {
+        "period_settings": [
+            CONF_BEST_PRICE_MIN_PERIOD_LENGTH,
+            CONF_BEST_PRICE_MAX_LEVEL_GAP_COUNT,
+        ],
+        "flexibility_settings": [
+            CONF_BEST_PRICE_FLEX,
+            CONF_BEST_PRICE_MIN_DISTANCE_FROM_AVG,
+        ],
+        "relaxation_and_target_periods": [
+            CONF_ENABLE_MIN_PERIODS_BEST,
+            CONF_MIN_PERIODS_BEST,
+            CONF_RELAXATION_ATTEMPTS_BEST,
+        ],
+    },
+    "peak_price": {
+        "period_settings": [
+            CONF_PEAK_PRICE_MIN_PERIOD_LENGTH,
+            CONF_PEAK_PRICE_MAX_LEVEL_GAP_COUNT,
+        ],
+        "flexibility_settings": [
+            CONF_PEAK_PRICE_FLEX,
+            CONF_PEAK_PRICE_MIN_DISTANCE_FROM_AVG,
+        ],
+        "relaxation_and_target_periods": [
+            CONF_ENABLE_MIN_PERIODS_PEAK,
+            CONF_MIN_PERIODS_PEAK,
+            CONF_RELAXATION_ATTEMPTS_PEAK,
+        ],
+    },
+}
+
+
+def get_section_override_warning(
+    step_id: str,
+    section_id: str,
+    overrides: ConfigOverrides | None,
+    translations: OverrideTranslations | None = None,
+) -> dict[vol.Optional, ConstantSelector] | None:
+    """
+    Return a warning constant selector if any fields in the section are overridden.
+
+    Args:
+        step_id: The step ID (best_price or peak_price)
+        section_id: The section ID within the step
+        overrides: Active runtime overrides from coordinator
+        translations: Override translations from common section (optional)
+
+    Returns:
+        Dict with override warning selector if any fields overridden, None otherwise
+
+    """
+    if not overrides:
+        return None
+
+    section_keys = SECTION_CONFIG_KEYS.get(step_id, {}).get(section_id, [])
+    overridden_fields = []
+
+    for config_key in section_keys:
+        if is_field_overridden(config_key, section_id, overrides):
+            # Try to get translated label from flat keys, fallback to DEFAULT_FIELD_LABELS
+            translation_key = f"override_field_label_{config_key}"
+            label = (translations.get(translation_key) if translations else None) or DEFAULT_FIELD_LABELS.get(
+                config_key, config_key
+            )
+            overridden_fields.append(label)
+
+    if not overridden_fields:
+        return None
+
+    # Get translated "and" connector or use fallback
+    and_connector = " and "
+    if translations and "override_warning_and" in translations:
+        and_connector = f" {translations['override_warning_and']} "
+
+    # Build warning message with list of overridden fields
+    if len(overridden_fields) == 1:
+        fields_text = overridden_fields[0]
+    else:
+        fields_text = ", ".join(overridden_fields[:-1]) + and_connector + overridden_fields[-1]
+
+    # Get translated warning template or use fallback
+    warning_template = "⚠️ {fields} controlled by config entity"
+    if translations and "override_warning_template" in translations:
+        warning_template = translations["override_warning_template"]
+
+    return {
+        vol.Optional("_override_warning"): ConstantSelector(
+            ConstantSelectorConfig(
+                value=True,
+                label=warning_template.format(fields=fields_text),
+            )
+        ),
+    }
+
 
 def get_user_schema(access_token: str | None = None) -> vol.Schema:
     """Return schema for user step (API token input)."""
@@ -256,11 +428,8 @@ def get_display_settings_schema(options: Mapping[str, Any], currency_code: str |
 
 
 def get_price_rating_schema(options: Mapping[str, Any]) -> vol.Schema:
-    """Return schema for price rating thresholds configuration."""
+    """Return schema for price rating configuration (thresholds and stabilization)."""
     return vol.Schema(
-        {
-            vol.Required("price_rating_thresholds"): section(
-                vol.Schema(
         {
             vol.Optional(
                 CONF_PRICE_RATING_THRESHOLD_LOW,
@@ -296,20 +465,70 @@ def get_price_rating_schema(options: Mapping[str, Any]) -> vol.Schema:
                     mode=NumberSelectorMode.SLIDER,
                 ),
             ),
-                    }
+            vol.Optional(
+                CONF_PRICE_RATING_HYSTERESIS,
+                default=float(
+                    options.get(
+                        CONF_PRICE_RATING_HYSTERESIS,
+                        DEFAULT_PRICE_RATING_HYSTERESIS,
+                    )
+                ),
+            ): NumberSelector(
+                NumberSelectorConfig(
+                    min=MIN_PRICE_RATING_HYSTERESIS,
+                    max=MAX_PRICE_RATING_HYSTERESIS,
+                    unit_of_measurement="%",
+                    step=0.5,
+                    mode=NumberSelectorMode.SLIDER,
+                ),
+            ),
+            vol.Optional(
+                CONF_PRICE_RATING_GAP_TOLERANCE,
+                default=int(
+                    options.get(
+                        CONF_PRICE_RATING_GAP_TOLERANCE,
+                        DEFAULT_PRICE_RATING_GAP_TOLERANCE,
+                    )
+                ),
+            ): NumberSelector(
+                NumberSelectorConfig(
+                    min=MIN_PRICE_RATING_GAP_TOLERANCE,
+                    max=MAX_PRICE_RATING_GAP_TOLERANCE,
+                    step=1,
+                    mode=NumberSelectorMode.SLIDER,
+                ),
+            ),
+        }
+    )
+
+
+def get_price_level_schema(options: Mapping[str, Any]) -> vol.Schema:
+    """Return schema for Tibber price level stabilization (gap tolerance for API level field)."""
+    return vol.Schema(
+        {
+            vol.Optional(
+                CONF_PRICE_LEVEL_GAP_TOLERANCE,
+                default=int(
+                    options.get(
+                        CONF_PRICE_LEVEL_GAP_TOLERANCE,
+                        DEFAULT_PRICE_LEVEL_GAP_TOLERANCE,
+                    )
+                ),
+            ): NumberSelector(
+                NumberSelectorConfig(
+                    min=MIN_PRICE_LEVEL_GAP_TOLERANCE,
+                    max=MAX_PRICE_LEVEL_GAP_TOLERANCE,
+                    step=1,
+                    mode=NumberSelectorMode.SLIDER,
                 ),
-                {"collapsed": True},
             ),
         }
     )
 
 
 def get_volatility_schema(options: Mapping[str, Any]) -> vol.Schema:
-    """Return schema for volatility thresholds configuration with collapsible sections."""
+    """Return schema for volatility thresholds configuration."""
     return vol.Schema(
-        {
-            vol.Required("volatility_thresholds"): section(
-                vol.Schema(
         {
             vol.Optional(
                 CONF_VOLATILITY_THRESHOLD_MODERATE,
@@ -363,28 +582,53 @@ def get_volatility_schema(options: Mapping[str, Any]) -> vol.Schema:
                 ),
             ),
         }
-                ),
-                {"collapsed": True},
-            ),
-        }
     )
 
 
-def get_best_price_schema(options: Mapping[str, Any]) -> vol.Schema:
-    """Return schema for best price period configuration with collapsible sections."""
-    return vol.Schema(
-        {
-            vol.Required("period_settings"): section(
-                vol.Schema(
-                    {
+def get_best_price_schema(
+    options: Mapping[str, Any],
+    overrides: ConfigOverrides | None = None,
+    translations: OverrideTranslations | None = None,
+) -> vol.Schema:
+    """
+    Return schema for best price period configuration with collapsible sections.
+
+    Args:
+        options: Current options from config entry
+        overrides: Active runtime overrides from coordinator. Fields with active
+                   overrides will be replaced with a constant placeholder.
+        translations: Override translations from common section (optional)
+
+    Returns:
+        Voluptuous schema for the best price configuration form
+
+    """
+    period_settings = options.get("period_settings", {})
+    flexibility_settings = options.get("flexibility_settings", {})
+    relaxation_settings = options.get("relaxation_and_target_periods", {})
+
+    # Get current values for override display
+    min_period_length = int(
+        period_settings.get(CONF_BEST_PRICE_MIN_PERIOD_LENGTH, DEFAULT_BEST_PRICE_MIN_PERIOD_LENGTH)
+    )
+    max_level_gap_count = int(
+        period_settings.get(CONF_BEST_PRICE_MAX_LEVEL_GAP_COUNT, DEFAULT_BEST_PRICE_MAX_LEVEL_GAP_COUNT)
+    )
+    best_price_flex = int(flexibility_settings.get(CONF_BEST_PRICE_FLEX, DEFAULT_BEST_PRICE_FLEX))
+    min_distance = int(
+        flexibility_settings.get(CONF_BEST_PRICE_MIN_DISTANCE_FROM_AVG, DEFAULT_BEST_PRICE_MIN_DISTANCE_FROM_AVG)
+    )
+    enable_min_periods = relaxation_settings.get(CONF_ENABLE_MIN_PERIODS_BEST, DEFAULT_ENABLE_MIN_PERIODS_BEST)
+    min_periods = int(relaxation_settings.get(CONF_MIN_PERIODS_BEST, DEFAULT_MIN_PERIODS_BEST))
+    relaxation_attempts = int(relaxation_settings.get(CONF_RELAXATION_ATTEMPTS_BEST, DEFAULT_RELAXATION_ATTEMPTS_BEST))
+
+    # Build section schemas with optional override warnings
+    period_warning = get_section_override_warning("best_price", "period_settings", overrides, translations) or {}
+    period_fields: dict[vol.Optional | vol.Required, Any] = {
+        **period_warning,  # type: ignore[misc]
         vol.Optional(
             CONF_BEST_PRICE_MIN_PERIOD_LENGTH,
-                            default=int(
-                                options.get(
-                                    CONF_BEST_PRICE_MIN_PERIOD_LENGTH,
-                                    DEFAULT_BEST_PRICE_MIN_PERIOD_LENGTH,
-                                )
-                            ),
+            default=min_period_length,
         ): NumberSelector(
             NumberSelectorConfig(
                 min=MIN_PERIOD_LENGTH,
@@ -392,11 +636,11 @@ def get_best_price_schema(options: Mapping[str, Any]) -> vol.Schema:
                 step=15,
                 unit_of_measurement="min",
                 mode=NumberSelectorMode.SLIDER,
-                            ),
+            )
         ),
         vol.Optional(
             CONF_BEST_PRICE_MAX_LEVEL,
-                            default=options.get(
+            default=period_settings.get(
                 CONF_BEST_PRICE_MAX_LEVEL,
                 DEFAULT_BEST_PRICE_MAX_LEVEL,
             ),
@@ -409,35 +653,25 @@ def get_best_price_schema(options: Mapping[str, Any]) -> vol.Schema:
         ),
         vol.Optional(
             CONF_BEST_PRICE_MAX_LEVEL_GAP_COUNT,
-                            default=int(
-                                options.get(
-                                    CONF_BEST_PRICE_MAX_LEVEL_GAP_COUNT,
-                                    DEFAULT_BEST_PRICE_MAX_LEVEL_GAP_COUNT,
-                                )
-                            ),
+            default=max_level_gap_count,
         ): NumberSelector(
             NumberSelectorConfig(
                 min=MIN_GAP_COUNT,
                 max=MAX_GAP_COUNT,
                 step=1,
                 mode=NumberSelectorMode.SLIDER,
-                            ),
-                        ),
-                    }
-                ),
-                {"collapsed": True},
-            ),
-            vol.Required("flexibility_settings"): section(
-                vol.Schema(
-                    {
-                        vol.Optional(
-                            CONF_BEST_PRICE_FLEX,
-                            default=int(
-                                options.get(
-                                    CONF_BEST_PRICE_FLEX,
-                                    DEFAULT_BEST_PRICE_FLEX,
             )
         ),
+    }
+
+    flexibility_warning = (
+        get_section_override_warning("best_price", "flexibility_settings", overrides, translations) or {}
+    )
+    flexibility_fields: dict[vol.Optional | vol.Required, Any] = {
+        **flexibility_warning,  # type: ignore[misc]
+        vol.Optional(
+            CONF_BEST_PRICE_FLEX,
+            default=best_price_flex,
         ): NumberSelector(
             NumberSelectorConfig(
                 min=0,
@@ -445,16 +679,11 @@ def get_best_price_schema(options: Mapping[str, Any]) -> vol.Schema:
                 step=1,
                 unit_of_measurement="%",
                 mode=NumberSelectorMode.SLIDER,
-                            ),
+            )
         ),
         vol.Optional(
             CONF_BEST_PRICE_MIN_DISTANCE_FROM_AVG,
-                            default=int(
-                                options.get(
-                                    CONF_BEST_PRICE_MIN_DISTANCE_FROM_AVG,
-                                    DEFAULT_BEST_PRICE_MIN_DISTANCE_FROM_AVG,
-                                )
-                            ),
+            default=min_distance,
         ): NumberSelector(
             NumberSelectorConfig(
                 min=-50,
@@ -462,77 +691,105 @@ def get_best_price_schema(options: Mapping[str, Any]) -> vol.Schema:
                 step=1,
                 unit_of_measurement="%",
                 mode=NumberSelectorMode.SLIDER,
-                            ),
-                        ),
-                    }
-                ),
-                {"collapsed": True},
-            ),
-            vol.Required("relaxation_and_target_periods"): section(
-                vol.Schema(
-                    {
-                        vol.Optional(
-                            CONF_ENABLE_MIN_PERIODS_BEST,
-                            default=options.get(
-                                CONF_ENABLE_MIN_PERIODS_BEST,
-                                DEFAULT_ENABLE_MIN_PERIODS_BEST,
-                            ),
-                        ): BooleanSelector(),
-                        vol.Optional(
-                            CONF_MIN_PERIODS_BEST,
-                            default=int(
-                                options.get(
-                                    CONF_MIN_PERIODS_BEST,
-                                    DEFAULT_MIN_PERIODS_BEST,
             )
         ),
+    }
+
+    relaxation_warning = (
+        get_section_override_warning("best_price", "relaxation_and_target_periods", overrides, translations) or {}
+    )
+    relaxation_fields: dict[vol.Optional | vol.Required, Any] = {
+        **relaxation_warning,  # type: ignore[misc]
+        vol.Optional(
+            CONF_ENABLE_MIN_PERIODS_BEST,
+            default=enable_min_periods,
+        ): BooleanSelector(selector.BooleanSelectorConfig()),
+        vol.Optional(
+            CONF_MIN_PERIODS_BEST,
+            default=min_periods,
         ): NumberSelector(
             NumberSelectorConfig(
                 min=1,
                 max=MAX_MIN_PERIODS,
                 step=1,
                 mode=NumberSelectorMode.SLIDER,
-                            ),
+            )
         ),
         vol.Optional(
             CONF_RELAXATION_ATTEMPTS_BEST,
-                            default=int(
-                                options.get(
-                                    CONF_RELAXATION_ATTEMPTS_BEST,
-                                    DEFAULT_RELAXATION_ATTEMPTS_BEST,
-                                )
-                            ),
+            default=relaxation_attempts,
         ): NumberSelector(
             NumberSelectorConfig(
                 min=MIN_RELAXATION_ATTEMPTS,
                 max=MAX_RELAXATION_ATTEMPTS,
                 step=1,
                 mode=NumberSelectorMode.SLIDER,
-                            ),
+            )
         ),
     }
+
+    return vol.Schema(
+        {
+            vol.Required("period_settings"): section(
+                vol.Schema(period_fields),
+                {"collapsed": False},
             ),
+            vol.Required("flexibility_settings"): section(
+                vol.Schema(flexibility_fields),
+                {"collapsed": True},
+            ),
+            vol.Required("relaxation_and_target_periods"): section(
+                vol.Schema(relaxation_fields),
                 {"collapsed": True},
             ),
         }
     )
 
 
-def get_peak_price_schema(options: Mapping[str, Any]) -> vol.Schema:
-    """Return schema for peak price period configuration with collapsible sections."""
-    return vol.Schema(
-        {
-            vol.Required("period_settings"): section(
-                vol.Schema(
-                    {
+def get_peak_price_schema(
+    options: Mapping[str, Any],
+    overrides: ConfigOverrides | None = None,
+    translations: OverrideTranslations | None = None,
+) -> vol.Schema:
+    """
+    Return schema for peak price period configuration with collapsible sections.
+
+    Args:
+        options: Current options from config entry
+        overrides: Active runtime overrides from coordinator. Fields with active
+                   overrides will be replaced with a constant placeholder.
+        translations: Override translations from common section (optional)
+
+    Returns:
+        Voluptuous schema for the peak price configuration form
+
+    """
+    period_settings = options.get("period_settings", {})
+    flexibility_settings = options.get("flexibility_settings", {})
+    relaxation_settings = options.get("relaxation_and_target_periods", {})
+
+    # Get current values for override display
+    min_period_length = int(
+        period_settings.get(CONF_PEAK_PRICE_MIN_PERIOD_LENGTH, DEFAULT_PEAK_PRICE_MIN_PERIOD_LENGTH)
+    )
+    max_level_gap_count = int(
+        period_settings.get(CONF_PEAK_PRICE_MAX_LEVEL_GAP_COUNT, DEFAULT_PEAK_PRICE_MAX_LEVEL_GAP_COUNT)
+    )
+    peak_price_flex = int(flexibility_settings.get(CONF_PEAK_PRICE_FLEX, DEFAULT_PEAK_PRICE_FLEX))
+    min_distance = int(
+        flexibility_settings.get(CONF_PEAK_PRICE_MIN_DISTANCE_FROM_AVG, DEFAULT_PEAK_PRICE_MIN_DISTANCE_FROM_AVG)
+    )
+    enable_min_periods = relaxation_settings.get(CONF_ENABLE_MIN_PERIODS_PEAK, DEFAULT_ENABLE_MIN_PERIODS_PEAK)
+    min_periods = int(relaxation_settings.get(CONF_MIN_PERIODS_PEAK, DEFAULT_MIN_PERIODS_PEAK))
+    relaxation_attempts = int(relaxation_settings.get(CONF_RELAXATION_ATTEMPTS_PEAK, DEFAULT_RELAXATION_ATTEMPTS_PEAK))
+
+    # Build section schemas with optional override warnings
+    period_warning = get_section_override_warning("peak_price", "period_settings", overrides, translations) or {}
+    period_fields: dict[vol.Optional | vol.Required, Any] = {
+        **period_warning,  # type: ignore[misc]
         vol.Optional(
             CONF_PEAK_PRICE_MIN_PERIOD_LENGTH,
-                            default=int(
-                                options.get(
-                                    CONF_PEAK_PRICE_MIN_PERIOD_LENGTH,
-                                    DEFAULT_PEAK_PRICE_MIN_PERIOD_LENGTH,
-                                )
-                            ),
+            default=min_period_length,
         ): NumberSelector(
             NumberSelectorConfig(
                 min=MIN_PERIOD_LENGTH,
@@ -540,11 +797,11 @@ def get_peak_price_schema(options: Mapping[str, Any]) -> vol.Schema:
                 step=15,
                 unit_of_measurement="min",
                 mode=NumberSelectorMode.SLIDER,
-                            ),
+            )
         ),
         vol.Optional(
             CONF_PEAK_PRICE_MIN_LEVEL,
-                            default=options.get(
+            default=period_settings.get(
                 CONF_PEAK_PRICE_MIN_LEVEL,
                 DEFAULT_PEAK_PRICE_MIN_LEVEL,
             ),
@@ -557,35 +814,25 @@ def get_peak_price_schema(options: Mapping[str, Any]) -> vol.Schema:
         ),
         vol.Optional(
             CONF_PEAK_PRICE_MAX_LEVEL_GAP_COUNT,
-                            default=int(
-                                options.get(
-                                    CONF_PEAK_PRICE_MAX_LEVEL_GAP_COUNT,
-                                    DEFAULT_PEAK_PRICE_MAX_LEVEL_GAP_COUNT,
-                                )
-                            ),
+            default=max_level_gap_count,
         ): NumberSelector(
             NumberSelectorConfig(
                 min=MIN_GAP_COUNT,
                 max=MAX_GAP_COUNT,
                 step=1,
                 mode=NumberSelectorMode.SLIDER,
-                            ),
-                        ),
-                    }
-                ),
-                {"collapsed": True},
-            ),
-            vol.Required("flexibility_settings"): section(
-                vol.Schema(
-                    {
-                        vol.Optional(
-                            CONF_PEAK_PRICE_FLEX,
-                            default=int(
-                                options.get(
-                                    CONF_PEAK_PRICE_FLEX,
-                                    DEFAULT_PEAK_PRICE_FLEX,
             )
         ),
+    }
+
+    flexibility_warning = (
+        get_section_override_warning("peak_price", "flexibility_settings", overrides, translations) or {}
+    )
+    flexibility_fields: dict[vol.Optional | vol.Required, Any] = {
+        **flexibility_warning,  # type: ignore[misc]
+        vol.Optional(
+            CONF_PEAK_PRICE_FLEX,
+            default=peak_price_flex,
         ): NumberSelector(
             NumberSelectorConfig(
                 min=-50,
@@ -593,16 +840,11 @@ def get_peak_price_schema(options: Mapping[str, Any]) -> vol.Schema:
                 step=1,
                 unit_of_measurement="%",
                 mode=NumberSelectorMode.SLIDER,
-                            ),
+            )
         ),
         vol.Optional(
             CONF_PEAK_PRICE_MIN_DISTANCE_FROM_AVG,
-                            default=int(
-                                options.get(
-                                    CONF_PEAK_PRICE_MIN_DISTANCE_FROM_AVG,
-                                    DEFAULT_PEAK_PRICE_MIN_DISTANCE_FROM_AVG,
-                                )
-                            ),
+            default=min_distance,
         ): NumberSelector(
             NumberSelectorConfig(
                 min=0,
@@ -610,56 +852,55 @@ def get_peak_price_schema(options: Mapping[str, Any]) -> vol.Schema:
                 step=1,
                 unit_of_measurement="%",
                 mode=NumberSelectorMode.SLIDER,
-                            ),
-                        ),
-                    }
-                ),
-                {"collapsed": True},
-            ),
-            vol.Required("relaxation_and_target_periods"): section(
-                vol.Schema(
-                    {
-                        vol.Optional(
-                            CONF_ENABLE_MIN_PERIODS_PEAK,
-                            default=options.get(
-                                CONF_ENABLE_MIN_PERIODS_PEAK,
-                                DEFAULT_ENABLE_MIN_PERIODS_PEAK,
-                            ),
-                        ): BooleanSelector(),
-                        vol.Optional(
-                            CONF_MIN_PERIODS_PEAK,
-                            default=int(
-                                options.get(
-                                    CONF_MIN_PERIODS_PEAK,
-                                    DEFAULT_MIN_PERIODS_PEAK,
             )
         ),
+    }
+
+    relaxation_warning = (
+        get_section_override_warning("peak_price", "relaxation_and_target_periods", overrides, translations) or {}
+    )
+    relaxation_fields: dict[vol.Optional | vol.Required, Any] = {
+        **relaxation_warning,  # type: ignore[misc]
+        vol.Optional(
+            CONF_ENABLE_MIN_PERIODS_PEAK,
+            default=enable_min_periods,
+        ): BooleanSelector(selector.BooleanSelectorConfig()),
+        vol.Optional(
+            CONF_MIN_PERIODS_PEAK,
+            default=min_periods,
         ): NumberSelector(
             NumberSelectorConfig(
                 min=1,
                 max=MAX_MIN_PERIODS,
                 step=1,
                 mode=NumberSelectorMode.SLIDER,
-                            ),
+            )
         ),
         vol.Optional(
             CONF_RELAXATION_ATTEMPTS_PEAK,
-                            default=int(
-                                options.get(
-                                    CONF_RELAXATION_ATTEMPTS_PEAK,
-                                    DEFAULT_RELAXATION_ATTEMPTS_PEAK,
-                                )
-                            ),
+            default=relaxation_attempts,
         ): NumberSelector(
             NumberSelectorConfig(
                 min=MIN_RELAXATION_ATTEMPTS,
                 max=MAX_RELAXATION_ATTEMPTS,
                 step=1,
                 mode=NumberSelectorMode.SLIDER,
-                            ),
+            )
         ),
     }
+
+    return vol.Schema(
+        {
+            vol.Required("period_settings"): section(
+                vol.Schema(period_fields),
+                {"collapsed": False},
             ),
+            vol.Required("flexibility_settings"): section(
+                vol.Schema(flexibility_fields),
+                {"collapsed": True},
+            ),
+            vol.Required("relaxation_and_target_periods"): section(
+                vol.Schema(relaxation_fields),
                 {"collapsed": True},
             ),
         }
@@ -669,9 +910,6 @@ def get_peak_price_schema(options: Mapping[str, Any]) -> vol.Schema:
 def get_price_trend_schema(options: Mapping[str, Any]) -> vol.Schema:
     """Return schema for price trend thresholds configuration."""
     return vol.Schema(
-        {
-            vol.Required("price_trend_thresholds"): section(
-                vol.Schema(
         {
             vol.Optional(
                 CONF_PRICE_TREND_THRESHOLD_RISING,
@@ -690,6 +928,23 @@ def get_price_trend_schema(options: Mapping[str, Any]) -> vol.Schema:
                     mode=NumberSelectorMode.SLIDER,
                 ),
             ),
+            vol.Optional(
+                CONF_PRICE_TREND_THRESHOLD_STRONGLY_RISING,
+                default=int(
+                    options.get(
+                        CONF_PRICE_TREND_THRESHOLD_STRONGLY_RISING,
+                        DEFAULT_PRICE_TREND_THRESHOLD_STRONGLY_RISING,
+                    )
+                ),
+            ): NumberSelector(
+                NumberSelectorConfig(
+                    min=MIN_PRICE_TREND_STRONGLY_RISING,
+                    max=MAX_PRICE_TREND_STRONGLY_RISING,
+                    step=1,
+                    unit_of_measurement="%",
+                    mode=NumberSelectorMode.SLIDER,
+                ),
+            ),
             vol.Optional(
                 CONF_PRICE_TREND_THRESHOLD_FALLING,
                 default=int(
@@ -707,9 +962,22 @@ def get_price_trend_schema(options: Mapping[str, Any]) -> vol.Schema:
                     mode=NumberSelectorMode.SLIDER,
                 ),
             ),
-                    }
+            vol.Optional(
+                CONF_PRICE_TREND_THRESHOLD_STRONGLY_FALLING,
+                default=int(
+                    options.get(
+                        CONF_PRICE_TREND_THRESHOLD_STRONGLY_FALLING,
+                        DEFAULT_PRICE_TREND_THRESHOLD_STRONGLY_FALLING,
+                    )
+                ),
+            ): NumberSelector(
+                NumberSelectorConfig(
+                    min=MIN_PRICE_TREND_STRONGLY_FALLING,
+                    max=MAX_PRICE_TREND_STRONGLY_FALLING,
+                    step=1,
+                    unit_of_measurement="%",
+                    mode=NumberSelectorMode.SLIDER,
                 ),
-                {"collapsed": True},
             ),
         }
     )
@@ -719,3 +987,12 @@ def get_chart_data_export_schema(_options: Mapping[str, Any]) -> vol.Schema:
     """Return schema for chart data export info page (no input fields)."""
     # Empty schema - this is just an info page now
     return vol.Schema({})
+
+
+def get_reset_to_defaults_schema() -> vol.Schema:
+    """Return schema for reset to defaults confirmation step."""
+    return vol.Schema(
+        {
+            vol.Required("confirm_reset", default=False): selector.BooleanSelector(),
+        }
+    )

custom_components/tibber_prices/config_flow_handlers/subentry_flow.py

@@ -125,6 +125,9 @@ class TibberPricesSubentryFlowHandler(ConfigSubentryFlow):
                 offset_desc = self._format_offset_description(offset_days, offset_hours, offset_minutes)
                 subentry_title = f"{parent_entry.title} ({offset_desc})"
 
+                # Note: Subentries inherit options from parent entry automatically
+                # Options parameter is not supported by ConfigSubentryFlow.async_create_entry()
+
                 return self.async_create_entry(
                     title=subentry_title,
                     data={

custom_components/tibber_prices/config_flow_handlers/user_flow.py

@@ -20,7 +20,12 @@ from custom_components.tibber_prices.config_flow_handlers.validators import (
     TibberPricesInvalidAuthError,
     validate_api_token,
 )
-from custom_components.tibber_prices.const import DOMAIN, LOGGER, get_translation
+from custom_components.tibber_prices.const import (
+    DOMAIN,
+    LOGGER,
+    get_default_options,
+    get_translation,
+)
 from homeassistant.config_entries import (
     ConfigEntry,
     ConfigFlow,
@@ -136,6 +141,7 @@ class TibberPricesConfigFlowHandler(ConfigFlow, domain=DOMAIN):
             step_id="reauth_confirm",
             data_schema=get_reauth_confirm_schema(),
             errors=_errors,
+            description_placeholders={"tibber_url": "https://developer.tibber.com"},
         )
 
     async def async_step_user(
@@ -286,6 +292,7 @@ class TibberPricesConfigFlowHandler(ConfigFlow, domain=DOMAIN):
             step_id="new_token",
             data_schema=get_user_schema((user_input or {}).get(CONF_ACCESS_TOKEN)),
             errors=_errors,
+            description_placeholders={"tibber_url": "https://developer.tibber.com"},
         )
 
     async def async_step_select_home(self, user_input: dict | None = None) -> ConfigFlowResult:  # noqa: PLR0911
@@ -379,6 +386,16 @@ class TibberPricesConfigFlowHandler(ConfigFlow, domain=DOMAIN):
                 "user_login": self._user_login or "N/A",
             }
 
+            # Extract currency from home data for intelligent defaults
+            currency_code = None
+            if (
+                selected_home
+                and (subscription := selected_home.get("currentSubscription"))
+                and (price_info := subscription.get("priceInfo"))
+                and (current_price := price_info.get("current"))
+            ):
+                currency_code = current_price.get("currency")
+
             # Generate entry title from home address (not appNickname)
             entry_title = self._get_entry_title(selected_home)
 
@@ -386,6 +403,7 @@ class TibberPricesConfigFlowHandler(ConfigFlow, domain=DOMAIN):
                 title=entry_title,
                 data=data,
                 description=f"{self._user_login} ({self._user_id})",
+                options=get_default_options(currency_code),
             )
 
         home_options = [

custom_components/tibber_prices/config_flow_handlers/validators.py

@@ -20,6 +20,8 @@ from custom_components.tibber_prices.const import (
     MAX_PRICE_RATING_THRESHOLD_LOW,
     MAX_PRICE_TREND_FALLING,
     MAX_PRICE_TREND_RISING,
+    MAX_PRICE_TREND_STRONGLY_FALLING,
+    MAX_PRICE_TREND_STRONGLY_RISING,
     MAX_RELAXATION_ATTEMPTS,
     MAX_VOLATILITY_THRESHOLD_HIGH,
     MAX_VOLATILITY_THRESHOLD_MODERATE,
@@ -30,6 +32,8 @@ from custom_components.tibber_prices.const import (
     MIN_PRICE_RATING_THRESHOLD_LOW,
     MIN_PRICE_TREND_FALLING,
     MIN_PRICE_TREND_RISING,
+    MIN_PRICE_TREND_STRONGLY_FALLING,
+    MIN_PRICE_TREND_STRONGLY_RISING,
     MIN_RELAXATION_ATTEMPTS,
     MIN_VOLATILITY_THRESHOLD_HIGH,
     MIN_VOLATILITY_THRESHOLD_MODERATE,
@@ -337,3 +341,31 @@ def validate_price_trend_falling(threshold: int) -> bool:
 
     """
     return MIN_PRICE_TREND_FALLING <= threshold <= MAX_PRICE_TREND_FALLING
+
+
+def validate_price_trend_strongly_rising(threshold: int) -> bool:
+    """
+    Validate strongly rising price trend threshold.
+
+    Args:
+        threshold: Strongly rising trend threshold percentage (2 to 100)
+
+    Returns:
+        True if threshold is valid (MIN_PRICE_TREND_STRONGLY_RISING to MAX_PRICE_TREND_STRONGLY_RISING)
+
+    """
+    return MIN_PRICE_TREND_STRONGLY_RISING <= threshold <= MAX_PRICE_TREND_STRONGLY_RISING
+
+
+def validate_price_trend_strongly_falling(threshold: int) -> bool:
+    """
+    Validate strongly falling price trend threshold.
+
+    Args:
+        threshold: Strongly falling trend threshold percentage (-100 to -2)
+
+    Returns:
+        True if threshold is valid (MIN_PRICE_TREND_STRONGLY_FALLING to MAX_PRICE_TREND_STRONGLY_FALLING)
+
+    """
+    return MIN_PRICE_TREND_STRONGLY_FALLING <= threshold <= MAX_PRICE_TREND_STRONGLY_FALLING

custom_components/tibber_prices/const.py

@@ -44,9 +44,14 @@ CONF_BEST_PRICE_MIN_PERIOD_LENGTH = "best_price_min_period_length"
 CONF_PEAK_PRICE_MIN_PERIOD_LENGTH = "peak_price_min_period_length"
 CONF_PRICE_RATING_THRESHOLD_LOW = "price_rating_threshold_low"
 CONF_PRICE_RATING_THRESHOLD_HIGH = "price_rating_threshold_high"
+CONF_PRICE_RATING_HYSTERESIS = "price_rating_hysteresis"
+CONF_PRICE_RATING_GAP_TOLERANCE = "price_rating_gap_tolerance"
+CONF_PRICE_LEVEL_GAP_TOLERANCE = "price_level_gap_tolerance"
 CONF_AVERAGE_SENSOR_DISPLAY = "average_sensor_display"  # "median" or "mean"
 CONF_PRICE_TREND_THRESHOLD_RISING = "price_trend_threshold_rising"
 CONF_PRICE_TREND_THRESHOLD_FALLING = "price_trend_threshold_falling"
+CONF_PRICE_TREND_THRESHOLD_STRONGLY_RISING = "price_trend_threshold_strongly_rising"
+CONF_PRICE_TREND_THRESHOLD_STRONGLY_FALLING = "price_trend_threshold_strongly_falling"
 CONF_VOLATILITY_THRESHOLD_MODERATE = "volatility_threshold_moderate"
 CONF_VOLATILITY_THRESHOLD_HIGH = "volatility_threshold_high"
 CONF_VOLATILITY_THRESHOLD_VERY_HIGH = "volatility_threshold_very_high"
@@ -92,9 +97,16 @@ DEFAULT_BEST_PRICE_MIN_PERIOD_LENGTH = 60  # 60 minutes minimum period length fo
 DEFAULT_PEAK_PRICE_MIN_PERIOD_LENGTH = 30  # 30 minutes minimum period length for peak price (user-facing, minutes)
 DEFAULT_PRICE_RATING_THRESHOLD_LOW = -10  # Default rating threshold low percentage
 DEFAULT_PRICE_RATING_THRESHOLD_HIGH = 10  # Default rating threshold high percentage
+DEFAULT_PRICE_RATING_HYSTERESIS = 2.0  # Hysteresis percentage to prevent flickering at threshold boundaries
+DEFAULT_PRICE_RATING_GAP_TOLERANCE = 1  # Max consecutive intervals to smooth out (0 = disabled)
+DEFAULT_PRICE_LEVEL_GAP_TOLERANCE = 1  # Max consecutive intervals to smooth out for price level (0 = disabled)
 DEFAULT_AVERAGE_SENSOR_DISPLAY = "median"  # Default: show median in state, mean in attributes
 DEFAULT_PRICE_TREND_THRESHOLD_RISING = 3  # Default trend threshold for rising prices (%)
 DEFAULT_PRICE_TREND_THRESHOLD_FALLING = -3  # Default trend threshold for falling prices (%, negative value)
+# Strong trend thresholds default to 2x the base threshold.
+# These are independently configurable to allow fine-tuning of "strongly" detection.
+DEFAULT_PRICE_TREND_THRESHOLD_STRONGLY_RISING = 6  # Default strong rising threshold (%)
+DEFAULT_PRICE_TREND_THRESHOLD_STRONGLY_FALLING = -6  # Default strong falling threshold (%, negative value)
 # Default volatility thresholds (relative values using coefficient of variation)
 # Coefficient of variation = (standard_deviation / mean) * 100%
 # These thresholds are unitless and work across different price levels
@@ -131,6 +143,12 @@ MIN_PRICE_RATING_THRESHOLD_LOW = -50  # Minimum value for low rating threshold
 MAX_PRICE_RATING_THRESHOLD_LOW = -5  # Maximum value for low rating threshold (must be < HIGH)
 MIN_PRICE_RATING_THRESHOLD_HIGH = 5  # Minimum value for high rating threshold (must be > LOW)
 MAX_PRICE_RATING_THRESHOLD_HIGH = 50  # Maximum value for high rating threshold
+MIN_PRICE_RATING_HYSTERESIS = 0.0  # Minimum hysteresis (0 = disabled)
+MAX_PRICE_RATING_HYSTERESIS = 5.0  # Maximum hysteresis (5% band)
+MIN_PRICE_RATING_GAP_TOLERANCE = 0  # Minimum gap tolerance (0 = disabled)
+MAX_PRICE_RATING_GAP_TOLERANCE = 4  # Maximum gap tolerance (4 intervals = 1 hour)
+MIN_PRICE_LEVEL_GAP_TOLERANCE = 0  # Minimum gap tolerance for price level (0 = disabled)
+MAX_PRICE_LEVEL_GAP_TOLERANCE = 4  # Maximum gap tolerance for price level (4 intervals = 1 hour)
 
 # Volatility threshold limits
 # MODERATE threshold: practical range 5% to 25% (entry point for noticeable fluctuation)
@@ -149,6 +167,11 @@ MIN_PRICE_TREND_RISING = 1  # Minimum rising trend threshold
 MAX_PRICE_TREND_RISING = 50  # Maximum rising trend threshold
 MIN_PRICE_TREND_FALLING = -50  # Minimum falling trend threshold (negative)
 MAX_PRICE_TREND_FALLING = -1  # Maximum falling trend threshold (negative)
+# Strong trend thresholds have higher ranges to allow detection of significant moves
+MIN_PRICE_TREND_STRONGLY_RISING = 2  # Minimum strongly rising threshold (must be > rising)
+MAX_PRICE_TREND_STRONGLY_RISING = 100  # Maximum strongly rising threshold
+MIN_PRICE_TREND_STRONGLY_FALLING = -100  # Minimum strongly falling threshold (negative)
+MAX_PRICE_TREND_STRONGLY_FALLING = -2  # Maximum strongly falling threshold (must be < falling)
 
 # Gap count and relaxation limits
 MIN_GAP_COUNT = 0  # Minimum gap count
@@ -298,6 +321,75 @@ def get_default_currency_display(currency_code: str | None) -> str:
     return DEFAULT_CURRENCY_DISPLAY.get(currency_code.upper(), DISPLAY_MODE_SUBUNIT)
 
 
+def get_default_options(currency_code: str | None) -> dict[str, Any]:
+    """
+    Get complete default options for a new config entry.
+
+    This ensures new config entries have explicitly set defaults based on their currency,
+    distinguishing them from legacy config entries that need migration.
+
+    Options structure has been flattened for single-section steps:
+    - Flat values: extended_descriptions, average_sensor_display, currency_display_mode,
+      price_rating_thresholds, volatility_thresholds, price_trend_thresholds, time offsets
+    - Nested sections (multi-section steps only): period_settings, flexibility_settings,
+      relaxation_and_target_periods
+
+    Args:
+        currency_code: ISO 4217 currency code (e.g., 'EUR', 'NOK')
+
+    Returns:
+        Dictionary with all default option values in nested section structure
+
+    """
+    return {
+        # Flat configuration values
+        CONF_EXTENDED_DESCRIPTIONS: DEFAULT_EXTENDED_DESCRIPTIONS,
+        CONF_AVERAGE_SENSOR_DISPLAY: DEFAULT_AVERAGE_SENSOR_DISPLAY,
+        CONF_CURRENCY_DISPLAY_MODE: get_default_currency_display(currency_code),
+        CONF_VIRTUAL_TIME_OFFSET_DAYS: DEFAULT_VIRTUAL_TIME_OFFSET_DAYS,
+        CONF_VIRTUAL_TIME_OFFSET_HOURS: DEFAULT_VIRTUAL_TIME_OFFSET_HOURS,
+        CONF_VIRTUAL_TIME_OFFSET_MINUTES: DEFAULT_VIRTUAL_TIME_OFFSET_MINUTES,
+        # Price rating settings (flat - single-section step)
+        CONF_PRICE_RATING_THRESHOLD_LOW: DEFAULT_PRICE_RATING_THRESHOLD_LOW,
+        CONF_PRICE_RATING_THRESHOLD_HIGH: DEFAULT_PRICE_RATING_THRESHOLD_HIGH,
+        CONF_PRICE_RATING_HYSTERESIS: DEFAULT_PRICE_RATING_HYSTERESIS,
+        CONF_PRICE_RATING_GAP_TOLERANCE: DEFAULT_PRICE_RATING_GAP_TOLERANCE,
+        CONF_PRICE_LEVEL_GAP_TOLERANCE: DEFAULT_PRICE_LEVEL_GAP_TOLERANCE,
+        # Volatility thresholds (flat - single-section step)
+        CONF_VOLATILITY_THRESHOLD_MODERATE: DEFAULT_VOLATILITY_THRESHOLD_MODERATE,
+        CONF_VOLATILITY_THRESHOLD_HIGH: DEFAULT_VOLATILITY_THRESHOLD_HIGH,
+        CONF_VOLATILITY_THRESHOLD_VERY_HIGH: DEFAULT_VOLATILITY_THRESHOLD_VERY_HIGH,
+        # Price trend thresholds (flat - single-section step)
+        CONF_PRICE_TREND_THRESHOLD_RISING: DEFAULT_PRICE_TREND_THRESHOLD_RISING,
+        CONF_PRICE_TREND_THRESHOLD_FALLING: DEFAULT_PRICE_TREND_THRESHOLD_FALLING,
+        # Nested section: Period settings (shared by best/peak price)
+        "period_settings": {
+            CONF_BEST_PRICE_MIN_PERIOD_LENGTH: DEFAULT_BEST_PRICE_MIN_PERIOD_LENGTH,
+            CONF_PEAK_PRICE_MIN_PERIOD_LENGTH: DEFAULT_PEAK_PRICE_MIN_PERIOD_LENGTH,
+            CONF_BEST_PRICE_MAX_LEVEL_GAP_COUNT: DEFAULT_BEST_PRICE_MAX_LEVEL_GAP_COUNT,
+            CONF_PEAK_PRICE_MAX_LEVEL_GAP_COUNT: DEFAULT_PEAK_PRICE_MAX_LEVEL_GAP_COUNT,
+            CONF_BEST_PRICE_MAX_LEVEL: DEFAULT_BEST_PRICE_MAX_LEVEL,
+            CONF_PEAK_PRICE_MIN_LEVEL: DEFAULT_PEAK_PRICE_MIN_LEVEL,
+        },
+        # Nested section: Flexibility settings (shared by best/peak price)
+        "flexibility_settings": {
+            CONF_BEST_PRICE_FLEX: DEFAULT_BEST_PRICE_FLEX,
+            CONF_PEAK_PRICE_FLEX: DEFAULT_PEAK_PRICE_FLEX,
+            CONF_BEST_PRICE_MIN_DISTANCE_FROM_AVG: DEFAULT_BEST_PRICE_MIN_DISTANCE_FROM_AVG,
+            CONF_PEAK_PRICE_MIN_DISTANCE_FROM_AVG: DEFAULT_PEAK_PRICE_MIN_DISTANCE_FROM_AVG,
+        },
+        # Nested section: Relaxation and target periods (shared by best/peak price)
+        "relaxation_and_target_periods": {
+            CONF_ENABLE_MIN_PERIODS_BEST: DEFAULT_ENABLE_MIN_PERIODS_BEST,
+            CONF_MIN_PERIODS_BEST: DEFAULT_MIN_PERIODS_BEST,
+            CONF_RELAXATION_ATTEMPTS_BEST: DEFAULT_RELAXATION_ATTEMPTS_BEST,
+            CONF_ENABLE_MIN_PERIODS_PEAK: DEFAULT_ENABLE_MIN_PERIODS_PEAK,
+            CONF_MIN_PERIODS_PEAK: DEFAULT_MIN_PERIODS_PEAK,
+            CONF_RELAXATION_ATTEMPTS_PEAK: DEFAULT_RELAXATION_ATTEMPTS_PEAK,
+        },
+    }
+
+
 def get_display_unit_factor(config_entry: ConfigEntry) -> int:
     """
     Get multiplication factor for converting base to display currency.
@@ -366,6 +458,14 @@ VOLATILITY_MODERATE = "MODERATE"
 VOLATILITY_HIGH = "HIGH"
 VOLATILITY_VERY_HIGH = "VERY_HIGH"
 
+# Price trend constants (calculated values with 5-level scale)
+# Used by trend sensors: momentary, short-term, mid-term, long-term
+PRICE_TREND_STRONGLY_FALLING = "strongly_falling"
+PRICE_TREND_FALLING = "falling"
+PRICE_TREND_STABLE = "stable"
+PRICE_TREND_RISING = "rising"
+PRICE_TREND_STRONGLY_RISING = "strongly_rising"
+
 # Sensor options (lowercase versions for ENUM device class)
 # NOTE: These constants define the valid enum options, but they are not used directly
 # in sensor/definitions.py due to import timing issues. Instead, the options are defined inline
@@ -391,6 +491,15 @@ VOLATILITY_OPTIONS = [
     VOLATILITY_VERY_HIGH.lower(),
 ]
 
+# Trend options for enum sensors (lowercase versions for ENUM device class)
+PRICE_TREND_OPTIONS = [
+    PRICE_TREND_STRONGLY_FALLING,
+    PRICE_TREND_FALLING,
+    PRICE_TREND_STABLE,
+    PRICE_TREND_RISING,
+    PRICE_TREND_STRONGLY_RISING,
+]
+
 # Valid options for best price maximum level filter
 # Sorted from cheap to expensive: user selects "up to how expensive"
 BEST_PRICE_MAX_LEVEL_OPTIONS = [
@@ -433,6 +542,16 @@ PRICE_RATING_MAPPING = {
     PRICE_RATING_HIGH: 1,
 }
 
+# Mapping for comparing price trends (used for sorting and automation comparisons)
+# Values range from -2 (strongly falling) to +2 (strongly rising), with 0 = stable
+PRICE_TREND_MAPPING = {
+    PRICE_TREND_STRONGLY_FALLING: -2,
+    PRICE_TREND_FALLING: -1,
+    PRICE_TREND_STABLE: 0,
+    PRICE_TREND_RISING: 1,
+    PRICE_TREND_STRONGLY_RISING: 2,
+}
+
 # Icon mapping for price levels (dynamic icons based on level)
 PRICE_LEVEL_ICON_MAPPING = {
     PRICE_LEVEL_VERY_CHEAP: "mdi:gauge-empty",

custom_components/tibber_prices/coordinator/cache.py

@@ -1,4 +1,28 @@
-"""Cache management for coordinator module."""
+"""
+Cache management for coordinator persistent storage.
+
+This module handles persistent storage for the coordinator, storing:
+- user_data: Account/home metadata (required, refreshed daily)
+- Timestamps for cache validation and lifecycle tracking
+
+**Storage Architecture (as of v0.25.0):**
+
+There are TWO persistent storage files per config entry:
+
+1. `tibber_prices.{entry_id}` (this module)
+   - user_data: Account info, home metadata, timezone, currency
+   - Timestamps: last_user_update, last_midnight_check
+
+2. `tibber_prices.interval_pool.{entry_id}` (interval_pool/storage.py)
+   - Intervals: Deduplicated quarter-hourly price data (source of truth)
+   - Fetch metadata: When each interval was fetched
+   - Protected range: Which intervals to keep during cleanup
+
+**Single Source of Truth:**
+Price intervals are ONLY stored in IntervalPool. This cache stores only
+user metadata and timestamps. The IntervalPool handles all price data
+fetching, caching, and persistence independently.
+"""
 
 from __future__ import annotations
 
@@ -16,11 +40,9 @@ _LOGGER = logging.getLogger(__name__)
 
 
 class TibberPricesCacheData(NamedTuple):
-    """Cache data structure."""
+    """Cache data structure for user metadata (price data is in IntervalPool)."""
 
-    price_data: dict[str, Any] | None
     user_data: dict[str, Any] | None
-    last_price_update: datetime | None
     last_user_update: datetime | None
     last_midnight_check: datetime | None
 
@@ -31,20 +53,16 @@ async def load_cache(
     *,
     time: TibberPricesTimeService,
 ) -> TibberPricesCacheData:
-    """Load cached data from storage."""
+    """Load cached user data from storage (price data is in IntervalPool)."""
     try:
         stored = await store.async_load()
         if stored:
-            cached_price_data = stored.get("price_data")
             cached_user_data = stored.get("user_data")
 
             # Restore timestamps
-            last_price_update = None
             last_user_update = None
             last_midnight_check = None
 
-            if last_price_update_str := stored.get("last_price_update"):
-                last_price_update = time.parse_datetime(last_price_update_str)
             if last_user_update_str := stored.get("last_user_update"):
                 last_user_update = time.parse_datetime(last_user_update_str)
             if last_midnight_check_str := stored.get("last_midnight_check"):
@@ -52,9 +70,7 @@ async def load_cache(
 
             _LOGGER.debug("%s Cache loaded successfully", log_prefix)
             return TibberPricesCacheData(
-                price_data=cached_price_data,
                 user_data=cached_user_data,
-                last_price_update=last_price_update,
                 last_user_update=last_user_update,
                 last_midnight_check=last_midnight_check,
             )
@@ -64,9 +80,7 @@ async def load_cache(
         _LOGGER.warning("%s Failed to load cache: %s", log_prefix, ex)
 
     return TibberPricesCacheData(
-        price_data=None,
         user_data=None,
-        last_price_update=None,
         last_user_update=None,
         last_midnight_check=None,
     )
@@ -77,11 +91,9 @@ async def save_cache(
     cache_data: TibberPricesCacheData,
     log_prefix: str,
 ) -> None:
-    """Store cache data."""
+    """Store cache data (user metadata only, price data is in IntervalPool)."""
     data = {
-        "price_data": cache_data.price_data,
         "user_data": cache_data.user_data,
-        "last_price_update": (cache_data.last_price_update.isoformat() if cache_data.last_price_update else None),
         "last_user_update": (cache_data.last_user_update.isoformat() if cache_data.last_user_update else None),
         "last_midnight_check": (cache_data.last_midnight_check.isoformat() if cache_data.last_midnight_check else None),
     }
@@ -91,55 +103,3 @@ async def save_cache(
         _LOGGER.debug("%s Cache stored successfully", log_prefix)
     except OSError:
         _LOGGER.exception("%s Failed to store cache", log_prefix)
-
-
-def is_cache_valid(
-    cache_data: TibberPricesCacheData,
-    log_prefix: str,
-    *,
-    time: TibberPricesTimeService,
-) -> bool:
-    """
-    Validate if cached price data is still current.
-
-    Returns False if:
-    - No cached data exists
-    - Cached data is from a different calendar day (in local timezone)
-    - Midnight turnover has occurred since cache was saved
-    - Cache structure is outdated (pre-v0.15.0 multi-home format)
-
-    """
-    if cache_data.price_data is None or cache_data.last_price_update is None:
-        return False
-
-    # Check for old cache structure (multi-home format from v0.14.0)
-    # Old format: {"homes": {home_id: {...}}}
-    # New format: {"home_id": str, "price_info": [...]}
-    if "homes" in cache_data.price_data:
-        _LOGGER.info(
-            "%s Cache has old multi-home structure (v0.14.0), invalidating to fetch fresh data",
-            log_prefix,
-        )
-        return False
-
-    # Check for missing required keys in new structure
-    if "price_info" not in cache_data.price_data:
-        _LOGGER.info(
-            "%s Cache missing 'price_info' key, invalidating to fetch fresh data",
-            log_prefix,
-        )
-        return False
-
-    current_local_date = time.as_local(time.now()).date()
-    last_update_local_date = time.as_local(cache_data.last_price_update).date()
-
-    if current_local_date != last_update_local_date:
-        _LOGGER.debug(
-            "%s Cache date mismatch: cached=%s, current=%s",
-            log_prefix,
-            last_update_local_date,
-            current_local_date,
-        )
-        return False
-
-    return True

custom_components/tibber_prices/coordinator/constants.py

@@ -31,6 +31,7 @@ TIME_SENSITIVE_ENTITY_KEYS = frozenset(
     {
         # Current/next/previous price sensors
         "current_interval_price",
+        "current_interval_price_base",
         "next_interval_price",
         "previous_interval_price",
         # Current/next/previous price levels
@@ -84,7 +85,11 @@ TIME_SENSITIVE_ENTITY_KEYS = frozenset(
         "best_price_next_start_time",
         "peak_price_end_time",
         "peak_price_next_start_time",
-        # Lifecycle sensor (needs quarter-hour updates for turnover_pending detection at 23:45)
+        # Lifecycle sensor needs quarter-hour precision for state transitions:
+        # - 23:45: turnover_pending (last interval before midnight)
+        # - 00:00: turnover complete (after midnight API update)
+        # - 13:00: searching_tomorrow (when tomorrow data search begins)
+        # Uses state-change filter in _handle_time_sensitive_update() to prevent recorder spam
         "data_lifecycle_status",
     }
 )

custom_components/tibber_prices/coordinator/core.py

@@ -11,7 +11,6 @@ from homeassistant.helpers.storage import Store
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
 
 if TYPE_CHECKING:
-    from collections.abc import Callable
     from datetime import date, datetime
 
     from homeassistant.config_entries import ConfigEntry
@@ -35,11 +34,11 @@ from .constants import (
     STORAGE_VERSION,
     UPDATE_INTERVAL,
 )
-from .data_fetching import TibberPricesDataFetcher
 from .data_transformation import TibberPricesDataTransformer
 from .listeners import TibberPricesListenerManager
 from .midnight_handler import TibberPricesMidnightHandler
 from .periods import TibberPricesPeriodCalculator
+from .price_data_manager import TibberPricesPriceDataManager
 from .repairs import TibberPricesRepairManager
 from .time_service import TibberPricesTimeService
 
@@ -206,17 +205,20 @@ class TibberPricesDataUpdateCoordinator(DataUpdateCoordinator[dict[str, Any]]):
         # Initialize helper modules
         self._listener_manager = TibberPricesListenerManager(hass, self._log_prefix)
         self._midnight_handler = TibberPricesMidnightHandler()
-        self._data_fetcher = TibberPricesDataFetcher(
+        self._price_data_manager = TibberPricesPriceDataManager(
             api=self.api,
             store=self._store,
             log_prefix=self._log_prefix,
             user_update_interval=timedelta(days=1),
             time=self.time,
+            home_id=self._home_id,
+            interval_pool=self.interval_pool,
         )
         # Create period calculator BEFORE data transformer (transformer needs it in lambda)
         self._period_calculator = TibberPricesPeriodCalculator(
             config_entry=config_entry,
             log_prefix=self._log_prefix,
+            get_config_override_fn=self.get_config_override,
         )
         self._data_transformer = TibberPricesDataTransformer(
             config_entry=config_entry,
@@ -235,22 +237,29 @@ class TibberPricesDataUpdateCoordinator(DataUpdateCoordinator[dict[str, Any]]):
         # Register options update listener to invalidate config caches
         config_entry.async_on_unload(config_entry.add_update_listener(self._handle_options_update))
 
-        # Legacy compatibility - keep references for methods that access directly
+        # User data cache (price data is in IntervalPool)
         self._cached_user_data: dict[str, Any] | None = None
         self._last_user_update: datetime | None = None
         self._user_update_interval = timedelta(days=1)
-        self._cached_price_data: dict[str, Any] | None = None
-        self._last_price_update: datetime | None = None
 
-        # Data lifecycle tracking for diagnostic sensor
+        # Data lifecycle tracking
+        # Note: _lifecycle_state is used for DIAGNOSTICS only (diagnostics.py export).
+        # The lifecycle SENSOR calculates its state dynamically in get_lifecycle_state(),
+        # using: _is_fetching, last_exception, time calculations, _needs_tomorrow_data(),
+        # and _last_price_update. It does NOT read _lifecycle_state!
         self._lifecycle_state: str = (
-            "cached"  # Current state: cached, fresh, refreshing, searching_tomorrow, turnover_pending, error
+            "cached"  # For diagnostics: cached, fresh, refreshing, searching_tomorrow, turnover_pending, error
         )
+        self._last_price_update: datetime | None = None  # When price data was last fetched from API
         self._api_calls_today: int = 0  # Counter for API calls today
         self._last_api_call_date: date | None = None  # Date of last API call (for daily reset)
-        self._is_fetching: bool = False  # Flag to track active API fetch
+        self._is_fetching: bool = False  # Flag to track active API fetch (read by lifecycle sensor)
         self._last_coordinator_update: datetime | None = None  # When Timer #1 last ran (_async_update_data)
-        self._lifecycle_callbacks: list[Callable[[], None]] = []  # Push-update callbacks for lifecycle sensor
+
+        # Runtime config overrides from config entities (number/switch)
+        # Structure: {"section_name": {"config_key": value, ...}, ...}
+        # When set, these override the corresponding options from config_entry.options
+        self._config_overrides: dict[str, dict[str, Any]] = {}
 
         # Start timers
         self._listener_manager.schedule_quarter_hour_refresh(self._handle_quarter_hour_refresh)
@@ -262,12 +271,129 @@ class TibberPricesDataUpdateCoordinator(DataUpdateCoordinator[dict[str, Any]]):
         getattr(_LOGGER, level)(prefixed_message, *args, **kwargs)
 
     async def _handle_options_update(self, _hass: HomeAssistant, _config_entry: ConfigEntry) -> None:
-        """Handle options update by invalidating config caches."""
-        self._log("debug", "Options updated, invalidating config caches")
+        """Handle options update by invalidating config caches and re-transforming data."""
+        self._log("debug", "Options update triggered, re-transforming data")
         self._data_transformer.invalidate_config_cache()
         self._period_calculator.invalidate_config_cache()
-        # Trigger a refresh to apply new configuration
-        await self.async_request_refresh()
+
+        # Re-transform existing data with new configuration
+        # This updates rating_levels, volatility, and period calculations
+        # without needing to fetch new data from the API
+        if self.data and "priceInfo" in self.data:
+            # Extract raw price_info and re-transform
+            raw_data = {"price_info": self.data["priceInfo"]}
+            self.data = self._transform_data(raw_data)
+            self.async_update_listeners()
+        else:
+            self._log("debug", "No data to re-transform")
+
+    # =========================================================================
+    # Runtime Config Override Methods (for number/switch entities)
+    # =========================================================================
+
+    def set_config_override(self, config_key: str, config_section: str, value: Any) -> None:
+        """
+        Set a runtime config override value.
+
+        These overrides take precedence over options from config_entry.options
+        and are used by number/switch entities for runtime configuration.
+
+        Args:
+            config_key: The configuration key (e.g., CONF_BEST_PRICE_FLEX)
+            config_section: The section in options (e.g., "flexibility_settings")
+            value: The override value
+
+        """
+        if config_section not in self._config_overrides:
+            self._config_overrides[config_section] = {}
+        self._config_overrides[config_section][config_key] = value
+        self._log(
+            "debug",
+            "Config override set: %s.%s = %s",
+            config_section,
+            config_key,
+            value,
+        )
+
+    def remove_config_override(self, config_key: str, config_section: str) -> None:
+        """
+        Remove a runtime config override value.
+
+        After removal, the value from config_entry.options will be used again.
+
+        Args:
+            config_key: The configuration key to remove
+            config_section: The section the key belongs to
+
+        """
+        if config_section in self._config_overrides:
+            self._config_overrides[config_section].pop(config_key, None)
+            # Clean up empty sections
+            if not self._config_overrides[config_section]:
+                del self._config_overrides[config_section]
+        self._log(
+            "debug",
+            "Config override removed: %s.%s",
+            config_section,
+            config_key,
+        )
+
+    def get_config_override(self, config_key: str, config_section: str) -> Any | None:
+        """
+        Get a runtime config override value if set.
+
+        Args:
+            config_key: The configuration key to check
+            config_section: The section the key belongs to
+
+        Returns:
+            The override value if set, None otherwise
+
+        """
+        return self._config_overrides.get(config_section, {}).get(config_key)
+
+    def has_config_override(self, config_key: str, config_section: str) -> bool:
+        """
+        Check if a runtime config override is set.
+
+        Args:
+            config_key: The configuration key to check
+            config_section: The section the key belongs to
+
+        Returns:
+            True if an override is set, False otherwise
+
+        """
+        return config_key in self._config_overrides.get(config_section, {})
+
+    def get_active_overrides(self) -> dict[str, dict[str, Any]]:
+        """
+        Get all active config overrides.
+
+        Returns:
+            Dictionary of all active overrides by section
+
+        """
+        return self._config_overrides.copy()
+
+    async def async_handle_config_override_update(self) -> None:
+        """
+        Handle config override change by invalidating caches and re-transforming data.
+
+        This is called by number/switch entities when their values change.
+        Uses the same logic as options update to ensure consistent behavior.
+        """
+        self._log("debug", "Config override update triggered, re-transforming data")
+        self._data_transformer.invalidate_config_cache()
+        self._period_calculator.invalidate_config_cache()
+
+        # Re-transform existing data with new configuration
+        if self.data and "priceInfo" in self.data:
+            raw_data = {"price_info": self.data["priceInfo"]}
+            self.data = self._transform_data(raw_data)
+            self.async_update_listeners()
+        else:
+            self._log("debug", "No data to re-transform")
 
     @callback
     def async_add_time_sensitive_listener(self, update_callback: TimeServiceCallback) -> CALLBACK_TYPE:
@@ -347,7 +473,7 @@ class TibberPricesDataUpdateCoordinator(DataUpdateCoordinator[dict[str, Any]]):
 
         # Update helper modules with fresh TimeService instance
         self.api.time = time_service
-        self._data_fetcher.time = time_service
+        self._price_data_manager.time = time_service
         self._data_transformer.time = time_service
         self._period_calculator.time = time_service
 
@@ -447,18 +573,13 @@ class TibberPricesDataUpdateCoordinator(DataUpdateCoordinator[dict[str, Any]]):
             current_date,
         )
 
-        # With flat interval list architecture, no rotation needed!
-        # get_intervals_for_day_offsets() automatically filters by date.
-        # Just update coordinator's data to trigger entity updates.
-        if self.data and self._cached_price_data:
-            # Re-transform data to ensure enrichment is refreshed
-            self.data = self._transform_data(self._cached_price_data)
-
-            # CRITICAL: Update _last_price_update to current time after midnight
-            # This prevents cache_validity from showing "date_mismatch" after midnight
-            # The data is still valid (just rotated today→yesterday, tomorrow→today)
-            # Update timestamp to reflect that the data is current for the new day
-            self._last_price_update = now
+        # With flat interval list architecture and IntervalPool as source of truth,
+        # no data rotation needed! get_intervals_for_day_offsets() automatically
+        # filters by date. Just re-transform to refresh enrichment.
+        if self.data and "priceInfo" in self.data:
+            # Re-transform data to ensure enrichment is refreshed for new day
+            raw_data = {"price_info": self.data["priceInfo"]}
+            self.data = self._transform_data(raw_data)
 
         # Mark turnover as done for today (atomic update)
         self._midnight_handler.mark_turnover_done(now)
@@ -545,19 +666,21 @@ class TibberPricesDataUpdateCoordinator(DataUpdateCoordinator[dict[str, Any]]):
 
         # Transition lifecycle state from "fresh" to "cached" if enough time passed
         # (5 minutes threshold defined in lifecycle calculator)
-        if self._lifecycle_state == "fresh" and self._last_price_update:
-            age = current_time - self._last_price_update
-            if age.total_seconds() > FRESH_TO_CACHED_SECONDS:
+        # Note: This updates _lifecycle_state for diagnostics only.
+        # The lifecycle sensor calculates its state dynamically in get_lifecycle_state(),
+        # checking _last_price_update timestamp directly.
+        if self._lifecycle_state == "fresh":
+            # After 5 minutes, data is considered "cached" (no longer "just fetched")
             self._lifecycle_state = "cached"
 
         # Update helper modules with fresh TimeService instance
         self.api.time = self.time
-        self._data_fetcher.time = self.time
+        self._price_data_manager.time = self.time
         self._data_transformer.time = self.time
         self._period_calculator.time = self.time
 
-        # Load cache if not already loaded
-        if self._cached_price_data is None and self._cached_user_data is None:
+        # Load cache if not already loaded (user data only, price data is in Pool)
+        if self._cached_user_data is None:
             await self.load_cache()
 
         # Initialize midnight handler on first run
@@ -594,47 +717,44 @@ class TibberPricesDataUpdateCoordinator(DataUpdateCoordinator[dict[str, Any]]):
                 self._api_calls_today = 0
                 self._last_api_call_date = current_date
 
-            # Track last_price_update timestamp before fetch to detect if data actually changed
-            old_price_update = self._last_price_update
-
-            # CRITICAL: Check if we need to fetch data BEFORE starting the fetch
-            # This allows the lifecycle sensor to show "searching_tomorrow" status
-            # when we're actively looking for tomorrow's data after 13:00
-            should_update = self._data_fetcher.should_update_price_data(current_time)
-
-            # Set _is_fetching flag if we're about to fetch data
-            # This makes the lifecycle sensor show "refreshing" status during the API call
-            if should_update:
+            # Set _is_fetching flag - lifecycle sensor shows "refreshing" during fetch
+            # Note: Lifecycle sensor reads this flag directly in get_lifecycle_state()
             self._is_fetching = True
-                # Immediately notify lifecycle sensor about state change
-                # This ensures "refreshing" or "searching_tomorrow" appears DURING the fetch
-                self.async_update_listeners()
 
-            result = await self._data_fetcher.handle_main_entry_update(
+            # Get current price info to check if tomorrow data already exists
+            current_price_info = self.data.get("priceInfo", []) if self.data else []
+
+            result, api_called = await self._price_data_manager.handle_main_entry_update(
                 current_time,
                 self._home_id,
                 self._transform_data,
+                current_price_info=current_price_info,
             )
 
             # CRITICAL: Reset fetching flag AFTER data fetch completes
             self._is_fetching = False
 
-            # CRITICAL: Sync cached data after API call
-            # handle_main_entry_update() updates data_fetcher's cache, we need to sync:
-            # 1. cached_user_data (for new integrations, may be fetched via update_user_data_if_needed())
-            # 2. cached_price_data (CRITICAL: contains tomorrow data, needed for _needs_tomorrow_data())
-            # 3. _last_price_update (for lifecycle tracking: cache age, fresh state detection)
-            self._cached_user_data = self._data_fetcher.cached_user_data
-            self._cached_price_data = self._data_fetcher.cached_price_data
-            self._last_price_update = self._data_fetcher._last_price_update  # noqa: SLF001 - Sync for lifecycle tracking
+            # Sync user_data cache (price data is in IntervalPool)
+            self._cached_user_data = self._price_data_manager.cached_user_data
 
-            # Update lifecycle tracking only if we fetched NEW data (timestamp changed)
-            # This prevents recorder spam from state changes when returning cached data
-            if self._last_price_update != old_price_update:
+            # Update lifecycle tracking - ONLY if API was actually called
+            # (not when returning cached data)
+            if api_called and result and "priceInfo" in result and len(result["priceInfo"]) > 0:
+                self._last_price_update = current_time  # Track when data was fetched from API
                 self._api_calls_today += 1
                 self._lifecycle_state = "fresh"  # Data just fetched
-                # No separate lifecycle notification needed - normal async_update_listeners()
-                # will trigger all entities (including lifecycle sensor) after this return
+                _LOGGER.debug(
+                    "API call completed: Fetched %d intervals, updating lifecycle to 'fresh'",
+                    len(result["priceInfo"]),
+                )
+                # Note: _lifecycle_state is for diagnostics only.
+                # Lifecycle sensor calculates state dynamically from _last_price_update.
+            elif not api_called:
+                # Using cached data - lifecycle stays as is (cached/searching_tomorrow/etc.)
+                _LOGGER.debug(
+                    "Using cached data: %d intervals from pool, no API call made",
+                    len(result.get("priceInfo", [])),
+                )
         except (
             TibberPricesApiClientAuthenticationError,
             TibberPricesApiClientCommunicationError,
@@ -642,17 +762,18 @@ class TibberPricesDataUpdateCoordinator(DataUpdateCoordinator[dict[str, Any]]):
         ) as err:
             # Reset lifecycle state on error
             self._is_fetching = False
-            self._lifecycle_state = "error"
+            self._lifecycle_state = "error"  # For diagnostics
+            # Note: Lifecycle sensor detects errors via coordinator.last_exception
 
             # Track rate limit errors for repair system
             await self._track_rate_limit_error(err)
 
-            # No separate lifecycle notification needed - error case returns data
-            # which triggers normal async_update_listeners()
-            return await self._data_fetcher.handle_api_error(
-                err,
-                self._transform_data,
-            )
+            # Handle API error - will re-raise as ConfigEntryAuthFailed or UpdateFailed
+            # Note: With IntervalPool, there's no local cache fallback here.
+            # The Pool has its own persistence for offline recovery.
+            await self._price_data_manager.handle_api_error(err)
+            # Note: handle_api_error always raises, this is never reached
+            return {}  # Satisfy type checker
         else:
             # Check for repair conditions after successful update
             await self._check_repair_conditions(result, current_time)
@@ -682,7 +803,7 @@ class TibberPricesDataUpdateCoordinator(DataUpdateCoordinator[dict[str, Any]]):
 
         # 2. Tomorrow data availability (after 18:00)
         if result and "priceInfo" in result:
-            has_tomorrow_data = self._data_fetcher.has_tomorrow_data(result["priceInfo"])
+            has_tomorrow_data = self._price_data_manager.has_tomorrow_data(result["priceInfo"])
             await self._repair_manager.check_tomorrow_data_availability(
                 has_tomorrow_data=has_tomorrow_data,
                 current_time=current_time,
@@ -692,33 +813,29 @@ class TibberPricesDataUpdateCoordinator(DataUpdateCoordinator[dict[str, Any]]):
         await self._repair_manager.clear_rate_limit_tracking()
 
     async def load_cache(self) -> None:
-        """Load cached data from storage."""
-        await self._data_fetcher.load_cache()
-        # Sync legacy references
-        self._cached_price_data = self._data_fetcher.cached_price_data
-        self._cached_user_data = self._data_fetcher.cached_user_data
-        self._last_price_update = self._data_fetcher._last_price_update  # noqa: SLF001 - Sync for lifecycle tracking
-        self._last_user_update = self._data_fetcher._last_user_update  # noqa: SLF001 - Sync for lifecycle tracking
+        """Load cached user data from storage (price data is in IntervalPool)."""
+        await self._price_data_manager.load_cache()
+        # Sync user data reference
+        self._cached_user_data = self._price_data_manager.cached_user_data
+        self._last_user_update = self._price_data_manager._last_user_update  # noqa: SLF001 - Sync for lifecycle tracking
 
-        # CRITICAL: Restore midnight handler state from cache
-        # If cache is from today, assume turnover already happened at midnight
-        # This allows proper turnover detection after HA restart
-        if self._last_price_update:
-            cache_date = self.time.as_local(self._last_price_update).date()
-            today_date = self.time.as_local(self.time.now()).date()
-            if cache_date == today_date:
-                # Cache is from today, so midnight turnover already happened
+        # Note: Midnight handler state is now based on current date
+        # Since price data is in IntervalPool (persistent), we just need to
+        # ensure turnover doesn't happen twice if HA restarts after midnight
         today_midnight = self.time.as_local(self.time.now()).replace(hour=0, minute=0, second=0, microsecond=0)
-                # Restore handler state: mark today's midnight as last turnover
+        # Mark today's midnight as done to prevent double turnover on HA restart
         self._midnight_handler.mark_turnover_done(today_midnight)
 
     async def _store_cache(self) -> None:
-        """Store cache data."""
-        await self._data_fetcher.store_cache(self._midnight_handler.last_check_time)
+        """Store cache data (user metadata only, price data is in IntervalPool)."""
+        await self._price_data_manager.store_cache(self._midnight_handler.last_check_time)
 
     def _needs_tomorrow_data(self) -> bool:
         """Check if tomorrow data is missing or invalid."""
-        return helpers.needs_tomorrow_data(self._cached_price_data)
+        # Check self.data (from Pool) instead of _cached_price_data
+        if not self.data or "priceInfo" not in self.data:
+            return True
+        return helpers.needs_tomorrow_data({"price_info": self.data["priceInfo"]})
 
     def _has_valid_tomorrow_data(self) -> bool:
         """Check if we have valid tomorrow data (inverse of _needs_tomorrow_data)."""
@@ -726,12 +843,12 @@ class TibberPricesDataUpdateCoordinator(DataUpdateCoordinator[dict[str, Any]]):
 
     @callback
     def _merge_cached_data(self) -> dict[str, Any]:
-        """Merge cached data into the expected format for main entry."""
-        if not self._cached_price_data:
+        """Return current data (from Pool)."""
+        if not self.data:
             return {}
-        return self._transform_data(self._cached_price_data)
+        return self.data
 
-    def _get_threshold_percentages(self) -> dict[str, int]:
+    def _get_threshold_percentages(self) -> dict[str, int | float]:
         """Get threshold percentages from config options."""
         return self._data_transformer.get_threshold_percentages()
 

custom_components/tibber_prices/coordinator/data_fetching.py

@@ -1,394 +0,0 @@
-"""Data fetching logic for the coordinator."""
-
-from __future__ import annotations
-
-import asyncio
-import logging
-import secrets
-from datetime import timedelta
-from typing import TYPE_CHECKING, Any
-
-from custom_components.tibber_prices.api import (
-    TibberPricesApiClientAuthenticationError,
-    TibberPricesApiClientCommunicationError,
-    TibberPricesApiClientError,
-)
-from homeassistant.core import callback
-from homeassistant.exceptions import ConfigEntryAuthFailed
-from homeassistant.helpers.update_coordinator import UpdateFailed
-
-from . import cache, helpers
-from .constants import TOMORROW_DATA_CHECK_HOUR, TOMORROW_DATA_RANDOM_DELAY_MAX
-
-if TYPE_CHECKING:
-    from collections.abc import Callable
-    from datetime import datetime
-
-    from custom_components.tibber_prices.api import TibberPricesApiClient
-
-    from .time_service import TibberPricesTimeService
-
-_LOGGER = logging.getLogger(__name__)
-
-
-class TibberPricesDataFetcher:
-    """Handles data fetching, caching, and main/subentry coordination."""
-
-    def __init__(
-        self,
-        api: TibberPricesApiClient,
-        store: Any,
-        log_prefix: str,
-        user_update_interval: timedelta,
-        time: TibberPricesTimeService,
-    ) -> None:
-        """Initialize the data fetcher."""
-        self.api = api
-        self._store = store
-        self._log_prefix = log_prefix
-        self._user_update_interval = user_update_interval
-        self.time: TibberPricesTimeService = time
-
-        # Cached data
-        self._cached_price_data: dict[str, Any] | None = None
-        self._cached_user_data: dict[str, Any] | None = None
-        self._last_price_update: datetime | None = None
-        self._last_user_update: datetime | None = None
-
-    def _log(self, level: str, message: str, *args: object, **kwargs: object) -> None:
-        """Log with coordinator-specific prefix."""
-        prefixed_message = f"{self._log_prefix} {message}"
-        getattr(_LOGGER, level)(prefixed_message, *args, **kwargs)
-
-    async def load_cache(self) -> None:
-        """Load cached data from storage."""
-        cache_data = await cache.load_cache(self._store, self._log_prefix, time=self.time)
-
-        self._cached_price_data = cache_data.price_data
-        self._cached_user_data = cache_data.user_data
-        self._last_price_update = cache_data.last_price_update
-        self._last_user_update = cache_data.last_user_update
-
-        # Parse timestamps if we loaded price data from cache
-        if self._cached_price_data:
-            self._cached_price_data = helpers.parse_all_timestamps(self._cached_price_data, time=self.time)
-
-        # Validate cache: check if price data is from a previous day
-        if not cache.is_cache_valid(cache_data, self._log_prefix, time=self.time):
-            self._log("info", "Cached price data is from a previous day, clearing cache to fetch fresh data")
-            self._cached_price_data = None
-            self._last_price_update = None
-            await self.store_cache()
-
-    async def store_cache(self, last_midnight_check: datetime | None = None) -> None:
-        """Store cache data."""
-        cache_data = cache.TibberPricesCacheData(
-            price_data=self._cached_price_data,
-            user_data=self._cached_user_data,
-            last_price_update=self._last_price_update,
-            last_user_update=self._last_user_update,
-            last_midnight_check=last_midnight_check,
-        )
-        await cache.save_cache(self._store, cache_data, self._log_prefix)
-
-    async def update_user_data_if_needed(self, current_time: datetime) -> bool:
-        """
-        Update user data if needed (daily check).
-
-        Returns:
-            True if user data was updated, False otherwise
-
-        """
-        if self._last_user_update is None or current_time - self._last_user_update >= self._user_update_interval:
-            try:
-                self._log("debug", "Updating user data")
-                user_data = await self.api.async_get_viewer_details()
-                self._cached_user_data = user_data
-                self._last_user_update = current_time
-                self._log("debug", "User data updated successfully")
-            except (
-                TibberPricesApiClientError,
-                TibberPricesApiClientCommunicationError,
-            ) as ex:
-                self._log("warning", "Failed to update user data: %s", ex)
-                return False  # Update failed
-            else:
-                return True  # User data was updated
-        return False  # No update needed
-
-    @callback
-    def should_update_price_data(self, current_time: datetime) -> bool | str:
-        """
-        Check if price data should be updated from the API.
-
-        API calls only happen when truly needed:
-        1. No cached data exists
-        2. Cache is invalid (from previous day - detected by _is_cache_valid)
-        3. After 13:00 local time and tomorrow's data is missing or invalid
-
-        Cache validity is ensured by:
-        - _is_cache_valid() checks date mismatch on load
-        - Midnight turnover clears cache (Timer #2)
-        - Tomorrow data validation after 13:00
-
-        No periodic "safety" updates - trust the cache validation!
-
-        Returns:
-            bool or str: True for immediate update, "tomorrow_check" for tomorrow
-                        data check (needs random delay), False for no update
-
-        """
-        if self._cached_price_data is None:
-            self._log("debug", "API update needed: No cached price data")
-            return True
-        if self._last_price_update is None:
-            self._log("debug", "API update needed: No last price update timestamp")
-            return True
-
-        # Check if after 13:00 and tomorrow data is missing or invalid
-        now_local = self.time.as_local(current_time)
-        if now_local.hour >= TOMORROW_DATA_CHECK_HOUR and self._cached_price_data and self.needs_tomorrow_data():
-            self._log(
-                "info",
-                "API update needed: After %s:00 and tomorrow's data missing/invalid",
-                TOMORROW_DATA_CHECK_HOUR,
-            )
-            # Return special marker to indicate this is a tomorrow data check
-            # Caller should add random delay to spread load
-            return "tomorrow_check"
-
-        # No update needed - cache is valid and complete
-        self._log("debug", "No API update needed: Cache is valid and complete")
-        return False
-
-    def needs_tomorrow_data(self) -> bool:
-        """Check if tomorrow data is missing or invalid."""
-        return helpers.needs_tomorrow_data(self._cached_price_data)
-
-    async def fetch_home_data(self, home_id: str, current_time: datetime) -> dict[str, Any]:
-        """Fetch data for a single home."""
-        if not home_id:
-            self._log("warning", "No home ID provided - cannot fetch price data")
-            return {
-                "timestamp": current_time,
-                "home_id": "",
-                "price_info": [],
-                "currency": "EUR",
-            }
-
-        # Ensure we have user_data before fetching price data
-        # This is critical for timezone-aware cursor calculation
-        if not self._cached_user_data:
-            self._log("info", "User data not cached, fetching before price data")
-            try:
-                user_data = await self.api.async_get_viewer_details()
-                self._cached_user_data = user_data
-                self._last_user_update = current_time
-            except (
-                TibberPricesApiClientError,
-                TibberPricesApiClientCommunicationError,
-            ) as ex:
-                msg = f"Failed to fetch user data (required for price fetching): {ex}"
-                self._log("error", msg)
-                raise TibberPricesApiClientError(msg) from ex
-
-        # Get price data for this home
-        # Pass user_data for timezone-aware cursor calculation
-        # At this point, _cached_user_data is guaranteed to be not None (checked above)
-        if not self._cached_user_data:
-            msg = "User data unexpectedly None after fetch attempt"
-            raise TibberPricesApiClientError(msg)
-
-        self._log("debug", "Fetching price data for home %s", home_id)
-        home_data = await self.api.async_get_price_info(
-            home_id=home_id,
-            user_data=self._cached_user_data,
-        )
-
-        # Extract currency for this home from user_data
-        currency = self._get_currency_for_home(home_id)
-
-        price_info = home_data.get("price_info", [])
-
-        self._log("debug", "Successfully fetched data for home %s (%d intervals)", home_id, len(price_info))
-
-        return {
-            "timestamp": current_time,
-            "home_id": home_id,
-            "price_info": price_info,
-            "currency": currency,
-        }
-
-    def _get_currency_for_home(self, home_id: str) -> str:
-        """Get currency for a specific home from cached user_data."""
-        if not self._cached_user_data:
-            self._log("warning", "No user data cached, using EUR as default currency")
-            return "EUR"
-
-        viewer = self._cached_user_data.get("viewer", {})
-        homes = viewer.get("homes", [])
-
-        for home in homes:
-            if home.get("id") == home_id:
-                # Extract currency from nested structure (with fallback to EUR)
-                currency = (
-                    home.get("currentSubscription", {}).get("priceInfo", {}).get("current", {}).get("currency", "EUR")
-                )
-                self._log("debug", "Extracted currency %s for home %s", currency, home_id)
-                return currency
-
-        self._log("warning", "Home %s not found in user data, using EUR as default", home_id)
-        return "EUR"
-
-    def _check_home_exists(self, home_id: str) -> bool:
-        """
-        Check if a home ID exists in cached user data.
-
-        Args:
-            home_id: The home ID to check.
-
-        Returns:
-            True if home exists, False otherwise.
-
-        """
-        if not self._cached_user_data:
-            # No user data yet - assume home exists (will be checked on next update)
-            return True
-
-        viewer = self._cached_user_data.get("viewer", {})
-        homes = viewer.get("homes", [])
-
-        return any(home.get("id") == home_id for home in homes)
-
-    async def handle_main_entry_update(
-        self,
-        current_time: datetime,
-        home_id: str,
-        transform_fn: Callable[[dict[str, Any]], dict[str, Any]],
-    ) -> dict[str, Any]:
-        """Handle update for main entry - fetch data for this home."""
-        # Update user data if needed (daily check)
-        user_data_updated = await self.update_user_data_if_needed(current_time)
-
-        # Check if this home still exists in user data after update
-        # This detects when a home was removed from the Tibber account
-        home_exists = self._check_home_exists(home_id)
-        if not home_exists:
-            self._log("warning", "Home ID %s not found in Tibber account", home_id)
-            # Return a special marker in the result that coordinator can check
-            # We still need to return valid data to avoid coordinator errors
-            result = transform_fn(self._cached_price_data or {})
-            result["_home_not_found"] = True  # Special marker for coordinator
-            return result
-
-        # Check if we need to update price data
-        should_update = self.should_update_price_data(current_time)
-
-        if should_update:
-            # If this is a tomorrow data check, add random delay to spread API load
-            if should_update == "tomorrow_check":
-                # Use secrets for better randomness distribution
-                delay = secrets.randbelow(TOMORROW_DATA_RANDOM_DELAY_MAX + 1)
-                self._log(
-                    "debug",
-                    "Tomorrow data check - adding random delay of %d seconds to spread load",
-                    delay,
-                )
-                await asyncio.sleep(delay)
-
-            self._log("debug", "Fetching fresh price data from API")
-            raw_data = await self.fetch_home_data(home_id, current_time)
-            # Parse timestamps immediately after API fetch
-            raw_data = helpers.parse_all_timestamps(raw_data, time=self.time)
-            # Cache the data (now with datetime objects)
-            self._cached_price_data = raw_data
-            self._last_price_update = current_time
-            await self.store_cache()
-            # Transform for main entry
-            return transform_fn(raw_data)
-
-        # Use cached data if available
-        if self._cached_price_data is not None:
-            # If user data was updated, we need to return transformed data to trigger entity updates
-            # This ensures diagnostic sensors (home_type, grid_company, etc.) get refreshed
-            if user_data_updated:
-                self._log("debug", "User data updated - returning transformed data to update diagnostic sensors")
-            else:
-                self._log("debug", "Using cached price data (no API call needed)")
-            return transform_fn(self._cached_price_data)
-
-        # Fallback: no cache and no update needed (shouldn't happen)
-        self._log("warning", "No cached data available and update not triggered - returning empty data")
-        return {
-            "timestamp": current_time,
-            "home_id": home_id,
-            "priceInfo": [],
-            "currency": "",
-        }
-
-    async def handle_api_error(
-        self,
-        error: Exception,
-        transform_fn: Callable[[dict[str, Any]], dict[str, Any]],
-    ) -> dict[str, Any]:
-        """Handle API errors with fallback to cached data."""
-        if isinstance(error, TibberPricesApiClientAuthenticationError):
-            msg = "Invalid access token"
-            raise ConfigEntryAuthFailed(msg) from error
-
-        # Use cached data as fallback if available
-        if self._cached_price_data is not None:
-            self._log("warning", "API error, using cached data: %s", error)
-            return transform_fn(self._cached_price_data)
-
-        msg = f"Error communicating with API: {error}"
-        raise UpdateFailed(msg) from error
-
-    @property
-    def cached_price_data(self) -> dict[str, Any] | None:
-        """Get cached price data."""
-        return self._cached_price_data
-
-    @cached_price_data.setter
-    def cached_price_data(self, value: dict[str, Any] | None) -> None:
-        """Set cached price data."""
-        self._cached_price_data = value
-
-    @property
-    def cached_user_data(self) -> dict[str, Any] | None:
-        """Get cached user data."""
-        return self._cached_user_data
-
-    def has_tomorrow_data(self, price_info: list[dict[str, Any]]) -> bool:
-        """
-        Check if tomorrow's price data is available.
-
-        Args:
-            price_info: List of price intervals from coordinator data.
-
-        Returns:
-            True if at least one interval from tomorrow is present.
-
-        """
-        if not price_info:
-            return False
-
-        # Get tomorrow's date
-        now = self.time.now()
-        tomorrow = (self.time.as_local(now) + timedelta(days=1)).date()
-
-        # Check if any interval is from tomorrow
-        for interval in price_info:
-            if "startsAt" not in interval:
-                continue
-
-            # startsAt is already a datetime object after _transform_data()
-            interval_time = interval["startsAt"]
-            if isinstance(interval_time, str):
-                # Fallback: parse if still string (shouldn't happen with transformed data)
-                interval_time = self.time.parse_datetime(interval_time)
-
-            if interval_time and self.time.as_local(interval_time).date() == tomorrow:
-                return True
-
-        return False

custom_components/tibber_prices/coordinator/data_transformation.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import copy
 import logging
 from typing import TYPE_CHECKING, Any
 
@@ -48,19 +49,50 @@ class TibberPricesDataTransformer:
         prefixed_message = f"{self._log_prefix} {message}"
         getattr(_LOGGER, level)(prefixed_message, *args, **kwargs)
 
-    def get_threshold_percentages(self) -> dict[str, int]:
-        """Get threshold percentages from config options."""
+    def get_threshold_percentages(self) -> dict[str, int | float]:
+        """
+        Get threshold percentages, hysteresis and gap tolerance for RATING_LEVEL from config options.
+
+        CRITICAL: This function is ONLY for rating_level (internal calculation: LOW/NORMAL/HIGH).
+        Do NOT use for price level (Tibber API: VERY_CHEAP/CHEAP/NORMAL/EXPENSIVE/VERY_EXPENSIVE).
+        """
         options = self.config_entry.options or {}
         return {
             "low": options.get(_const.CONF_PRICE_RATING_THRESHOLD_LOW, _const.DEFAULT_PRICE_RATING_THRESHOLD_LOW),
             "high": options.get(_const.CONF_PRICE_RATING_THRESHOLD_HIGH, _const.DEFAULT_PRICE_RATING_THRESHOLD_HIGH),
+            "hysteresis": options.get(_const.CONF_PRICE_RATING_HYSTERESIS, _const.DEFAULT_PRICE_RATING_HYSTERESIS),
+            "gap_tolerance": options.get(
+                _const.CONF_PRICE_RATING_GAP_TOLERANCE, _const.DEFAULT_PRICE_RATING_GAP_TOLERANCE
+            ),
         }
 
+    def get_level_gap_tolerance(self) -> int:
+        """
+        Get gap tolerance for PRICE LEVEL (Tibber API) from config options.
+
+        CRITICAL: This is separate from rating_level gap tolerance.
+        Price level comes from Tibber API (VERY_CHEAP/CHEAP/NORMAL/EXPENSIVE/VERY_EXPENSIVE).
+        Rating level is calculated internally (LOW/NORMAL/HIGH).
+        """
+        options = self.config_entry.options or {}
+        return options.get(_const.CONF_PRICE_LEVEL_GAP_TOLERANCE, _const.DEFAULT_PRICE_LEVEL_GAP_TOLERANCE)
+
     def invalidate_config_cache(self) -> None:
-        """Invalidate config cache when options change."""
+        """
+        Invalidate config cache AND transformation cache when options change.
+
+        CRITICAL: When options like gap_tolerance, hysteresis, or price_level_gap_tolerance
+        change, we must clear BOTH caches:
+        1. Config cache (_config_cache) - forces config rebuild on next check
+        2. Transformation cache (_cached_transformed_data) - forces data re-enrichment
+
+        This ensures that the next call to transform_data() will re-calculate
+        rating_levels and apply new gap tolerance settings to existing price data.
+        """
         self._config_cache_valid = False
         self._config_cache = None
-        self._log("debug", "Config cache invalidated")
+        self._cached_transformed_data = None  # Force re-transformation with new config
+        self._last_transformation_config = None  # Force config comparison to trigger
 
     def _get_current_transformation_config(self) -> dict[str, Any]:
         """
@@ -73,36 +105,53 @@ class TibberPricesDataTransformer:
             return self._config_cache
 
         # Build config dictionary (expensive operation)
+        options = self.config_entry.options
+
+        # Best/peak price remain nested (multi-section steps)
+        best_period_section = options.get("period_settings", {})
+        best_flex_section = options.get("flexibility_settings", {})
+        best_relax_section = options.get("relaxation_and_target_periods", {})
+        peak_period_section = options.get("period_settings", {})
+        peak_flex_section = options.get("flexibility_settings", {})
+        peak_relax_section = options.get("relaxation_and_target_periods", {})
+
         config = {
             "thresholds": self.get_threshold_percentages(),
+            "level_gap_tolerance": self.get_level_gap_tolerance(),  # Separate: Tibber's price level smoothing
+            # Volatility thresholds now flat (single-section step)
             "volatility_thresholds": {
-                "moderate": self.config_entry.options.get(_const.CONF_VOLATILITY_THRESHOLD_MODERATE, 15.0),
-                "high": self.config_entry.options.get(_const.CONF_VOLATILITY_THRESHOLD_HIGH, 25.0),
-                "very_high": self.config_entry.options.get(_const.CONF_VOLATILITY_THRESHOLD_VERY_HIGH, 40.0),
+                "moderate": options.get(_const.CONF_VOLATILITY_THRESHOLD_MODERATE, 15.0),
+                "high": options.get(_const.CONF_VOLATILITY_THRESHOLD_HIGH, 25.0),
+                "very_high": options.get(_const.CONF_VOLATILITY_THRESHOLD_VERY_HIGH, 40.0),
+            },
+            # Price trend thresholds now flat (single-section step)
+            "price_trend_thresholds": {
+                "rising": options.get(
+                    _const.CONF_PRICE_TREND_THRESHOLD_RISING, _const.DEFAULT_PRICE_TREND_THRESHOLD_RISING
+                ),
+                "falling": options.get(
+                    _const.CONF_PRICE_TREND_THRESHOLD_FALLING, _const.DEFAULT_PRICE_TREND_THRESHOLD_FALLING
+                ),
             },
             "best_price_config": {
-                "flex": self.config_entry.options.get(_const.CONF_BEST_PRICE_FLEX, 15.0),
-                "max_level": self.config_entry.options.get(_const.CONF_BEST_PRICE_MAX_LEVEL, "NORMAL"),
-                "min_period_length": self.config_entry.options.get(_const.CONF_BEST_PRICE_MIN_PERIOD_LENGTH, 4),
-                "min_distance_from_avg": self.config_entry.options.get(
-                    _const.CONF_BEST_PRICE_MIN_DISTANCE_FROM_AVG, -5.0
-                ),
-                "max_level_gap_count": self.config_entry.options.get(_const.CONF_BEST_PRICE_MAX_LEVEL_GAP_COUNT, 0),
-                "enable_min_periods": self.config_entry.options.get(_const.CONF_ENABLE_MIN_PERIODS_BEST, False),
-                "min_periods": self.config_entry.options.get(_const.CONF_MIN_PERIODS_BEST, 2),
-                "relaxation_attempts": self.config_entry.options.get(_const.CONF_RELAXATION_ATTEMPTS_BEST, 4),
+                "flex": best_flex_section.get(_const.CONF_BEST_PRICE_FLEX, 15.0),
+                "max_level": best_period_section.get(_const.CONF_BEST_PRICE_MAX_LEVEL, "NORMAL"),
+                "min_period_length": best_period_section.get(_const.CONF_BEST_PRICE_MIN_PERIOD_LENGTH, 4),
+                "min_distance_from_avg": best_flex_section.get(_const.CONF_BEST_PRICE_MIN_DISTANCE_FROM_AVG, -5.0),
+                "max_level_gap_count": best_period_section.get(_const.CONF_BEST_PRICE_MAX_LEVEL_GAP_COUNT, 0),
+                "enable_min_periods": best_relax_section.get(_const.CONF_ENABLE_MIN_PERIODS_BEST, False),
+                "min_periods": best_relax_section.get(_const.CONF_MIN_PERIODS_BEST, 2),
+                "relaxation_attempts": best_relax_section.get(_const.CONF_RELAXATION_ATTEMPTS_BEST, 4),
             },
             "peak_price_config": {
-                "flex": self.config_entry.options.get(_const.CONF_PEAK_PRICE_FLEX, 15.0),
-                "min_level": self.config_entry.options.get(_const.CONF_PEAK_PRICE_MIN_LEVEL, "HIGH"),
-                "min_period_length": self.config_entry.options.get(_const.CONF_PEAK_PRICE_MIN_PERIOD_LENGTH, 4),
-                "min_distance_from_avg": self.config_entry.options.get(
-                    _const.CONF_PEAK_PRICE_MIN_DISTANCE_FROM_AVG, 5.0
-                ),
-                "max_level_gap_count": self.config_entry.options.get(_const.CONF_PEAK_PRICE_MAX_LEVEL_GAP_COUNT, 0),
-                "enable_min_periods": self.config_entry.options.get(_const.CONF_ENABLE_MIN_PERIODS_PEAK, False),
-                "min_periods": self.config_entry.options.get(_const.CONF_MIN_PERIODS_PEAK, 2),
-                "relaxation_attempts": self.config_entry.options.get(_const.CONF_RELAXATION_ATTEMPTS_PEAK, 4),
+                "flex": peak_flex_section.get(_const.CONF_PEAK_PRICE_FLEX, 15.0),
+                "min_level": peak_period_section.get(_const.CONF_PEAK_PRICE_MIN_LEVEL, "HIGH"),
+                "min_period_length": peak_period_section.get(_const.CONF_PEAK_PRICE_MIN_PERIOD_LENGTH, 4),
+                "min_distance_from_avg": peak_flex_section.get(_const.CONF_PEAK_PRICE_MIN_DISTANCE_FROM_AVG, 5.0),
+                "max_level_gap_count": peak_period_section.get(_const.CONF_PEAK_PRICE_MAX_LEVEL_GAP_COUNT, 0),
+                "enable_min_periods": peak_relax_section.get(_const.CONF_ENABLE_MIN_PERIODS_PEAK, False),
+                "min_periods": peak_relax_section.get(_const.CONF_MIN_PERIODS_PEAK, 2),
+                "relaxation_attempts": peak_relax_section.get(_const.CONF_RELAXATION_ATTEMPTS_PEAK, 4),
             },
         }
 
@@ -135,8 +184,9 @@ class TibberPricesDataTransformer:
 
         # Configuration changed - must retransform
         current_config = self._get_current_transformation_config()
-        if current_config != self._last_transformation_config:
-            self._log("debug", "Configuration changed, retransforming data")
+        config_changed = current_config != self._last_transformation_config
+
+        if config_changed:
             return True
 
         # Check for midnight turnover
@@ -161,18 +211,29 @@ class TibberPricesDataTransformer:
         source_data_timestamp = raw_data.get("timestamp")
 
         # Return cached transformed data if no retransformation needed
-        if (
-            not self._should_retransform_data(current_time, source_data_timestamp)
-            and self._cached_transformed_data is not None
-        ):
+        should_retransform = self._should_retransform_data(current_time, source_data_timestamp)
+        has_cache = self._cached_transformed_data is not None
+
+        self._log(
+            "info",
+            "transform_data: should_retransform=%s, has_cache=%s",
+            should_retransform,
+            has_cache,
+        )
+
+        if not should_retransform and has_cache:
             self._log("debug", "Using cached transformed data (no transformation needed)")
-            return self._cached_transformed_data
+            # has_cache ensures _cached_transformed_data is not None
+            return self._cached_transformed_data  # type: ignore[return-value]
 
         self._log("debug", "Transforming price data (enrichment + period calculation)")
 
         # Extract data from single-home structure
         home_id = raw_data.get("home_id", "")
-        all_intervals = raw_data.get("price_info", [])
+        # CRITICAL: Make a deep copy of intervals to avoid modifying cached raw data
+        # The enrichment function modifies intervals in-place, which would corrupt
+        # the original API data and make re-enrichment with different settings impossible
+        all_intervals = copy.deepcopy(raw_data.get("price_info", []))
         currency = raw_data.get("currency", "EUR")
 
         if not all_intervals:
@@ -189,11 +250,16 @@ class TibberPricesDataTransformer:
 
         # Enrich price info dynamically with calculated differences and rating levels
         # (Modifies all_intervals in-place, returns same list)
-        thresholds = self.get_threshold_percentages()
+        thresholds = self.get_threshold_percentages()  # Only for rating_level
+        level_gap_tolerance = self.get_level_gap_tolerance()  # Separate: for Tibber's price level
+
         enriched_intervals = enrich_price_info_with_differences(
             all_intervals,
             threshold_low=thresholds["low"],
             threshold_high=thresholds["high"],
+            hysteresis=float(thresholds["hysteresis"]),
+            gap_tolerance=int(thresholds["gap_tolerance"]),
+            level_gap_tolerance=level_gap_tolerance,
             time=self.time,
         )
 

custom_components/tibber_prices/coordinator/period_handlers/core.py

@@ -16,8 +16,10 @@ from .period_building import (
     add_interval_ends,
     build_periods,
     calculate_reference_prices,
+    extend_periods_across_midnight,
     filter_periods_by_end_date,
     filter_periods_by_min_length,
+    filter_superseded_periods,
     split_intervals_by_day,
 )
 from .period_statistics import (
@@ -188,7 +190,7 @@ def calculate_periods(
     # Sensors filter further for today+tomorrow, services can access all cached periods
     raw_periods = filter_periods_by_end_date(raw_periods, time=time)
 
-    # Step 8: Extract lightweight period summaries (no full price data)
+    # Step 7: Extract lightweight period summaries (no full price data)
     # Note: Periods are filtered by end date to keep yesterday/today/tomorrow.
     # This preserves periods that started day-before-yesterday but end yesterday.
     thresholds = TibberPricesThresholdConfig(
@@ -207,6 +209,26 @@ def calculate_periods(
         time=time,
     )
 
+    # Step 8: Cross-day extension for late-night periods
+    # If a best-price period ends near midnight and tomorrow has continued low prices,
+    # extend the period across midnight to give users the full cheap window
+    period_summaries = extend_periods_across_midnight(
+        period_summaries,
+        all_prices_sorted,
+        price_context,
+        time=time,
+        reverse_sort=reverse_sort,
+    )
+
+    # Step 9: Filter superseded periods
+    # When tomorrow data is available, late-night today periods that were found via
+    # relaxation may be obsolete if tomorrow has significantly better alternatives
+    period_summaries = filter_superseded_periods(
+        period_summaries,
+        time=time,
+        reverse_sort=reverse_sort,
+    )
+
     return {
         "periods": period_summaries,  # Lightweight summaries only
         "metadata": {

custom_components/tibber_prices/coordinator/period_handlers/level_filtering.py

@@ -155,9 +155,12 @@ def check_interval_criteria(
             in_flex = price >= flex_threshold
         else:
             # Best price: accept prices <= (ref_price + flex_amount)
-            # Prices must be CLOSE TO or AT the minimum
+            # Accept ALL low prices up to the flex threshold, not just those >= minimum
+            # This ensures that if there are multiple low-price intervals, all that meet
+            # the threshold are included, regardless of whether they're before or after
+            # the daily minimum in the chronological sequence.
             flex_threshold = criteria.ref_price + flex_amount
-            in_flex = price >= criteria.ref_price and price <= flex_threshold
+            in_flex = price <= flex_threshold
 
     # ============================================================
     # MIN_DISTANCE FILTER: Check if price is far enough from average
@@ -181,7 +184,7 @@ def check_interval_criteria(
         if scale_factor < SCALE_FACTOR_WARNING_THRESHOLD:
             import logging  # noqa: PLC0415
 
-            _LOGGER = logging.getLogger(__name__)  # noqa: N806
+            _LOGGER = logging.getLogger(f"{__name__}.details")  # noqa: N806
             _LOGGER.debug(
                 "High flex %.1f%% detected: Reducing min_distance %.1f%% → %.1f%% (scale %.2f)",
                 flex_abs * 100,

custom_components/tibber_prices/coordinator/period_handlers/outlier_filtering.py

@@ -15,19 +15,34 @@ Uses statistical methods:
 from __future__ import annotations
 
 import logging
+from datetime import datetime
 from typing import NamedTuple
 
+from custom_components.tibber_prices.utils.price import calculate_coefficient_of_variation
+
 _LOGGER = logging.getLogger(__name__)
 _LOGGER_DETAILS = logging.getLogger(__name__ + ".details")
 
 # Outlier filtering constants
 MIN_CONTEXT_SIZE = 3  # Minimum intervals needed before/after for analysis
-CONFIDENCE_LEVEL = 2.0  # Standard deviations for 95% confidence interval
 VOLATILITY_THRESHOLD = 0.05  # 5% max relative std dev for zigzag detection
 SYMMETRY_THRESHOLD = 1.5  # Max std dev difference for symmetric spike
 RELATIVE_VOLATILITY_THRESHOLD = 2.0  # Window volatility vs context (cluster detection)
 ASYMMETRY_TAIL_WINDOW = 6  # Skip asymmetry check for last ~1.5h (6 intervals) of available data
 ZIGZAG_TAIL_WINDOW = 6  # Skip zigzag/cluster detection for last ~1.5h (6 intervals)
+EXTREMES_PROTECTION_TOLERANCE = 0.001  # Protect prices within 0.1% of daily min/max from smoothing
+
+# Adaptive confidence level constants
+# Uses coefficient of variation (CV) from utils/price.py for consistency with volatility sensors
+# On flat days (low CV), we're more conservative (higher confidence = fewer smoothed)
+# On volatile days (high CV), we're more aggressive (lower confidence = more smoothed)
+CONFIDENCE_LEVEL_MIN = 1.5  # Minimum confidence (volatile days: smooth more aggressively)
+CONFIDENCE_LEVEL_MAX = 2.5  # Maximum confidence (flat days: smooth more conservatively)
+CONFIDENCE_LEVEL_DEFAULT = 2.0  # Default: 95% confidence interval (2 std devs)
+# CV thresholds for adaptive confidence (align with volatility sensor defaults)
+# These are in percentage points (e.g., 10.0 = 10% CV)
+DAILY_CV_LOW = 10.0  # ≤10% CV = flat day (use max confidence)
+DAILY_CV_HIGH = 30.0  # ≥30% CV = volatile day (use min confidence)
 
 # Module-local log indentation (each module starts at level 0)
 INDENT_L0 = ""  # All logs in this module (no indentation needed)
@@ -233,6 +248,166 @@ def _validate_spike_candidate(
     return True
 
 
+def _calculate_daily_extremes(intervals: list[dict]) -> dict[str, tuple[float, float]]:
+    """
+    Calculate daily min/max prices for each day in the interval list.
+
+    These extremes are used to protect reference prices from being smoothed.
+    The daily minimum is the reference for best_price periods, and the daily
+    maximum is the reference for peak_price periods - smoothing these would
+    break period detection.
+
+    Args:
+        intervals: List of price intervals with 'startsAt' and 'total' keys
+
+    Returns:
+        Dict mapping date strings to (min_price, max_price) tuples
+
+    """
+    daily_prices: dict[str, list[float]] = {}
+
+    for interval in intervals:
+        starts_at = interval.get("startsAt")
+        if starts_at is None:
+            continue
+
+        # Handle both datetime objects and ISO strings
+        dt = datetime.fromisoformat(starts_at) if isinstance(starts_at, str) else starts_at
+
+        date_key = dt.strftime("%Y-%m-%d")
+        price = float(interval["total"])
+        daily_prices.setdefault(date_key, []).append(price)
+
+    # Calculate min/max for each day
+    return {date_key: (min(prices), max(prices)) for date_key, prices in daily_prices.items()}
+
+
+def _calculate_daily_cv(intervals: list[dict]) -> dict[str, float]:
+    """
+    Calculate daily coefficient of variation (CV) for each day.
+
+    Uses the same CV calculation as volatility sensors for consistency.
+    CV = (std_dev / mean) * 100, expressed as percentage.
+
+    Used to adapt the confidence level for outlier detection:
+    - Flat days (low CV): Higher confidence → fewer false positives
+    - Volatile days (high CV): Lower confidence → catch more real outliers
+
+    Args:
+        intervals: List of price intervals with 'startsAt' and 'total' keys
+
+    Returns:
+        Dict mapping date strings to CV percentage (e.g., 15.0 for 15% CV)
+
+    """
+    daily_prices: dict[str, list[float]] = {}
+
+    for interval in intervals:
+        starts_at = interval.get("startsAt")
+        if starts_at is None:
+            continue
+
+        dt = datetime.fromisoformat(starts_at) if isinstance(starts_at, str) else starts_at
+        date_key = dt.strftime("%Y-%m-%d")
+        price = float(interval["total"])
+        daily_prices.setdefault(date_key, []).append(price)
+
+    # Calculate CV using the shared function from utils/price.py
+    result = {}
+    for date_key, prices in daily_prices.items():
+        cv = calculate_coefficient_of_variation(prices)
+        result[date_key] = cv if cv is not None else 0.0
+    return result
+
+
+def _get_adaptive_confidence_level(
+    interval: dict,
+    daily_cv: dict[str, float],
+) -> float:
+    """
+    Get adaptive confidence level based on daily coefficient of variation (CV).
+
+    Maps daily CV to confidence level:
+    - Low CV (≤10%): High confidence (2.5) → conservative, fewer smoothed
+    - High CV (≥30%): Low confidence (1.5) → aggressive, more smoothed
+    - Between: Linear interpolation
+
+    Uses the same CV calculation as volatility sensors for consistency.
+
+    Args:
+        interval: Price interval dict with 'startsAt' key
+        daily_cv: Dict from _calculate_daily_cv()
+
+    Returns:
+        Confidence level multiplier for std_dev threshold
+
+    """
+    starts_at = interval.get("startsAt")
+    if starts_at is None:
+        return CONFIDENCE_LEVEL_DEFAULT
+
+    dt = datetime.fromisoformat(starts_at) if isinstance(starts_at, str) else starts_at
+    date_key = dt.strftime("%Y-%m-%d")
+
+    cv = daily_cv.get(date_key, 0.0)
+
+    # Linear interpolation between LOW and HIGH CV
+    # Low CV → high confidence (conservative)
+    # High CV → low confidence (aggressive)
+    if cv <= DAILY_CV_LOW:
+        return CONFIDENCE_LEVEL_MAX
+    if cv >= DAILY_CV_HIGH:
+        return CONFIDENCE_LEVEL_MIN
+
+    # Linear interpolation: as CV increases, confidence decreases
+    ratio = (cv - DAILY_CV_LOW) / (DAILY_CV_HIGH - DAILY_CV_LOW)
+    return CONFIDENCE_LEVEL_MAX - (ratio * (CONFIDENCE_LEVEL_MAX - CONFIDENCE_LEVEL_MIN))
+
+
+def _is_daily_extreme(
+    interval: dict,
+    daily_extremes: dict[str, tuple[float, float]],
+    tolerance: float = EXTREMES_PROTECTION_TOLERANCE,
+) -> bool:
+    """
+    Check if an interval's price is at or very near a daily extreme.
+
+    Prices at daily extremes should never be smoothed because:
+    - Daily minimum is the reference for best_price period detection
+    - Daily maximum is the reference for peak_price period detection
+    - Smoothing these would cause periods to miss their most important intervals
+
+    Args:
+        interval: Price interval dict with 'startsAt' and 'total' keys
+        daily_extremes: Dict from _calculate_daily_extremes()
+        tolerance: Relative tolerance for matching (default 0.1%)
+
+    Returns:
+        True if the price is at or very near a daily min or max
+
+    """
+    starts_at = interval.get("startsAt")
+    if starts_at is None:
+        return False
+
+    # Handle both datetime objects and ISO strings
+    dt = datetime.fromisoformat(starts_at) if isinstance(starts_at, str) else starts_at
+
+    date_key = dt.strftime("%Y-%m-%d")
+    if date_key not in daily_extremes:
+        return False
+
+    price = float(interval["total"])
+    daily_min, daily_max = daily_extremes[date_key]
+
+    # Check if price is within tolerance of daily min or max
+    # Using relative tolerance: |price - extreme| <= extreme * tolerance
+    min_threshold = daily_min * (1 + tolerance)
+    max_threshold = daily_max * (1 - tolerance)
+
+    return price <= min_threshold or price >= max_threshold
+
+
 def filter_price_outliers(
     intervals: list[dict],
     flexibility_pct: float,
@@ -260,15 +435,29 @@ def filter_price_outliers(
         Intervals with smoothed prices (marked with _smoothed flag)
 
     """
+    # Convert percentage to ratio once for all comparisons (e.g., 15.0 → 0.15)
+    flexibility_ratio = flexibility_pct / 100
+
+    # Calculate daily extremes to protect reference prices from smoothing
+    # Daily min is the reference for best_price, daily max for peak_price
+    daily_extremes = _calculate_daily_extremes(intervals)
+
+    # Calculate daily coefficient of variation (CV) for adaptive confidence levels
+    # Uses same CV calculation as volatility sensors for consistency
+    # Flat days → conservative smoothing, volatile days → aggressive smoothing
+    daily_cv = _calculate_daily_cv(intervals)
+
+    # Log CV info for debugging (CV is in percentage points, e.g., 15.0 = 15%)
+    cv_info = ", ".join(f"{date}: {cv:.1f}%" for date, cv in sorted(daily_cv.items()))
     _LOGGER.info(
-        "%sSmoothing price outliers: %d intervals, flex=%.1f%%",
+        "%sSmoothing price outliers: %d intervals, flex=%.1f%%, daily CV: %s",
         INDENT_L0,
         len(intervals),
         flexibility_pct,
+        cv_info,
     )
 
-    # Convert percentage to ratio once for all comparisons (e.g., 15.0 → 0.15)
-    flexibility_ratio = flexibility_pct / 100
+    protected_count = 0
 
     result = []
     smoothed_count = 0
@@ -276,6 +465,20 @@ def filter_price_outliers(
     for i, current in enumerate(intervals):
         current_price = current["total"]
 
+        # CRITICAL: Never smooth daily extremes - they are the reference prices!
+        # Smoothing the daily min would break best_price period detection,
+        # smoothing the daily max would break peak_price period detection.
+        if _is_daily_extreme(current, daily_extremes):
+            result.append(current)
+            protected_count += 1
+            _LOGGER_DETAILS.debug(
+                "%sProtected daily extreme at %s: %.2f ct/kWh (not smoothed)",
+                INDENT_L0,
+                current.get("startsAt", f"index {i}"),
+                current_price * 100,
+            )
+            continue
+
         # Get context windows (3 intervals before and after)
         context_before = intervals[max(0, i - MIN_CONTEXT_SIZE) : i]
         context_after = intervals[i + 1 : min(len(intervals), i + 1 + MIN_CONTEXT_SIZE)]
@@ -297,8 +500,11 @@ def filter_price_outliers(
         # Calculate how far current price deviates from expected
         residual = abs(current_price - expected_price)
 
-        # Tolerance based on statistical confidence (2 std dev = 95% confidence)
-        tolerance = stats["std_dev"] * CONFIDENCE_LEVEL
+        # Adaptive confidence level based on daily CV:
+        # - Flat days (low CV): higher confidence (2.5) → fewer false positives
+        # - Volatile days (high CV): lower confidence (1.5) → catch more real spikes
+        confidence_level = _get_adaptive_confidence_level(current, daily_cv)
+        tolerance = stats["std_dev"] * confidence_level
 
         # Not a spike if within tolerance
         if residual <= tolerance:
@@ -332,23 +538,22 @@ def filter_price_outliers(
         smoothed_count += 1
 
         _LOGGER_DETAILS.debug(
-            "%sSmoothed spike at %s: %.2f → %.2f ct/kWh (residual: %.2f, tolerance: %.2f, trend_slope: %.4f)",
+            "%sSmoothed spike at %s: %.2f → %.2f ct/kWh (residual: %.2f, tolerance: %.2f, confidence: %.2f)",
             INDENT_L0,
             current.get("startsAt", f"index {i}"),
             current_price * 100,
             expected_price * 100,
             residual * 100,
             tolerance * 100,
-            stats["trend_slope"] * 100,
+            confidence_level,
         )
 
-    if smoothed_count > 0:
+    if smoothed_count > 0 or protected_count > 0:
         _LOGGER.info(
-            "%sPrice outlier smoothing complete: %d/%d intervals smoothed (%.1f%%)",
+            "%sPrice outlier smoothing complete: %d smoothed, %d protected (daily extremes)",
             INDENT_L0,
             smoothed_count,
-            len(intervals),
-            (smoothed_count / len(intervals)) * 100,
+            protected_count,
         )
 
     return result

custom_components/tibber_prices/coordinator/period_handlers/period_building.py

@@ -3,13 +3,12 @@
 from __future__ import annotations
 
 import logging
+from datetime import date, datetime, timedelta
 from typing import TYPE_CHECKING, Any
 
 from custom_components.tibber_prices.const import PRICE_LEVEL_MAPPING
 
 if TYPE_CHECKING:
-    from datetime import date
-
     from custom_components.tibber_prices.coordinator.time_service import TibberPricesTimeService
 
 from .level_filtering import (
@@ -281,3 +280,428 @@ def filter_periods_by_end_date(periods: list[list[dict]], *, time: TibberPricesT
             filtered.append(period)
 
     return filtered
+
+
+def _categorize_periods_for_supersession(
+    period_summaries: list[dict],
+    today: date,
+    tomorrow: date,
+    late_hour_threshold: int,
+    early_hour_limit: int,
+) -> tuple[list[dict], list[dict], list[dict]]:
+    """Categorize periods into today-late, tomorrow-early, and other."""
+    today_late: list[dict] = []
+    tomorrow_early: list[dict] = []
+    other: list[dict] = []
+
+    for period in period_summaries:
+        period_start = period.get("start")
+        period_end = period.get("end")
+
+        if not period_start or not period_end:
+            other.append(period)
+        # Today late-night periods: START today at or after late_hour_threshold (e.g., 20:00)
+        # Note: period_end could be tomorrow (e.g., 23:30-00:00 spans midnight)
+        elif period_start.date() == today and period_start.hour >= late_hour_threshold:
+            today_late.append(period)
+        # Tomorrow early-morning periods: START tomorrow before early_hour_limit (e.g., 08:00)
+        elif period_start.date() == tomorrow and period_start.hour < early_hour_limit:
+            tomorrow_early.append(period)
+        else:
+            other.append(period)
+
+    return today_late, tomorrow_early, other
+
+
+def _filter_superseded_today_periods(
+    today_late_periods: list[dict],
+    best_tomorrow: dict,
+    best_tomorrow_price: float,
+    improvement_threshold: float,
+) -> list[dict]:
+    """Filter today periods that are superseded by a better tomorrow period."""
+    kept: list[dict] = []
+
+    for today_period in today_late_periods:
+        today_price = today_period.get("price_mean")
+
+        if today_price is None:
+            kept.append(today_period)
+            continue
+
+        # Calculate how much better tomorrow is (as percentage)
+        improvement_pct = ((today_price - best_tomorrow_price) / today_price * 100) if today_price > 0 else 0
+
+        _LOGGER.debug(
+            "Supersession check: Today %s-%s (%.4f) vs Tomorrow %s-%s (%.4f) = %.1f%% improvement (threshold: %.1f%%)",
+            today_period["start"].strftime("%H:%M"),
+            today_period["end"].strftime("%H:%M"),
+            today_price,
+            best_tomorrow["start"].strftime("%H:%M"),
+            best_tomorrow["end"].strftime("%H:%M"),
+            best_tomorrow_price,
+            improvement_pct,
+            improvement_threshold,
+        )
+
+        if improvement_pct >= improvement_threshold:
+            _LOGGER.info(
+                "Period superseded: Today %s-%s (%.2f) replaced by Tomorrow %s-%s (%.2f, %.1f%% better)",
+                today_period["start"].strftime("%H:%M"),
+                today_period["end"].strftime("%H:%M"),
+                today_price,
+                best_tomorrow["start"].strftime("%H:%M"),
+                best_tomorrow["end"].strftime("%H:%M"),
+                best_tomorrow_price,
+                improvement_pct,
+            )
+        else:
+            kept.append(today_period)
+
+    return kept
+
+
+def filter_superseded_periods(
+    period_summaries: list[dict],
+    *,
+    time: TibberPricesTimeService,
+    reverse_sort: bool,
+) -> list[dict]:
+    """
+    Filter out late-night today periods that are superseded by better tomorrow periods.
+
+    When tomorrow's data becomes available, some late-night periods that were found
+    through relaxation may no longer make sense. If tomorrow has a significantly
+    better period in the early morning, the late-night today period is obsolete.
+
+    Example:
+    - Today 23:30-00:00 at 0.70 kr (found via relaxation, was best available)
+    - Tomorrow 04:00-05:30 at 0.50 kr (much better alternative)
+    → The today period is superseded and should be filtered out
+
+    This only applies to best-price periods (reverse_sort=False).
+    Peak-price periods are not filtered this way.
+
+    """
+    from .types import (  # noqa: PLC0415
+        CROSS_DAY_LATE_PERIOD_START_HOUR,
+        CROSS_DAY_MAX_EXTENSION_HOUR,
+        SUPERSESSION_PRICE_IMPROVEMENT_PCT,
+    )
+
+    _LOGGER.debug(
+        "filter_superseded_periods called: %d periods, reverse_sort=%s",
+        len(period_summaries) if period_summaries else 0,
+        reverse_sort,
+    )
+
+    # Only filter for best-price periods
+    if reverse_sort or not period_summaries:
+        return period_summaries
+
+    now = time.now()
+    today = now.date()
+    tomorrow = today + timedelta(days=1)
+
+    # Categorize periods
+    today_late, tomorrow_early, other = _categorize_periods_for_supersession(
+        period_summaries,
+        today,
+        tomorrow,
+        CROSS_DAY_LATE_PERIOD_START_HOUR,
+        CROSS_DAY_MAX_EXTENSION_HOUR,
+    )
+
+    _LOGGER.debug(
+        "Supersession categorization: today_late=%d, tomorrow_early=%d, other=%d",
+        len(today_late),
+        len(tomorrow_early),
+        len(other),
+    )
+
+    # If no tomorrow early periods, nothing to compare against
+    if not tomorrow_early:
+        _LOGGER.debug("No tomorrow early periods - skipping supersession check")
+        return period_summaries
+
+    # Find the best tomorrow early period (lowest mean price)
+    best_tomorrow = min(tomorrow_early, key=lambda p: p.get("price_mean", float("inf")))
+    best_tomorrow_price = best_tomorrow.get("price_mean")
+
+    if best_tomorrow_price is None:
+        return period_summaries
+
+    # Filter superseded today periods
+    kept_today = _filter_superseded_today_periods(
+        today_late,
+        best_tomorrow,
+        best_tomorrow_price,
+        SUPERSESSION_PRICE_IMPROVEMENT_PCT,
+    )
+
+    # Reconstruct and sort by start time
+    result = other + kept_today + tomorrow_early
+    result.sort(key=lambda p: p.get("start") or time.now())
+
+    return result
+
+
+def _is_period_eligible_for_extension(
+    period: dict,
+    today: date,
+    late_hour_threshold: int,
+) -> bool:
+    """
+    Check if a period is eligible for cross-day extension.
+
+    Eligibility criteria:
+    - Period has valid start and end times
+    - Period ends on today (not yesterday or tomorrow)
+    - Period ends late (after late_hour_threshold, e.g. 20:00)
+
+    """
+    period_end = period.get("end")
+    period_start = period.get("start")
+
+    if not period_end or not period_start:
+        return False
+
+    if period_end.date() != today:
+        return False
+
+    return period_end.hour >= late_hour_threshold
+
+
+def _find_extension_intervals(
+    period_end: datetime,
+    price_lookup: dict[str, dict],
+    criteria: Any,
+    max_extension_time: datetime,
+    interval_duration: timedelta,
+) -> list[dict]:
+    """
+    Find consecutive intervals after period_end that meet criteria.
+
+    Iterates forward from period_end, adding intervals while they
+    meet the flex and min_distance criteria. Stops at first failure
+    or when reaching max_extension_time.
+
+    """
+    from .level_filtering import check_interval_criteria  # noqa: PLC0415
+
+    extension_intervals: list[dict] = []
+    check_time = period_end
+
+    while check_time < max_extension_time:
+        price_data = price_lookup.get(check_time.isoformat())
+        if not price_data:
+            break  # No more data
+
+        price = float(price_data["total"])
+        in_flex, meets_min_distance = check_interval_criteria(price, criteria)
+
+        if not (in_flex and meets_min_distance):
+            break  # Criteria no longer met
+
+        extension_intervals.append(price_data)
+        check_time = check_time + interval_duration
+
+    return extension_intervals
+
+
+def _collect_original_period_prices(
+    period_start: datetime,
+    period_end: datetime,
+    price_lookup: dict[str, dict],
+    interval_duration: timedelta,
+) -> list[float]:
+    """Collect prices from original period for CV calculation."""
+    prices: list[float] = []
+    current = period_start
+    while current < period_end:
+        price_data = price_lookup.get(current.isoformat())
+        if price_data:
+            prices.append(float(price_data["total"]))
+        current = current + interval_duration
+    return prices
+
+
+def _build_extended_period(
+    period: dict,
+    extension_intervals: list[dict],
+    combined_prices: list[float],
+    combined_cv: float,
+    interval_duration: timedelta,
+) -> dict:
+    """Create extended period dict with updated statistics."""
+    period_start = period["start"]
+    period_end = period["end"]
+    new_end = period_end + (interval_duration * len(extension_intervals))
+
+    extended = period.copy()
+    extended["end"] = new_end
+    extended["duration_minutes"] = int((new_end - period_start).total_seconds() / 60)
+    extended["period_interval_count"] = len(combined_prices)
+    extended["cross_day_extended"] = True
+    extended["cross_day_extension_intervals"] = len(extension_intervals)
+
+    # Recalculate price statistics
+    extended["price_min"] = min(combined_prices)
+    extended["price_max"] = max(combined_prices)
+    extended["price_mean"] = sum(combined_prices) / len(combined_prices)
+    extended["price_spread"] = extended["price_max"] - extended["price_min"]
+    extended["price_coefficient_variation_%"] = round(combined_cv, 1)
+
+    return extended
+
+
+def extend_periods_across_midnight(
+    period_summaries: list[dict],
+    all_prices: list[dict],
+    price_context: dict[str, Any],
+    *,
+    time: TibberPricesTimeService,
+    reverse_sort: bool,
+) -> list[dict]:
+    """
+    Extend late-night periods across midnight if favorable prices continue.
+
+    When a period ends close to midnight and tomorrow's data shows continued
+    favorable prices, extend the period into the next day. This prevents
+    artificial period breaks at midnight when it's actually better to continue.
+
+    Example: Best price period 22:00-23:45 today could extend to 04:00 tomorrow
+    if prices remain low overnight.
+
+    Rules:
+    - Only extends periods ending after CROSS_DAY_LATE_PERIOD_START_HOUR (20:00)
+    - Won't extend beyond CROSS_DAY_MAX_EXTENSION_HOUR (08:00) next day
+    - Extension must pass same flex criteria as original period
+    - Quality Gate (CV check) applies to extended period
+
+    Args:
+        period_summaries: List of period summary dicts (already processed)
+        all_prices: All price intervals including tomorrow
+        price_context: Dict with ref_prices, avg_prices, flex, min_distance_from_avg
+        time: Time service instance
+        reverse_sort: True for peak price, False for best price
+
+    Returns:
+        Updated list of period summaries with extensions applied
+
+    """
+    from custom_components.tibber_prices.utils.price import calculate_coefficient_of_variation  # noqa: PLC0415
+
+    from .types import (  # noqa: PLC0415
+        CROSS_DAY_LATE_PERIOD_START_HOUR,
+        CROSS_DAY_MAX_EXTENSION_HOUR,
+        PERIOD_MAX_CV,
+        TibberPricesIntervalCriteria,
+    )
+
+    if not period_summaries or not all_prices:
+        return period_summaries
+
+    # Build price lookup by timestamp
+    price_lookup: dict[str, dict] = {}
+    for price_data in all_prices:
+        interval_time = time.get_interval_time(price_data)
+        if interval_time:
+            price_lookup[interval_time.isoformat()] = price_data
+
+    ref_prices = price_context.get("ref_prices", {})
+    avg_prices = price_context.get("avg_prices", {})
+    flex = price_context.get("flex", 0.15)
+    min_distance = price_context.get("min_distance_from_avg", 0)
+
+    now = time.now()
+    today = now.date()
+    tomorrow = today + timedelta(days=1)
+    interval_duration = time.get_interval_duration()
+
+    # Max extension time (e.g., 08:00 tomorrow)
+    max_extension_time = time.start_of_local_day(now) + timedelta(days=1, hours=CROSS_DAY_MAX_EXTENSION_HOUR)
+
+    extended_summaries = []
+
+    for period in period_summaries:
+        # Check eligibility for extension
+        if not _is_period_eligible_for_extension(period, today, CROSS_DAY_LATE_PERIOD_START_HOUR):
+            extended_summaries.append(period)
+            continue
+
+        # Get tomorrow's reference prices
+        tomorrow_ref = ref_prices.get(tomorrow) or ref_prices.get(str(tomorrow))
+        tomorrow_avg = avg_prices.get(tomorrow) or avg_prices.get(str(tomorrow))
+
+        if tomorrow_ref is None or tomorrow_avg is None:
+            extended_summaries.append(period)
+            continue
+
+        # Set up criteria for extension check
+        criteria = TibberPricesIntervalCriteria(
+            ref_price=tomorrow_ref,
+            avg_price=tomorrow_avg,
+            flex=flex,
+            min_distance_from_avg=min_distance,
+            reverse_sort=reverse_sort,
+        )
+
+        # Find extension intervals
+        extension_intervals = _find_extension_intervals(
+            period["end"],
+            price_lookup,
+            criteria,
+            max_extension_time,
+            interval_duration,
+        )
+
+        if not extension_intervals:
+            extended_summaries.append(period)
+            continue
+
+        # Collect all prices for CV check
+        original_prices = _collect_original_period_prices(
+            period["start"],
+            period["end"],
+            price_lookup,
+            interval_duration,
+        )
+        extension_prices = [float(p["total"]) for p in extension_intervals]
+        combined_prices = original_prices + extension_prices
+
+        # Quality Gate: Check CV of extended period
+        combined_cv = calculate_coefficient_of_variation(combined_prices)
+
+        if combined_cv is not None and combined_cv <= PERIOD_MAX_CV:
+            # Extension passes quality gate
+            extended_period = _build_extended_period(
+                period,
+                extension_intervals,
+                combined_prices,
+                combined_cv,
+                interval_duration,
+            )
+
+            _LOGGER.info(
+                "Cross-day extension: Period %s-%s extended to %s (+%d intervals, CV=%.1f%%)",
+                period["start"].strftime("%H:%M"),
+                period["end"].strftime("%H:%M"),
+                extended_period["end"].strftime("%H:%M"),
+                len(extension_intervals),
+                combined_cv,
+            )
+            extended_summaries.append(extended_period)
+        else:
+            # Extension would exceed quality gate
+            _LOGGER_DETAILS.debug(
+                "%sCross-day extension rejected for period %s-%s: CV=%.1f%% > %.1f%%",
+                INDENT_L0,
+                period["start"].strftime("%H:%M"),
+                period["end"].strftime("%H:%M"),
+                combined_cv or 0,
+                PERIOD_MAX_CV,
+            )
+            extended_summaries.append(period)
+
+    return extended_summaries

custom_components/tibber_prices/coordinator/period_handlers/period_overlap.py

@@ -17,6 +17,41 @@ INDENT_L1 = "  "  # Nested logic / loop iterations
 INDENT_L2 = "    "  # Deeper nesting
 
 
+def _estimate_merged_cv(period1: dict, period2: dict) -> float | None:
+    """
+    Estimate the CV of a merged period from two period summaries.
+
+    Since we don't have the raw prices, we estimate using the combined min/max range.
+    This is a conservative estimate - the actual CV could be higher or lower.
+
+    Formula: CV ≈ (range / 2) / mean * 100
+    Where range = max - min, mean = (min + max) / 2
+
+    This approximation assumes roughly uniform distribution within the range.
+    """
+    p1_min = period1.get("price_min")
+    p1_max = period1.get("price_max")
+    p2_min = period2.get("price_min")
+    p2_max = period2.get("price_max")
+
+    if None in (p1_min, p1_max, p2_min, p2_max):
+        return None
+
+    # Cast to float - None case handled above
+    combined_min = min(float(p1_min), float(p2_min))  # type: ignore[arg-type]
+    combined_max = max(float(p1_max), float(p2_max))  # type: ignore[arg-type]
+
+    if combined_min <= 0:
+        return None
+
+    combined_mean = (combined_min + combined_max) / 2
+    price_range = combined_max - combined_min
+
+    # CV estimate based on range (assuming uniform distribution)
+    # For uniform distribution: std_dev ≈ range / sqrt(12) ≈ range / 3.46
+    return (price_range / 3.46) / combined_mean * 100
+
+
 def recalculate_period_metadata(periods: list[dict], *, time: TibberPricesTimeService) -> None:
     """
     Recalculate period metadata after merging periods.
@@ -105,7 +140,7 @@ def merge_adjacent_periods(period1: dict, period2: dict) -> dict:
         "period2_end": period2["end"].isoformat(),
     }
 
-    _LOGGER.debug(
+    _LOGGER_DETAILS.debug(
         "%sMerged periods: %s-%s + %s-%s → %s-%s (duration: %d min)",
         INDENT_L2,
         period1["start"].strftime("%H:%M"),
@@ -120,6 +155,119 @@ def merge_adjacent_periods(period1: dict, period2: dict) -> dict:
     return merged
 
 
+def _check_merge_quality_gate(periods_to_merge: list[tuple[int, dict]], relaxed: dict) -> bool:
+    """
+    Check if merging would create a period that's too heterogeneous.
+
+    Returns True if merge is allowed, False if blocked by Quality Gate.
+    """
+    from .types import PERIOD_MAX_CV  # noqa: PLC0415
+
+    relaxed_start = relaxed["start"]
+    relaxed_end = relaxed["end"]
+
+    for _idx, existing in periods_to_merge:
+        estimated_cv = _estimate_merged_cv(existing, relaxed)
+        if estimated_cv is not None and estimated_cv > PERIOD_MAX_CV:
+            _LOGGER.debug(
+                "Merge blocked by Quality Gate: %s-%s + %s-%s would have CV≈%.1f%% (max: %.1f%%)",
+                existing["start"].strftime("%H:%M"),
+                existing["end"].strftime("%H:%M"),
+                relaxed_start.strftime("%H:%M"),
+                relaxed_end.strftime("%H:%M"),
+                estimated_cv,
+                PERIOD_MAX_CV,
+            )
+            return False
+    return True
+
+
+def _would_swallow_existing(relaxed: dict, existing_periods: list[dict]) -> bool:
+    """
+    Check if the relaxed period would "swallow" any existing period.
+
+    A period is "swallowed" if the new relaxed period completely contains it.
+    In this case, we should NOT merge - the existing smaller period is more
+    homogeneous and should be preserved.
+
+    This prevents relaxation from replacing good small periods with larger,
+    more heterogeneous ones.
+
+    Returns:
+        True if any existing period would be swallowed (merge should be blocked)
+        False if safe to proceed with merge evaluation
+
+    """
+    relaxed_start = relaxed["start"]
+    relaxed_end = relaxed["end"]
+
+    for existing in existing_periods:
+        existing_start = existing["start"]
+        existing_end = existing["end"]
+
+        # Check if relaxed completely contains existing
+        if relaxed_start <= existing_start and relaxed_end >= existing_end:
+            _LOGGER.debug(
+                "Blocking merge: %s-%s would swallow %s-%s (keeping smaller period)",
+                relaxed_start.strftime("%H:%M"),
+                relaxed_end.strftime("%H:%M"),
+                existing_start.strftime("%H:%M"),
+                existing_end.strftime("%H:%M"),
+            )
+            return True
+
+    return False
+
+
+def _is_duplicate_period(relaxed: dict, existing_periods: list[dict], tolerance_seconds: int = 60) -> bool:
+    """Check if relaxed period is a duplicate of any existing period."""
+    relaxed_start = relaxed["start"]
+    relaxed_end = relaxed["end"]
+
+    for existing in existing_periods:
+        if (
+            abs((relaxed_start - existing["start"]).total_seconds()) < tolerance_seconds
+            and abs((relaxed_end - existing["end"]).total_seconds()) < tolerance_seconds
+        ):
+            _LOGGER_DETAILS.debug(
+                "%sSkipping duplicate period %s-%s (already exists)",
+                INDENT_L1,
+                relaxed_start.strftime("%H:%M"),
+                relaxed_end.strftime("%H:%M"),
+            )
+            return True
+    return False
+
+
+def _find_adjacent_or_overlapping(relaxed: dict, existing_periods: list[dict]) -> list[tuple[int, dict]]:
+    """Find all periods that are adjacent to or overlapping with the relaxed period."""
+    relaxed_start = relaxed["start"]
+    relaxed_end = relaxed["end"]
+    periods_to_merge = []
+
+    for idx, existing in enumerate(existing_periods):
+        existing_start = existing["start"]
+        existing_end = existing["end"]
+
+        # Check if adjacent (no gap) or overlapping
+        is_adjacent = relaxed_end == existing_start or relaxed_start == existing_end
+        is_overlapping = relaxed_start < existing_end and relaxed_end > existing_start
+
+        if is_adjacent or is_overlapping:
+            periods_to_merge.append((idx, existing))
+            _LOGGER_DETAILS.debug(
+                "%sPeriod %s-%s %s with existing period %s-%s",
+                INDENT_L1,
+                relaxed_start.strftime("%H:%M"),
+                relaxed_end.strftime("%H:%M"),
+                "overlaps" if is_overlapping else "is adjacent to",
+                existing_start.strftime("%H:%M"),
+                existing_end.strftime("%H:%M"),
+            )
+
+    return periods_to_merge
+
+
 def resolve_period_overlaps(
     existing_periods: list[dict],
     new_relaxed_periods: list[dict],
@@ -130,6 +278,10 @@ def resolve_period_overlaps(
     Adjacent or overlapping periods are merged into single continuous periods.
     The newer period's relaxation attributes override the older period's.
 
+    Quality Gate: Merging is blocked if the combined period would have
+    an estimated CV above PERIOD_MAX_CV (25%), to prevent creating
+    periods with excessive internal price variation.
+
     This function is called incrementally after each relaxation phase:
     - Phase 1: existing = baseline, new = first relaxation
     - Phase 2: existing = baseline + phase 1, new = second relaxation
@@ -145,7 +297,7 @@ def resolve_period_overlaps(
         - new_periods_count: Number of new periods added (some may have been merged)
 
     """
-    _LOGGER.debug(
+    _LOGGER_DETAILS.debug(
         "%sresolve_period_overlaps called: existing=%d, new=%d",
         INDENT_L0,
         len(existing_periods),
@@ -167,58 +319,44 @@ def resolve_period_overlaps(
         relaxed_end = relaxed["end"]
 
         # Check if this period is duplicate (exact match within tolerance)
-        tolerance_seconds = 60  # 1 minute tolerance
-        is_duplicate = False
-        for existing in merged:
-            if (
-                abs((relaxed_start - existing["start"]).total_seconds()) < tolerance_seconds
-                and abs((relaxed_end - existing["end"]).total_seconds()) < tolerance_seconds
-            ):
-                is_duplicate = True
-                _LOGGER.debug(
-                    "%sSkipping duplicate period %s-%s (already exists)",
-                    INDENT_L1,
-                    relaxed_start.strftime("%H:%M"),
-                    relaxed_end.strftime("%H:%M"),
-                )
-                break
+        if _is_duplicate_period(relaxed, merged):
+            continue
 
-        if is_duplicate:
+        # Check if this period would "swallow" an existing smaller period
+        # In that case, skip it - the smaller existing period is more homogeneous
+        if _would_swallow_existing(relaxed, merged):
             continue
 
         # Find periods that are adjacent or overlapping (should be merged)
-        periods_to_merge = []
-        for idx, existing in enumerate(merged):
-            existing_start = existing["start"]
-            existing_end = existing["end"]
-
-            # Check if adjacent (no gap) or overlapping
-            is_adjacent = relaxed_end == existing_start or relaxed_start == existing_end
-            is_overlapping = relaxed_start < existing_end and relaxed_end > existing_start
-
-            if is_adjacent or is_overlapping:
-                periods_to_merge.append((idx, existing))
-                _LOGGER.debug(
-                    "%sPeriod %s-%s %s with existing period %s-%s",
-                    INDENT_L1,
-                    relaxed_start.strftime("%H:%M"),
-                    relaxed_end.strftime("%H:%M"),
-                    "overlaps" if is_overlapping else "is adjacent to",
-                    existing_start.strftime("%H:%M"),
-                    existing_end.strftime("%H:%M"),
-                )
+        periods_to_merge = _find_adjacent_or_overlapping(relaxed, merged)
 
         if not periods_to_merge:
             # No merge needed - add as new period
             merged.append(relaxed)
             periods_added += 1
-            _LOGGER.debug(
+            _LOGGER_DETAILS.debug(
                 "%sAdded new period %s-%s (no overlap/adjacency)",
                 INDENT_L1,
                 relaxed_start.strftime("%H:%M"),
                 relaxed_end.strftime("%H:%M"),
             )
-        else:
+            continue
+
+        # Quality Gate: Check if merging would create a period that's too heterogeneous
+        should_merge = _check_merge_quality_gate(periods_to_merge, relaxed)
+
+        if not should_merge:
+            # Don't merge - add as separate period instead
+            merged.append(relaxed)
+            periods_added += 1
+            _LOGGER_DETAILS.debug(
+                "%sAdded new period %s-%s separately (merge blocked by CV gate)",
+                INDENT_L1,
+                relaxed_start.strftime("%H:%M"),
+                relaxed_end.strftime("%H:%M"),
+            )
+            continue
+
         # Merge with all adjacent/overlapping periods
         # Start with the new relaxed period
         merged_period = relaxed.copy()

custom_components/tibber_prices/coordinator/period_handlers/period_statistics.py

@@ -19,6 +19,7 @@ from custom_components.tibber_prices.utils.average import calculate_median
 from custom_components.tibber_prices.utils.price import (
     aggregate_period_levels,
     aggregate_period_ratings,
+    calculate_coefficient_of_variation,
     calculate_volatility_level,
 )
 
@@ -169,6 +170,7 @@ def build_period_summary_dict(
         "price_min": stats.price_min,
         "price_max": stats.price_max,
         "price_spread": stats.price_spread,
+        "price_coefficient_variation_%": stats.coefficient_of_variation,
         "volatility": stats.volatility,
         # 4. Price differences will be added below if available
         # 5. Detail information (additional context)
@@ -314,7 +316,10 @@ def extract_period_summaries(
         # Extract prices for volatility calculation (coefficient of variation)
         prices_for_volatility = [float(p["total"]) for p in period_price_data if "total" in p]
 
-        # Calculate volatility (categorical) and aggregated rating difference (numeric)
+        # Calculate CV (numeric) for quality gate checks
+        period_cv = calculate_coefficient_of_variation(prices_for_volatility)
+
+        # Calculate volatility (categorical) using thresholds
         volatility = calculate_volatility_level(
             prices_for_volatility,
             threshold_moderate=thresholds.threshold_volatility_moderate,
@@ -348,6 +353,7 @@ def extract_period_summaries(
             price_max=price_stats["price_max"],
             price_spread=price_stats["price_spread"],
             volatility=volatility,
+            coefficient_of_variation=round(period_cv, 1) if period_cv is not None else None,
             period_price_diff=period_price_diff,
             period_price_diff_pct=period_price_diff_pct,
         )

custom_components/tibber_prices/coordinator/period_handlers/relaxation.py

@@ -11,7 +11,7 @@ if TYPE_CHECKING:
 
     from custom_components.tibber_prices.coordinator.time_service import TibberPricesTimeService
 
-    from .types import TibberPricesPeriodConfig
+from custom_components.tibber_prices.utils.price import calculate_coefficient_of_variation
 
 from .period_overlap import (
     recalculate_period_metadata,
@@ -21,6 +21,8 @@ from .types import (
     INDENT_L0,
     INDENT_L1,
     INDENT_L2,
+    PERIOD_MAX_CV,
+    TibberPricesPeriodConfig,
 )
 
 _LOGGER = logging.getLogger(__name__)
@@ -32,6 +34,125 @@ FLEX_WARNING_THRESHOLD_RELAXATION = 0.25  # 25% - INFO: suggest lowering to 15-2
 MAX_FLEX_HARD_LIMIT = 0.50  # 50% - hard maximum flex value
 FLEX_HIGH_THRESHOLD_RELAXATION = 0.30  # 30% - WARNING: base flex too high for relaxation mode
 
+# Min duration fallback constants
+# When all relaxation phases are exhausted and still no periods found,
+# gradually reduce min_period_length to find at least something
+MIN_DURATION_FALLBACK_MINIMUM = 30  # Minimum period length to try (30 min = 2 intervals)
+MIN_DURATION_FALLBACK_STEP = 15  # Reduce by 15 min (1 interval) each step
+
+
+def _check_period_quality(
+    period: dict, all_prices: list[dict], *, time: TibberPricesTimeService
+) -> tuple[bool, float | None]:
+    """
+    Check if a period passes the quality gate (internal CV not too high).
+
+    The Quality Gate prevents relaxation from creating periods with too much
+    internal price variation. A "best price period" with prices ranging from
+    0.5 to 1.0 kr/kWh is not useful - user can't trust it's actually "best".
+
+    Args:
+        period: Period summary dict with "start" and "end" datetime
+        all_prices: All price intervals (to look up prices for CV calculation)
+        time: Time service for interval time parsing
+
+    Returns:
+        Tuple of (passes_quality_gate, cv_value)
+        - passes_quality_gate: True if CV <= PERIOD_MAX_CV
+        - cv_value: Calculated CV as percentage, or None if not calculable
+
+    """
+    start_time = period.get("start")
+    end_time = period.get("end")
+
+    if not start_time or not end_time:
+        return True, None  # Can't check, assume OK
+
+    # Build lookup for prices
+    price_lookup: dict[str, float] = {}
+    for price_data in all_prices:
+        interval_time = time.get_interval_time(price_data)
+        if interval_time:
+            price_lookup[interval_time.isoformat()] = float(price_data["total"])
+
+    # Collect prices within the period
+    period_prices: list[float] = []
+    interval_duration = time.get_interval_duration()
+
+    current = start_time
+    while current < end_time:
+        price = price_lookup.get(current.isoformat())
+        if price is not None:
+            period_prices.append(price)
+        current = current + interval_duration
+
+    # Need at least 2 prices to calculate CV (same as MIN_PRICES_FOR_VOLATILITY in price.py)
+    min_prices_for_cv = 2
+    if len(period_prices) < min_prices_for_cv:
+        return True, None  # Too few prices to calculate CV
+
+    cv = calculate_coefficient_of_variation(period_prices)
+    if cv is None:
+        return True, None
+
+    passes = cv <= PERIOD_MAX_CV
+    return passes, cv
+
+
+def _count_quality_periods(
+    periods: list[dict],
+    all_prices: list[dict],
+    prices_by_day: dict[date, list[dict]],
+    min_periods: int,
+    *,
+    time: TibberPricesTimeService,
+) -> tuple[int, int]:
+    """
+    Count days meeting requirement when considering quality gate.
+
+    Only periods passing the quality gate (CV <= PERIOD_MAX_CV) are counted
+    towards meeting the min_periods requirement.
+
+    Args:
+        periods: List of all periods
+        all_prices: All price intervals
+        prices_by_day: Price intervals grouped by day
+        min_periods: Target periods per day
+        time: Time service
+
+    Returns:
+        Tuple of (days_meeting_requirement, total_quality_periods)
+
+    """
+    periods_by_day = group_periods_by_day(periods)
+    days_meeting_requirement = 0
+    total_quality_periods = 0
+
+    for day in sorted(prices_by_day.keys()):
+        day_periods = periods_by_day.get(day, [])
+        quality_count = 0
+
+        for period in day_periods:
+            passes, cv = _check_period_quality(period, all_prices, time=time)
+            if passes:
+                quality_count += 1
+            else:
+                _LOGGER_DETAILS.debug(
+                    "%s      Day %s: Period %s-%s REJECTED by quality gate (CV=%.1f%% > %.1f%%)",
+                    INDENT_L2,
+                    day,
+                    period.get("start", "?").strftime("%H:%M") if hasattr(period.get("start"), "strftime") else "?",
+                    period.get("end", "?").strftime("%H:%M") if hasattr(period.get("end"), "strftime") else "?",
+                    cv or 0,
+                    PERIOD_MAX_CV,
+                )
+
+        total_quality_periods += quality_count
+        if quality_count >= min_periods:
+            days_meeting_requirement += 1
+
+    return days_meeting_requirement, total_quality_periods
+
 
 def group_periods_by_day(periods: list[dict]) -> dict[date, list[dict]]:
     """
@@ -137,7 +258,167 @@ def group_prices_by_day(all_prices: list[dict], *, time: TibberPricesTimeService
     return prices_by_day
 
 
-def calculate_periods_with_relaxation(  # noqa: PLR0913, PLR0915 - Per-day relaxation requires many parameters and statements
+def _try_min_duration_fallback(
+    *,
+    config: TibberPricesPeriodConfig,
+    existing_periods: list[dict],
+    prices_by_day: dict[date, list[dict]],
+    time: TibberPricesTimeService,
+) -> tuple[dict[str, Any] | None, dict[str, Any]]:
+    """
+    Try reducing min_period_length to find periods when relaxation is exhausted.
+
+    This is a LAST RESORT mechanism. It only activates when:
+    1. All relaxation phases have been tried
+    2. Some days STILL have zero periods (not just below min_periods)
+
+    The fallback progressively reduces min_period_length:
+    - 60 min (default) → 45 min → 30 min (minimum)
+
+    It does NOT reduce below 30 min (2 intervals) because a single 15-min
+    interval is essentially just the daily min/max price - not a "period".
+
+    Args:
+        config: Period configuration
+        existing_periods: Periods found so far (from relaxation)
+        prices_by_day: Price intervals grouped by day
+        time: Time service instance
+
+    Returns:
+        Tuple of (result dict with periods, metadata dict) or (None, empty metadata)
+
+    """
+    from .core import calculate_periods  # noqa: PLC0415 - Avoid circular import
+
+    metadata: dict[str, Any] = {"phases_used": [], "fallback_active": False}
+
+    # Only try fallback if current min_period_length > minimum
+    if config.min_period_length <= MIN_DURATION_FALLBACK_MINIMUM:
+        return None, metadata
+
+    # Check which days have ZERO periods (not just below target)
+    existing_by_day = group_periods_by_day(existing_periods)
+    days_with_zero_periods = [day for day in prices_by_day if not existing_by_day.get(day)]
+
+    if not days_with_zero_periods:
+        _LOGGER_DETAILS.debug(
+            "%sMin duration fallback: All days have at least one period - no fallback needed",
+            INDENT_L1,
+        )
+        return None, metadata
+
+    _LOGGER.info(
+        "Min duration fallback: %d day(s) have zero periods, trying shorter min_period_length...",
+        len(days_with_zero_periods),
+    )
+
+    # Try progressively shorter min_period_length
+    current_min_duration = config.min_period_length
+    fallback_periods: list[dict] = []
+
+    while current_min_duration > MIN_DURATION_FALLBACK_MINIMUM:
+        current_min_duration = max(
+            current_min_duration - MIN_DURATION_FALLBACK_STEP,
+            MIN_DURATION_FALLBACK_MINIMUM,
+        )
+
+        _LOGGER_DETAILS.debug(
+            "%sTrying min_period_length=%d min for days with zero periods",
+            INDENT_L2,
+            current_min_duration,
+        )
+
+        # Create modified config with shorter min_period_length
+        # Use maxed-out flex (50%) since we're in fallback mode
+        fallback_config = TibberPricesPeriodConfig(
+            reverse_sort=config.reverse_sort,
+            flex=MAX_FLEX_HARD_LIMIT,  # Max flex
+            min_distance_from_avg=0,  # Disable min_distance in fallback
+            min_period_length=current_min_duration,
+            threshold_low=config.threshold_low,
+            threshold_high=config.threshold_high,
+            threshold_volatility_moderate=config.threshold_volatility_moderate,
+            threshold_volatility_high=config.threshold_volatility_high,
+            threshold_volatility_very_high=config.threshold_volatility_very_high,
+            level_filter=None,  # Disable level filter
+            gap_count=config.gap_count,
+        )
+
+        # Try to find periods for days with zero periods
+        for day in days_with_zero_periods:
+            day_prices = prices_by_day.get(day, [])
+            if not day_prices:
+                continue
+
+            try:
+                day_result = calculate_periods(
+                    day_prices,
+                    config=fallback_config,
+                    time=time,
+                )
+
+                day_periods = day_result.get("periods", [])
+                if day_periods:
+                    # Mark periods with fallback metadata
+                    for period in day_periods:
+                        period["duration_fallback_active"] = True
+                        period["duration_fallback_min_length"] = current_min_duration
+                        period["relaxation_active"] = True
+                        period["relaxation_level"] = f"duration_fallback={current_min_duration}min"
+
+                    fallback_periods.extend(day_periods)
+                    _LOGGER.info(
+                        "Min duration fallback: Found %d period(s) for %s at min_length=%d min",
+                        len(day_periods),
+                        day,
+                        current_min_duration,
+                    )
+
+            except (KeyError, ValueError, TypeError) as err:
+                _LOGGER.warning(
+                    "Error during min duration fallback for %s: %s",
+                    day,
+                    err,
+                )
+                continue
+
+        # If we found periods for all zero-period days, we can stop
+        if fallback_periods:
+            # Remove days that now have periods from the list
+            fallback_by_day = group_periods_by_day(fallback_periods)
+            days_with_zero_periods = [day for day in days_with_zero_periods if not fallback_by_day.get(day)]
+
+            if not days_with_zero_periods:
+                break
+
+    if fallback_periods:
+        # Merge with existing periods
+        # resolve_period_overlaps merges adjacent/overlapping periods
+        merged_periods, _new_count = resolve_period_overlaps(
+            existing_periods,
+            fallback_periods,
+        )
+        recalculate_period_metadata(merged_periods, time=time)
+
+        metadata["fallback_active"] = True
+        metadata["phases_used"] = [f"duration_fallback (min_length={current_min_duration}min)"]
+
+        _LOGGER.info(
+            "Min duration fallback complete: Added %d period(s), total now %d",
+            len(fallback_periods),
+            len(merged_periods),
+        )
+
+        return {"periods": merged_periods}, metadata
+
+    _LOGGER.warning(
+        "Min duration fallback: Still %d day(s) with zero periods after trying all durations",
+        len(days_with_zero_periods),
+    )
+    return None, metadata
+
+
+def calculate_periods_with_relaxation(  # noqa: PLR0912, PLR0913, PLR0915 - Per-day relaxation requires many parameters and branches
     all_prices: list[dict],
     *,
     config: TibberPricesPeriodConfig,
@@ -185,6 +466,9 @@ def calculate_periods_with_relaxation(  # noqa: PLR0913, PLR0915 - Per-day relax
     from .core import (  # noqa: PLC0415
         calculate_periods,
     )
+    from .period_building import (  # noqa: PLC0415
+        filter_superseded_periods,
+    )
 
     # Compact INFO-level summary
     period_type = "PEAK PRICE" if config.reverse_sort else "BEST PRICE"
@@ -338,6 +622,37 @@ def calculate_periods_with_relaxation(  # noqa: PLR0913, PLR0915 - Per-day relax
             period_count = len(day_periods)
             if period_count >= min_periods:
                 days_meeting_requirement += 1
+
+        # === MIN DURATION FALLBACK ===
+        # If still no periods after relaxation, try reducing min_period_length
+        # This is a last resort to ensure users always get SOME period
+        if days_meeting_requirement < total_days and config.min_period_length > MIN_DURATION_FALLBACK_MINIMUM:
+            _LOGGER.info(
+                "Relaxation incomplete (%d/%d days). Trying min_duration fallback...",
+                days_meeting_requirement,
+                total_days,
+            )
+
+            fallback_result, fallback_metadata = _try_min_duration_fallback(
+                config=config,
+                existing_periods=all_periods,
+                prices_by_day=prices_by_day,
+                time=time,
+            )
+
+            if fallback_result:
+                all_periods = fallback_result["periods"]
+                all_phases_used.extend(fallback_metadata.get("phases_used", []))
+
+                # Recount after fallback
+                periods_by_day = group_periods_by_day(all_periods)
+                days_meeting_requirement = 0
+                for day in sorted(prices_by_day.keys()):
+                    day_periods = periods_by_day.get(day, [])
+                    period_count = len(day_periods)
+                    if period_count >= min_periods:
+                        days_meeting_requirement += 1
+
     elif enable_relaxation:
         _LOGGER_DETAILS.debug(
             "%sAll %d days met target with baseline - no relaxation needed",
@@ -351,6 +666,14 @@ def calculate_periods_with_relaxation(  # noqa: PLR0913, PLR0915 - Per-day relax
     # Recalculate metadata for combined periods
     recalculate_period_metadata(all_periods, time=time)
 
+    # Apply cross-day supersession filter (only for best-price periods)
+    # This removes late-night today periods that are superseded by better tomorrow alternatives
+    all_periods = filter_superseded_periods(
+        all_periods,
+        time=time,
+        reverse_sort=config.reverse_sort,
+    )
+
     # Build final result
     final_result = baseline_result.copy()
     final_result["periods"] = all_periods
@@ -491,22 +814,10 @@ def relax_all_prices(  # noqa: PLR0913 - Comprehensive filter relaxation require
             new_relaxed_periods=new_periods,
         )
 
-        # Count periods per day to check if requirement met
-        periods_by_day = group_periods_by_day(combined)
-        days_meeting_requirement = 0
-
-        for day in sorted(prices_by_day.keys()):
-            day_periods = periods_by_day.get(day, [])
-            period_count = len(day_periods)
-            if period_count >= min_periods:
-                days_meeting_requirement += 1
-
-            _LOGGER_DETAILS.debug(
-                "%s      Day %s: %d periods%s",
-                INDENT_L2,
-                day,
-                period_count,
-                " ✓" if period_count >= min_periods else f" (need {min_periods})",
+        # Count periods per day with QUALITY GATE check
+        # Only periods with CV <= PERIOD_MAX_CV count towards min_periods requirement
+        days_meeting_requirement, quality_period_count = _count_quality_periods(
+            combined, all_prices, prices_by_day, min_periods, time=time
         )
 
         total_periods = len(combined)

custom_components/tibber_prices/coordinator/period_handlers/types.py

@@ -15,6 +15,24 @@ from custom_components.tibber_prices.const import (
     DEFAULT_VOLATILITY_THRESHOLD_VERY_HIGH,
 )
 
+# Quality Gate: Maximum coefficient of variation (CV) allowed within a period
+# Periods with internal CV above this are considered too heterogeneous for "best price"
+# A 25% CV means the std dev is 25% of the mean - beyond this, prices vary too much
+# Example: Period with prices 0.7-0.99 kr has ~15% CV which is acceptable
+#          Period with prices 0.5-1.0 kr has ~30% CV which would be rejected
+PERIOD_MAX_CV = 25.0  # 25% max coefficient of variation within a period
+
+# Cross-Day Extension: Time window constants
+# When a period ends late in the day and tomorrow data is available,
+# we can extend it past midnight if prices remain favorable
+CROSS_DAY_LATE_PERIOD_START_HOUR = 20  # Consider periods starting at 20:00 or later for extension
+CROSS_DAY_MAX_EXTENSION_HOUR = 8  # Don't extend beyond 08:00 next day (covers typical night low)
+
+# Cross-Day Supersession: When tomorrow data arrives, late-night periods that are
+# worse than early-morning tomorrow periods become obsolete
+# A today period is "superseded" if tomorrow has a significantly better alternative
+SUPERSESSION_PRICE_IMPROVEMENT_PCT = 10.0  # Tomorrow must be at least 10% cheaper to supersede
+
 # Log indentation levels for visual hierarchy
 INDENT_L0 = ""  # Top level (calculate_periods_with_relaxation)
 INDENT_L1 = "  "  # Per-day loop
@@ -62,6 +80,7 @@ class TibberPricesPeriodStatistics(NamedTuple):
     price_max: float
     price_spread: float
     volatility: str
+    coefficient_of_variation: float | None  # CV as percentage (e.g., 15.0 for 15%)
     period_price_diff: float | None
     period_price_diff_pct: float | None
 

custom_components/tibber_prices/coordinator/periods.py

@@ -13,6 +13,8 @@ from typing import TYPE_CHECKING, Any
 from custom_components.tibber_prices import const as _const
 
 if TYPE_CHECKING:
+    from collections.abc import Callable
+
     from custom_components.tibber_prices.coordinator.time_service import TibberPricesTimeService
     from homeassistant.config_entries import ConfigEntry
 
@@ -32,6 +34,7 @@ class TibberPricesPeriodCalculator:
         self,
         config_entry: ConfigEntry,
         log_prefix: str,
+        get_config_override_fn: Callable[[str, str], Any | None] | None = None,
     ) -> None:
         """Initialize the period calculator."""
         self.config_entry = config_entry
@@ -39,11 +42,40 @@ class TibberPricesPeriodCalculator:
         self.time: TibberPricesTimeService  # Set by coordinator before first use
         self._config_cache: dict[str, dict[str, Any]] | None = None
         self._config_cache_valid = False
+        self._get_config_override = get_config_override_fn
 
         # Period calculation cache
         self._cached_periods: dict[str, Any] | None = None
         self._last_periods_hash: str | None = None
 
+    def _get_option(
+        self,
+        config_key: str,
+        config_section: str,
+        default: Any,
+    ) -> Any:
+        """
+        Get a config option, checking overrides first.
+
+        Args:
+            config_key: The configuration key
+            config_section: The section in options (e.g., "flexibility_settings")
+            default: Default value if not set
+
+        Returns:
+            Override value if set, otherwise options value, otherwise default
+
+        """
+        # Check overrides first
+        if self._get_config_override is not None:
+            override = self._get_config_override(config_key, config_section)
+            if override is not None:
+                return override
+
+        # Fall back to options
+        section = self.config_entry.options.get(config_section, {})
+        return section.get(config_key, default)
+
     def _log(self, level: str, message: str, *args: object, **kwargs: object) -> None:
         """Log with calculator-specific prefix."""
         prefixed_message = f"{self._log_prefix} {message}"
@@ -92,8 +124,9 @@ class TibberPricesPeriodCalculator:
 
         # Get level filter overrides from options
         options = self.config_entry.options
-        best_level_filter = options.get(_const.CONF_BEST_PRICE_MAX_LEVEL, _const.DEFAULT_BEST_PRICE_MAX_LEVEL)
-        peak_level_filter = options.get(_const.CONF_PEAK_PRICE_MIN_LEVEL, _const.DEFAULT_PEAK_PRICE_MIN_LEVEL)
+        period_settings = options.get("period_settings", {})
+        best_level_filter = period_settings.get(_const.CONF_BEST_PRICE_MAX_LEVEL, _const.DEFAULT_BEST_PRICE_MAX_LEVEL)
+        peak_level_filter = period_settings.get(_const.CONF_PEAK_PRICE_MIN_LEVEL, _const.DEFAULT_PEAK_PRICE_MIN_LEVEL)
 
         # Compute hash from all relevant data
         hash_data = (
@@ -111,7 +144,7 @@ class TibberPricesPeriodCalculator:
         Get period calculation configuration from config options.
 
         Uses cached config to avoid multiple options.get() calls.
-        Cache is invalidated when config_entry.options change.
+        Cache is invalidated when config_entry.options change or override entities update.
         """
         cache_key = "peak" if reverse_sort else "best"
 
@@ -123,34 +156,45 @@ class TibberPricesPeriodCalculator:
         if self._config_cache is None:
             self._config_cache = {}
 
-        options = self.config_entry.options
-        data = self.config_entry.data
+        # Get config values, checking overrides first
+        # CRITICAL: Best/Peak price settings are stored in nested sections:
+        # - period_settings: min_period_length, max_level, gap_count
+        # - flexibility_settings: flex, min_distance_from_avg
+        # Override entities can override any of these values at runtime
 
         if reverse_sort:
             # Peak price configuration
-            flex = options.get(
-                _const.CONF_PEAK_PRICE_FLEX, data.get(_const.CONF_PEAK_PRICE_FLEX, _const.DEFAULT_PEAK_PRICE_FLEX)
+            flex = self._get_option(
+                _const.CONF_PEAK_PRICE_FLEX,
+                "flexibility_settings",
+                _const.DEFAULT_PEAK_PRICE_FLEX,
             )
-            min_distance_from_avg = options.get(
+            min_distance_from_avg = self._get_option(
                 _const.CONF_PEAK_PRICE_MIN_DISTANCE_FROM_AVG,
-                data.get(_const.CONF_PEAK_PRICE_MIN_DISTANCE_FROM_AVG, _const.DEFAULT_PEAK_PRICE_MIN_DISTANCE_FROM_AVG),
+                "flexibility_settings",
+                _const.DEFAULT_PEAK_PRICE_MIN_DISTANCE_FROM_AVG,
             )
-            min_period_length = options.get(
+            min_period_length = self._get_option(
                 _const.CONF_PEAK_PRICE_MIN_PERIOD_LENGTH,
-                data.get(_const.CONF_PEAK_PRICE_MIN_PERIOD_LENGTH, _const.DEFAULT_PEAK_PRICE_MIN_PERIOD_LENGTH),
+                "period_settings",
+                _const.DEFAULT_PEAK_PRICE_MIN_PERIOD_LENGTH,
             )
         else:
             # Best price configuration
-            flex = options.get(
-                _const.CONF_BEST_PRICE_FLEX, data.get(_const.CONF_BEST_PRICE_FLEX, _const.DEFAULT_BEST_PRICE_FLEX)
+            flex = self._get_option(
+                _const.CONF_BEST_PRICE_FLEX,
+                "flexibility_settings",
+                _const.DEFAULT_BEST_PRICE_FLEX,
             )
-            min_distance_from_avg = options.get(
+            min_distance_from_avg = self._get_option(
                 _const.CONF_BEST_PRICE_MIN_DISTANCE_FROM_AVG,
-                data.get(_const.CONF_BEST_PRICE_MIN_DISTANCE_FROM_AVG, _const.DEFAULT_BEST_PRICE_MIN_DISTANCE_FROM_AVG),
+                "flexibility_settings",
+                _const.DEFAULT_BEST_PRICE_MIN_DISTANCE_FROM_AVG,
             )
-            min_period_length = options.get(
+            min_period_length = self._get_option(
                 _const.CONF_BEST_PRICE_MIN_PERIOD_LENGTH,
-                data.get(_const.CONF_BEST_PRICE_MIN_PERIOD_LENGTH, _const.DEFAULT_BEST_PRICE_MIN_PERIOD_LENGTH),
+                "period_settings",
+                _const.DEFAULT_BEST_PRICE_MIN_PERIOD_LENGTH,
             )
 
         # Convert flex from percentage to decimal (e.g., 5 -> 0.05)
@@ -356,13 +400,14 @@ class TibberPricesPeriodCalculator:
 
         # Normal check failed - try splitting at gap clusters as fallback
         # Get minimum period length from config (convert minutes to intervals)
+        period_settings = self.config_entry.options.get("period_settings", {})
         if reverse_sort:
-            min_period_minutes = self.config_entry.options.get(
+            min_period_minutes = period_settings.get(
                 _const.CONF_PEAK_PRICE_MIN_PERIOD_LENGTH,
                 _const.DEFAULT_PEAK_PRICE_MIN_PERIOD_LENGTH,
             )
         else:
-            min_period_minutes = self.config_entry.options.get(
+            min_period_minutes = period_settings.get(
                 _const.CONF_BEST_PRICE_MIN_PERIOD_LENGTH,
                 _const.DEFAULT_BEST_PRICE_MIN_PERIOD_LENGTH,
             )
@@ -487,13 +532,15 @@ class TibberPricesPeriodCalculator:
         # Get appropriate config based on sensor type
         elif reverse_sort:
             # Peak price: minimum level filter (lower bound)
-            level_config = self.config_entry.options.get(
+            period_settings = self.config_entry.options.get("period_settings", {})
+            level_config = period_settings.get(
                 _const.CONF_PEAK_PRICE_MIN_LEVEL,
                 _const.DEFAULT_PEAK_PRICE_MIN_LEVEL,
             )
         else:
             # Best price: maximum level filter (upper bound)
-            level_config = self.config_entry.options.get(
+            period_settings = self.config_entry.options.get("period_settings", {})
+            level_config = period_settings.get(
                 _const.CONF_BEST_PRICE_MAX_LEVEL,
                 _const.DEFAULT_BEST_PRICE_MAX_LEVEL,
             )
@@ -511,13 +558,14 @@ class TibberPricesPeriodCalculator:
             return True  # If no data, don't filter
 
         # Get gap tolerance configuration
+        period_settings = self.config_entry.options.get("period_settings", {})
         if reverse_sort:
-            max_gap_count = self.config_entry.options.get(
+            max_gap_count = period_settings.get(
                 _const.CONF_PEAK_PRICE_MAX_LEVEL_GAP_COUNT,
                 _const.DEFAULT_PEAK_PRICE_MAX_LEVEL_GAP_COUNT,
             )
         else:
-            max_gap_count = self.config_entry.options.get(
+            max_gap_count = period_settings.get(
                 _const.CONF_BEST_PRICE_MAX_LEVEL_GAP_COUNT,
                 _const.DEFAULT_BEST_PRICE_MAX_LEVEL_GAP_COUNT,
             )
@@ -574,7 +622,8 @@ class TibberPricesPeriodCalculator:
         coordinator_data = {"priceInfo": price_info}
         all_prices = get_intervals_for_day_offsets(coordinator_data, [-2, -1, 0, 1])
 
-        # Get rating thresholds from config
+        # Get rating thresholds from config (flat in options, not in sections)
+        # CRITICAL: Price rating thresholds are stored FLAT in options (no sections)
         threshold_low = self.config_entry.options.get(
             _const.CONF_PRICE_RATING_THRESHOLD_LOW,
             _const.DEFAULT_PRICE_RATING_THRESHOLD_LOW,
@@ -584,7 +633,8 @@ class TibberPricesPeriodCalculator:
             _const.DEFAULT_PRICE_RATING_THRESHOLD_HIGH,
         )
 
-        # Get volatility thresholds from config
+        # Get volatility thresholds from config (flat in options, not in sections)
+        # CRITICAL: Volatility thresholds are stored FLAT in options (no sections)
         threshold_volatility_moderate = self.config_entry.options.get(
             _const.CONF_VOLATILITY_THRESHOLD_MODERATE,
             _const.DEFAULT_VOLATILITY_THRESHOLD_MODERATE,
@@ -599,8 +649,11 @@ class TibberPricesPeriodCalculator:
         )
 
         # Get relaxation configuration for best price
-        enable_relaxation_best = self.config_entry.options.get(
+        # CRITICAL: Relaxation settings are stored in nested section 'relaxation_and_target_periods'
+        # Override entities can override any of these values at runtime
+        enable_relaxation_best = self._get_option(
             _const.CONF_ENABLE_MIN_PERIODS_BEST,
+            "relaxation_and_target_periods",
             _const.DEFAULT_ENABLE_MIN_PERIODS_BEST,
         )
 
@@ -611,25 +664,30 @@ class TibberPricesPeriodCalculator:
             show_best_price = bool(all_prices)
         else:
             show_best_price = self.should_show_periods(price_info, reverse_sort=False) if all_prices else False
-        min_periods_best = self.config_entry.options.get(
+        min_periods_best = self._get_option(
             _const.CONF_MIN_PERIODS_BEST,
+            "relaxation_and_target_periods",
             _const.DEFAULT_MIN_PERIODS_BEST,
         )
-        relaxation_attempts_best = self.config_entry.options.get(
+        relaxation_attempts_best = self._get_option(
             _const.CONF_RELAXATION_ATTEMPTS_BEST,
+            "relaxation_and_target_periods",
             _const.DEFAULT_RELAXATION_ATTEMPTS_BEST,
         )
 
         # Calculate best price periods (or return empty if filtered)
         if show_best_price:
             best_config = self.get_period_config(reverse_sort=False)
-            # Get level filter configuration
-            max_level_best = self.config_entry.options.get(
+            # Get level filter configuration from period_settings section
+            # CRITICAL: max_level and gap_count are stored in nested section 'period_settings'
+            max_level_best = self._get_option(
                 _const.CONF_BEST_PRICE_MAX_LEVEL,
+                "period_settings",
                 _const.DEFAULT_BEST_PRICE_MAX_LEVEL,
             )
-            gap_count_best = self.config_entry.options.get(
+            gap_count_best = self._get_option(
                 _const.CONF_BEST_PRICE_MAX_LEVEL_GAP_COUNT,
+                "period_settings",
                 _const.DEFAULT_BEST_PRICE_MAX_LEVEL_GAP_COUNT,
             )
             best_period_config = TibberPricesPeriodConfig(
@@ -672,8 +730,11 @@ class TibberPricesPeriodCalculator:
             }
 
         # Get relaxation configuration for peak price
-        enable_relaxation_peak = self.config_entry.options.get(
+        # CRITICAL: Relaxation settings are stored in nested section 'relaxation_and_target_periods'
+        # Override entities can override any of these values at runtime
+        enable_relaxation_peak = self._get_option(
             _const.CONF_ENABLE_MIN_PERIODS_PEAK,
+            "relaxation_and_target_periods",
             _const.DEFAULT_ENABLE_MIN_PERIODS_PEAK,
         )
 
@@ -684,25 +745,30 @@ class TibberPricesPeriodCalculator:
             show_peak_price = bool(all_prices)
         else:
             show_peak_price = self.should_show_periods(price_info, reverse_sort=True) if all_prices else False
-        min_periods_peak = self.config_entry.options.get(
+        min_periods_peak = self._get_option(
             _const.CONF_MIN_PERIODS_PEAK,
+            "relaxation_and_target_periods",
             _const.DEFAULT_MIN_PERIODS_PEAK,
         )
-        relaxation_attempts_peak = self.config_entry.options.get(
+        relaxation_attempts_peak = self._get_option(
             _const.CONF_RELAXATION_ATTEMPTS_PEAK,
+            "relaxation_and_target_periods",
             _const.DEFAULT_RELAXATION_ATTEMPTS_PEAK,
         )
 
         # Calculate peak price periods (or return empty if filtered)
         if show_peak_price:
             peak_config = self.get_period_config(reverse_sort=True)
-            # Get level filter configuration
-            min_level_peak = self.config_entry.options.get(
+            # Get level filter configuration from period_settings section
+            # CRITICAL: min_level and gap_count are stored in nested section 'period_settings'
+            min_level_peak = self._get_option(
                 _const.CONF_PEAK_PRICE_MIN_LEVEL,
+                "period_settings",
                 _const.DEFAULT_PEAK_PRICE_MIN_LEVEL,
             )
-            gap_count_peak = self.config_entry.options.get(
+            gap_count_peak = self._get_option(
                 _const.CONF_PEAK_PRICE_MAX_LEVEL_GAP_COUNT,
+                "period_settings",
                 _const.DEFAULT_PEAK_PRICE_MAX_LEVEL_GAP_COUNT,
             )
             peak_period_config = TibberPricesPeriodConfig(

custom_components/tibber_prices/coordinator/price_data_manager.py

@@ -0,0 +1,631 @@
+"""
+Price data management for the coordinator.
+
+This module manages all price-related data for the Tibber Prices integration:
+
+**User Data** (fetched directly via API):
+- Home metadata (name, address, timezone)
+- Account info (subscription status)
+- Currency settings
+- Refreshed daily (24h interval)
+
+**Price Data** (fetched via IntervalPool):
+- Quarter-hourly price intervals
+- Yesterday/today/tomorrow coverage
+- The IntervalPool handles actual API fetching, deduplication, and caching
+- This manager coordinates the data flow and user data refresh
+
+Data flow:
+    Tibber API → IntervalPool → PriceDataManager → Coordinator → Sensors
+                     ↑                  ↓
+              (actual fetching)   (orchestration + user data)
+
+Note: Price data is NOT cached in this module - IntervalPool is the single
+source of truth. This module only caches user_data for daily refresh cycle.
+"""
+
+from __future__ import annotations
+
+import logging
+from datetime import timedelta
+from typing import TYPE_CHECKING, Any
+
+from custom_components.tibber_prices.api import (
+    TibberPricesApiClientAuthenticationError,
+    TibberPricesApiClientCommunicationError,
+    TibberPricesApiClientError,
+)
+from homeassistant.exceptions import ConfigEntryAuthFailed
+from homeassistant.helpers.update_coordinator import UpdateFailed
+
+from . import cache, helpers
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+    from datetime import datetime
+
+    from custom_components.tibber_prices.api import TibberPricesApiClient
+    from custom_components.tibber_prices.interval_pool import TibberPricesIntervalPool
+
+    from .time_service import TibberPricesTimeService
+
+_LOGGER = logging.getLogger(__name__)
+
+# Hour when Tibber publishes tomorrow's prices (around 13:00 local time)
+# Before this hour, requesting tomorrow data will always fail → wasted API call
+TOMORROW_DATA_AVAILABLE_HOUR = 13
+
+
+class TibberPricesPriceDataManager:
+    """
+    Manages price and user data for the coordinator.
+
+    Responsibilities:
+    - User data: Fetches directly via API, validates, caches with persistence
+    - Price data: Coordinates with IntervalPool (which does actual API fetching)
+    - Cache management: Loads/stores both data types to HA persistent storage
+    - Update decisions: Determines when fresh data is needed
+
+    Note: Despite the name, this class does NOT do the actual price fetching.
+    The IntervalPool handles API calls, deduplication, and interval management.
+    This class orchestrates WHEN to fetch and processes the results.
+    """
+
+    def __init__(  # noqa: PLR0913
+        self,
+        api: TibberPricesApiClient,
+        store: Any,
+        log_prefix: str,
+        user_update_interval: timedelta,
+        time: TibberPricesTimeService,
+        home_id: str,
+        interval_pool: TibberPricesIntervalPool,
+    ) -> None:
+        """
+        Initialize the price data manager.
+
+        Args:
+            api: API client for direct requests (user data only).
+            store: Home Assistant storage for persistence.
+            log_prefix: Prefix for log messages (e.g., "[Home Name]").
+            user_update_interval: How often to refresh user data (default: 1 day).
+            time: TimeService for time operations.
+            home_id: Home ID this manager is responsible for.
+            interval_pool: IntervalPool for price data (handles actual fetching).
+
+        """
+        self.api = api
+        self._store = store
+        self._log_prefix = log_prefix
+        self._user_update_interval = user_update_interval
+        self.time: TibberPricesTimeService = time
+        self.home_id = home_id
+        self._interval_pool = interval_pool
+
+        # Cached data (user data only - price data is in IntervalPool)
+        self._cached_user_data: dict[str, Any] | None = None
+        self._last_user_update: datetime | None = None
+
+    def _log(self, level: str, message: str, *args: object, **kwargs: object) -> None:
+        """Log with coordinator-specific prefix."""
+        prefixed_message = f"{self._log_prefix} {message}"
+        getattr(_LOGGER, level)(prefixed_message, *args, **kwargs)
+
+    async def load_cache(self) -> None:
+        """Load cached user data from storage (price data is in IntervalPool)."""
+        cache_data = await cache.load_cache(self._store, self._log_prefix, time=self.time)
+
+        self._cached_user_data = cache_data.user_data
+        self._last_user_update = cache_data.last_user_update
+
+    def should_fetch_tomorrow_data(
+        self,
+        current_price_info: list[dict[str, Any]] | None,
+    ) -> bool:
+        """
+        Determine if tomorrow's data should be requested from the API.
+
+        This is the key intelligence that prevents API spam:
+        - Tibber publishes tomorrow's prices around 13:00 each day
+        - Before 13:00, requesting tomorrow data will always fail → wasted API call
+        - If we already have tomorrow data, no need to request it again
+
+        The decision logic:
+        1. Before 13:00 local time → Don't fetch (data not available yet)
+        2. After 13:00 AND tomorrow data already present → Don't fetch (already have it)
+        3. After 13:00 AND tomorrow data missing → Fetch (data should be available)
+
+        Args:
+            current_price_info: List of price intervals from current coordinator data.
+                               Used to check if tomorrow data already exists.
+
+        Returns:
+            True if tomorrow data should be requested, False otherwise.
+
+        """
+        now = self.time.now()
+        now_local = self.time.as_local(now)
+        current_hour = now_local.hour
+
+        # Before TOMORROW_DATA_AVAILABLE_HOUR - tomorrow data not available yet
+        if current_hour < TOMORROW_DATA_AVAILABLE_HOUR:
+            self._log("debug", "Before %d:00 - not requesting tomorrow data", TOMORROW_DATA_AVAILABLE_HOUR)
+            return False
+
+        # After TOMORROW_DATA_AVAILABLE_HOUR - check if we already have tomorrow data
+        if current_price_info:
+            has_tomorrow = self.has_tomorrow_data(current_price_info)
+            if has_tomorrow:
+                self._log(
+                    "debug", "After %d:00 but already have tomorrow data - not requesting", TOMORROW_DATA_AVAILABLE_HOUR
+                )
+                return False
+            self._log("debug", "After %d:00 and tomorrow data missing - will request", TOMORROW_DATA_AVAILABLE_HOUR)
+            return True
+
+        # No current data - request tomorrow data if after TOMORROW_DATA_AVAILABLE_HOUR
+        self._log(
+            "debug", "After %d:00 with no current data - will request tomorrow data", TOMORROW_DATA_AVAILABLE_HOUR
+        )
+        return True
+
+    async def store_cache(self, last_midnight_check: datetime | None = None) -> None:
+        """Store cache data (user metadata only, price data is in IntervalPool)."""
+        cache_data = cache.TibberPricesCacheData(
+            user_data=self._cached_user_data,
+            last_user_update=self._last_user_update,
+            last_midnight_check=last_midnight_check,
+        )
+        await cache.save_cache(self._store, cache_data, self._log_prefix)
+
+    def _validate_user_data(self, user_data: dict, home_id: str) -> bool:  # noqa: PLR0911
+        """
+        Validate user data completeness.
+
+        Rejects incomplete/invalid data from API to prevent caching temporary errors.
+        Currency information is critical - if missing, we cannot safely calculate prices.
+
+        Args:
+            user_data: User data dict from API.
+            home_id: Home ID to validate against.
+
+        Returns:
+            True if data is valid and complete, False otherwise.
+
+        """
+        if not user_data:
+            self._log("warning", "User data validation failed: Empty data")
+            return False
+
+        viewer = user_data.get("viewer")
+        if not viewer or not isinstance(viewer, dict):
+            self._log("warning", "User data validation failed: Missing or invalid viewer")
+            return False
+
+        homes = viewer.get("homes")
+        if not homes or not isinstance(homes, list) or len(homes) == 0:
+            self._log("warning", "User data validation failed: No homes found")
+            return False
+
+        # Find our home and validate it has required data
+        home_found = False
+        for home in homes:
+            if home.get("id") == home_id:
+                home_found = True
+
+                # Validate home has timezone (required for cursor calculation)
+                if not home.get("timeZone"):
+                    self._log("warning", "User data validation failed: Home %s missing timezone", home_id)
+                    return False
+
+                # Currency is REQUIRED - we cannot function without it
+                # The currency is nested in currentSubscription.priceInfo.current.currency
+                subscription = home.get("currentSubscription")
+                if not subscription:
+                    self._log(
+                        "warning",
+                        "User data validation failed: Home %s has no active subscription",
+                        home_id,
+                    )
+                    return False
+
+                price_info = subscription.get("priceInfo")
+                if not price_info:
+                    self._log(
+                        "warning",
+                        "User data validation failed: Home %s subscription has no priceInfo",
+                        home_id,
+                    )
+                    return False
+
+                current = price_info.get("current")
+                if not current:
+                    self._log(
+                        "warning",
+                        "User data validation failed: Home %s priceInfo has no current data",
+                        home_id,
+                    )
+                    return False
+
+                currency = current.get("currency")
+                if not currency:
+                    self._log(
+                        "warning",
+                        "User data validation failed: Home %s has no currency",
+                        home_id,
+                    )
+                    return False
+
+                break
+
+        if not home_found:
+            self._log("warning", "User data validation failed: Home %s not found in homes list", home_id)
+            return False
+
+        self._log("debug", "User data validation passed for home %s", home_id)
+        return True
+
+    async def update_user_data_if_needed(self, current_time: datetime) -> bool:
+        """
+        Update user data if needed (daily check).
+
+        Only accepts complete and valid data. If API returns incomplete data
+        (e.g., during maintenance), keeps existing cached data and retries later.
+
+        Returns:
+            True if user data was updated, False otherwise
+
+        """
+        if self._last_user_update is None or current_time - self._last_user_update >= self._user_update_interval:
+            try:
+                self._log("debug", "Updating user data")
+                user_data = await self.api.async_get_viewer_details()
+
+                # Validate before caching
+                if not self._validate_user_data(user_data, self.home_id):
+                    self._log(
+                        "warning",
+                        "Rejecting incomplete user data from API - keeping existing cached data",
+                    )
+                    return False  # Keep existing data, don't update timestamp
+
+                # Data is valid, cache it
+                self._cached_user_data = user_data
+                self._last_user_update = current_time
+                self._log("debug", "User data updated successfully")
+            except (
+                TibberPricesApiClientError,
+                TibberPricesApiClientCommunicationError,
+            ) as ex:
+                self._log("warning", "Failed to update user data: %s", ex)
+                return False  # Update failed
+            else:
+                return True  # User data was updated
+        return False  # No update needed
+
+    async def fetch_home_data(
+        self,
+        home_id: str,
+        current_time: datetime,
+        *,
+        include_tomorrow: bool = True,
+    ) -> tuple[dict[str, Any], bool]:
+        """
+        Fetch data for a single home via pool.
+
+        Args:
+            home_id: Home ID to fetch data for.
+            current_time: Current time for timestamp in result.
+            include_tomorrow: If True, request tomorrow's data too. If False,
+                             only request up to end of today.
+
+        Returns:
+            Tuple of (data_dict, api_called):
+            - data_dict: Dictionary with timestamp, home_id, price_info, currency.
+            - api_called: True if API was called to fetch missing data.
+
+        """
+        if not home_id:
+            self._log("warning", "No home ID provided - cannot fetch price data")
+            return (
+                {
+                    "timestamp": current_time,
+                    "home_id": "",
+                    "price_info": [],
+                    "currency": "EUR",
+                },
+                False,  # No API call made
+            )
+
+        # Ensure we have user_data before fetching price data
+        # This is critical for timezone-aware cursor calculation
+        if not self._cached_user_data:
+            self._log("info", "User data not cached, fetching before price data")
+            try:
+                user_data = await self.api.async_get_viewer_details()
+
+                # Validate data before accepting it (especially on initial setup)
+                if not self._validate_user_data(user_data, self.home_id):
+                    msg = "Received incomplete user data from API - cannot proceed with price fetching"
+                    self._log("error", msg)
+                    raise TibberPricesApiClientError(msg)  # noqa: TRY301
+
+                self._cached_user_data = user_data
+                self._last_user_update = current_time
+            except (
+                TibberPricesApiClientError,
+                TibberPricesApiClientCommunicationError,
+            ) as ex:
+                msg = f"Failed to fetch user data (required for price fetching): {ex}"
+                self._log("error", msg)
+                raise TibberPricesApiClientError(msg) from ex
+
+        # At this point, _cached_user_data is guaranteed to be not None (checked above)
+        if not self._cached_user_data:
+            msg = "User data unexpectedly None after fetch attempt"
+            raise TibberPricesApiClientError(msg)
+
+        # Retrieve price data via IntervalPool (single source of truth)
+        price_info, api_called = await self._fetch_via_pool(home_id, include_tomorrow=include_tomorrow)
+
+        # Extract currency for this home from user_data
+        currency = self._get_currency_for_home(home_id)
+
+        self._log(
+            "debug",
+            "Successfully fetched data for home %s (%d intervals, api_called=%s)",
+            home_id,
+            len(price_info),
+            api_called,
+        )
+
+        return (
+            {
+                "timestamp": current_time,
+                "home_id": home_id,
+                "price_info": price_info,
+                "currency": currency,
+            },
+            api_called,
+        )
+
+    async def _fetch_via_pool(
+        self,
+        home_id: str,
+        *,
+        include_tomorrow: bool = True,
+    ) -> tuple[list[dict[str, Any]], bool]:
+        """
+        Retrieve price data via IntervalPool.
+
+        The IntervalPool is the single source of truth for price data:
+        - Handles actual API calls to Tibber
+        - Manages deduplication and caching
+        - Provides intervals from day-before-yesterday to end-of-today/tomorrow
+
+        This method delegates to the Pool's get_sensor_data() which returns
+        all relevant intervals for sensor display.
+
+        Args:
+            home_id: Home ID (currently unused, Pool knows its home).
+            include_tomorrow: If True, request tomorrow's data too. If False,
+                             only request up to end of today. This prevents
+                             API spam before 13:00 when Tibber doesn't have
+                             tomorrow data yet.
+
+        Returns:
+            Tuple of (intervals, api_called):
+            - intervals: List of price interval dicts.
+            - api_called: True if API was called to fetch missing data.
+
+        """
+        # user_data is guaranteed by fetch_home_data(), but needed for type narrowing
+        if self._cached_user_data is None:
+            return [], False  # No data, no API call
+
+        self._log(
+            "debug",
+            "Retrieving price data for home %s via interval pool (include_tomorrow=%s)",
+            home_id,
+            include_tomorrow,
+        )
+        intervals, api_called = await self._interval_pool.get_sensor_data(
+            api_client=self.api,
+            user_data=self._cached_user_data,
+            include_tomorrow=include_tomorrow,
+        )
+
+        return intervals, api_called
+
+    def _get_currency_for_home(self, home_id: str) -> str:
+        """
+        Get currency for a specific home from cached user_data.
+
+        Note: The cached user_data is validated before storage, so if we have
+        cached data it should contain valid currency. This method extracts
+        the currency from the nested structure.
+
+        Returns:
+            Currency code (e.g., "EUR", "NOK", "SEK").
+
+        Raises:
+            TibberPricesApiClientError: If currency cannot be determined.
+
+        """
+        if not self._cached_user_data:
+            msg = "No user data cached - cannot determine currency"
+            self._log("error", msg)
+            raise TibberPricesApiClientError(msg)
+
+        viewer = self._cached_user_data.get("viewer", {})
+        homes = viewer.get("homes", [])
+
+        for home in homes:
+            if home.get("id") == home_id:
+                # Extract currency from nested structure
+                # Use 'or {}' to handle None values (homes without active subscription)
+                subscription = home.get("currentSubscription") or {}
+                price_info = subscription.get("priceInfo") or {}
+                current = price_info.get("current") or {}
+                currency = current.get("currency")
+
+                if not currency:
+                    # This should not happen if validation worked correctly
+                    msg = f"Home {home_id} has no active subscription - currency unavailable"
+                    self._log("error", msg)
+                    raise TibberPricesApiClientError(msg)
+
+                self._log("debug", "Extracted currency %s for home %s", currency, home_id)
+                return currency
+
+        # Home not found in cached data - data validation should have caught this
+        msg = f"Home {home_id} not found in user data - data validation failed"
+        self._log("error", msg)
+        raise TibberPricesApiClientError(msg)
+
+    def _check_home_exists(self, home_id: str) -> bool:
+        """
+        Check if a home ID exists in cached user data.
+
+        Args:
+            home_id: The home ID to check.
+
+        Returns:
+            True if home exists, False otherwise.
+
+        """
+        if not self._cached_user_data:
+            # No user data yet - assume home exists (will be checked on next update)
+            return True
+
+        viewer = self._cached_user_data.get("viewer", {})
+        homes = viewer.get("homes", [])
+
+        return any(home.get("id") == home_id for home in homes)
+
+    async def handle_main_entry_update(
+        self,
+        current_time: datetime,
+        home_id: str,
+        transform_fn: Callable[[dict[str, Any]], dict[str, Any]],
+        *,
+        current_price_info: list[dict[str, Any]] | None = None,
+    ) -> tuple[dict[str, Any], bool]:
+        """
+        Handle update for main entry - fetch data for this home.
+
+        The IntervalPool is the single source of truth for price data:
+        - It handles API fetching, deduplication, and caching internally
+        - We decide WHEN to fetch tomorrow data (after 13:00, if not already present)
+        - This prevents API spam before 13:00 when Tibber doesn't have tomorrow data
+
+        This method:
+        1. Updates user data if needed (daily)
+        2. Determines if tomorrow data should be requested
+        3. Fetches price data via IntervalPool
+        4. Transforms result for coordinator
+
+        Args:
+            current_time: Current time for update decisions.
+            home_id: Home ID to fetch data for.
+            transform_fn: Function to transform raw data for coordinator.
+            current_price_info: Current price intervals (from coordinator.data["priceInfo"]).
+                               Used to check if tomorrow data already exists.
+
+        Returns:
+            Tuple of (transformed_data, api_called):
+            - transformed_data: Transformed data dict for coordinator.
+            - api_called: True if API was called to fetch missing data.
+
+        """
+        # Update user data if needed (daily check)
+        user_data_updated = await self.update_user_data_if_needed(current_time)
+
+        # Check if this home still exists in user data after update
+        # This detects when a home was removed from the Tibber account
+        home_exists = self._check_home_exists(home_id)
+        if not home_exists:
+            self._log("warning", "Home ID %s not found in Tibber account", home_id)
+            # Return a special marker in the result that coordinator can check
+            result = transform_fn({})
+            result["_home_not_found"] = True  # Special marker for coordinator
+            return result, False  # No API call made (home doesn't exist)
+
+        # Determine if we should request tomorrow data
+        include_tomorrow = self.should_fetch_tomorrow_data(current_price_info)
+
+        # Fetch price data via IntervalPool
+        self._log(
+            "debug",
+            "Fetching price data for home %s via interval pool (include_tomorrow=%s)",
+            home_id,
+            include_tomorrow,
+        )
+        raw_data, api_called = await self.fetch_home_data(home_id, current_time, include_tomorrow=include_tomorrow)
+
+        # Parse timestamps immediately after fetch
+        raw_data = helpers.parse_all_timestamps(raw_data, time=self.time)
+
+        # Store user data cache (price data persisted by IntervalPool)
+        if user_data_updated:
+            await self.store_cache()
+
+        # Transform for main entry
+        return transform_fn(raw_data), api_called
+
+    async def handle_api_error(
+        self,
+        error: Exception,
+    ) -> None:
+        """
+        Handle API errors - re-raise appropriate exceptions.
+
+        Note: With IntervalPool as source of truth, there's no local price cache
+        to fall back to. The Pool has its own persistence, so on next update
+        it will use its cached intervals if API is unavailable.
+        """
+        if isinstance(error, TibberPricesApiClientAuthenticationError):
+            msg = "Invalid access token"
+            raise ConfigEntryAuthFailed(msg) from error
+
+        msg = f"Error communicating with API: {error}"
+        raise UpdateFailed(msg) from error
+
+    @property
+    def cached_user_data(self) -> dict[str, Any] | None:
+        """Get cached user data."""
+        return self._cached_user_data
+
+    def has_tomorrow_data(self, price_info: list[dict[str, Any]]) -> bool:
+        """
+        Check if tomorrow's price data is available.
+
+        Args:
+            price_info: List of price intervals from coordinator data.
+
+        Returns:
+            True if at least one interval from tomorrow is present.
+
+        """
+        if not price_info:
+            return False
+
+        # Get tomorrow's date
+        now = self.time.now()
+        tomorrow = (self.time.as_local(now) + timedelta(days=1)).date()
+
+        # Check if any interval is from tomorrow
+        for interval in price_info:
+            if "startsAt" not in interval:
+                continue
+
+            # startsAt is already a datetime object after _transform_data()
+            interval_time = interval["startsAt"]
+            if isinstance(interval_time, str):
+                # Fallback: parse if still string (shouldn't happen with transformed data)
+                interval_time = self.time.parse_datetime(interval_time)
+
+            if interval_time and self.time.as_local(interval_time).date() == tomorrow:
+                return True
+
+        return False

custom_components/tibber_prices/custom_translations/de.json

@@ -2,7 +2,9 @@
     "apexcharts": {
         "title_rating_level": "Preisphasen Tagesverlauf",
         "title_level": "Preisniveau",
-        "best_price_period_name": "Beste Preisperiode",
+        "hourly_suffix": "(Ø stündlich)",
+        "best_price_period_name": "Bestpreis-Zeitraum",
+        "peak_price_period_name": "Spitzenpreis-Zeitraum",
         "notification": {
             "metadata_sensor_unavailable": {
                 "title": "Tibber Prices: ApexCharts YAML mit eingeschränkter Funktionalität generiert",
@@ -56,9 +58,9 @@
             "usage_tips": "Nutze dies, um den Betrieb von Geräten während Spitzenpreiszeiten zu vermeiden"
         },
         "average_price_today": {
-            "description": "Der durchschnittliche Strompreis für heute pro kWh",
-            "long_description": "Zeigt den durchschnittlichen Preis pro kWh für den aktuellen Tag von deinem Tibber-Abonnement an",
-            "usage_tips": "Nutze dies als Grundlage für den Vergleich mit aktuellen Preisen"
+            "description": "Der typische Strompreis für heute pro kWh (konfigurierbares Anzeigeformat)",
+            "long_description": "Zeigt den typischen Preis pro kWh für heute. **Standardmäßig zeigt der Status den Median** (resistent gegen extreme Preisspitzen, zeigt was du generell erwarten kannst). Du kannst dies in den Integrationsoptionen ändern, um stattdessen das arithmetische Mittel anzuzeigen. Der alternative Wert ist immer als Attribut `price_mean` oder `price_median` für Automatisierungen verfügbar.",
+            "usage_tips": "Nutze den Status-Wert für die Anzeige. Für exakte Kostenberechnungen in Automatisierungen nutze: {{ state_attr('sensor.average_price_today', 'price_mean') }}"
         },
         "lowest_price_tomorrow": {
             "description": "Der niedrigste Strompreis für morgen pro kWh",
@@ -71,9 +73,9 @@
             "usage_tips": "Nutze dies, um den Betrieb von Geräten während der teuersten Stunden morgen zu vermeiden. Plane nicht-essentielle Lasten außerhalb dieser Spitzenpreiszeiten."
         },
         "average_price_tomorrow": {
-            "description": "Der durchschnittliche Strompreis für morgen pro kWh",
-            "long_description": "Zeigt den durchschnittlichen Preis pro kWh für den morgigen Tag von deinem Tibber-Abonnement an. Dieser Sensor wird nicht verfügbar, bis die Preise für morgen von Tibber veröffentlicht werden (typischerweise zwischen 13:00 und 14:00 Uhr MEZ).",
-            "usage_tips": "Nutze dies als Grundlinie für den Vergleich mit den morgigen Preisen und zur Verbrauchsplanung. Vergleiche mit dem heutigen Durchschnitt, um zu sehen, ob morgen insgesamt teurer oder günstiger wird."
+            "description": "Der typische Strompreis für morgen pro kWh (konfigurierbares Anzeigeformat)",
+            "long_description": "Zeigt den typischen Preis pro kWh für morgen. **Standardmäßig zeigt der Status den Median** (resistent gegen extreme Preisspitzen). Du kannst dies in den Integrationsoptionen ändern, um stattdessen das arithmetische Mittel anzuzeigen. Der alternative Wert ist als Attribut verfügbar. Dieser Sensor wird nicht verfügbar, bis die Preise für morgen von Tibber veröffentlicht werden (typischerweise zwischen 13:00 und 14:00 Uhr MEZ).",
+            "usage_tips": "Nutze den Status-Wert für Anzeige und schnelle Vergleiche. Für Automatisierungen, die exakte Kostenberechnungen benötigen, nutze das Attribut `price_mean`: {{ state_attr('sensor.average_price_tomorrow', 'price_mean') }}"
         },
         "yesterday_price_level": {
             "description": "Aggregiertes Preisniveau für gestern",
@@ -106,14 +108,14 @@
             "usage_tips": "Nutze dies, um den morgigen Energieverbrauch basierend auf deinen persönlichen Preisschwellenwerten zu planen. Vergleiche mit heute, um zu entscheiden, ob du den Verbrauch auf morgen verschieben oder heute nutzen solltest."
         },
         "trailing_price_average": {
-            "description": "Der durchschnittliche Strompreis für die letzten 24 Stunden pro kWh",
-            "long_description": "Zeigt den durchschnittlichen Preis pro kWh berechnet aus den letzten 24 Stunden (nachlaufender Durchschnitt) von deinem Tibber-Abonnement an. Dies bietet einen gleitenden Durchschnitt, der alle 15 Minuten basierend auf historischen Daten aktualisiert wird.",
-            "usage_tips": "Nutze dies, um aktuelle Preise mit den jüngsten Trends zu vergleichen. Ein aktueller Preis deutlich über diesem Durchschnitt kann ein guter Zeitpunkt sein, um den Verbrauch zu reduzieren."
+            "description": "Der typische Strompreis der letzten 24 Stunden pro kWh (konfigurierbares Anzeigeformat)",
+            "long_description": "Zeigt den typischen Preis pro kWh der letzten 24 Stunden. **Standardmäßig zeigt der Status den Median** (resistent gegen extreme Spitzen, zeigt welches Preisniveau typisch war). Du kannst dies in den Integrationsoptionen ändern, um stattdessen das arithmetische Mittel anzuzeigen. Der alternative Wert ist als Attribut verfügbar. Wird alle 15 Minuten aktualisiert.",
+            "usage_tips": "Nutze den Status-Wert, um das typische aktuelle Preisniveau zu sehen. Für Kostenberechnungen nutze: {{ state_attr('sensor.trailing_price_average', 'price_mean') }}"
         },
         "leading_price_average": {
-            "description": "Der durchschnittliche Strompreis für die nächsten 24 Stunden pro kWh",
-            "long_description": "Zeigt den durchschnittlichen Preis pro kWh berechnet aus den nächsten 24 Stunden (vorlaufender Durchschnitt) von deinem Tibber-Abonnement an. Dies bietet einen vorausschauenden Durchschnitt basierend auf verfügbaren Prognosedaten.",
-            "usage_tips": "Nutze dies zur Energieverbrauchsplanung. Wenn der aktuelle Preis unter dem vorlaufenden Durchschnitt liegt, kann es ein guter Zeitpunkt sein, um energieintensive Geräte zu betreiben."
+            "description": "Der typische Strompreis für die nächsten 24 Stunden pro kWh (konfigurierbares Anzeigeformat)",
+            "long_description": "Zeigt den typischen Preis pro kWh für die nächsten 24 Stunden. **Standardmäßig zeigt der Status den Median** (resistent gegen extreme Spitzen, zeigt welches Preisniveau zu erwarten ist). Du kannst dies in den Integrationsoptionen ändern, um stattdessen das arithmetische Mittel anzuzeigen. Der alternative Wert ist als Attribut verfügbar.",
+            "usage_tips": "Nutze den Status-Wert, um das typische kommende Preisniveau zu sehen. Für Kostenberechnungen nutze: {{ state_attr('sensor.leading_price_average', 'price_mean') }}"
         },
         "trailing_price_min": {
             "description": "Der niedrigste Strompreis für die letzten 24 Stunden pro kWh",
@@ -290,24 +292,24 @@
             "long_description": "Zeigt den Zeitstempel des letzten verfügbaren Preisdatenintervalls von deinem Tibber-Abonnement"
         },
         "today_volatility": {
-            "description": "Preisvolatilitätsklassifizierung für heute",
-            "long_description": "Zeigt, wie stark die Strompreise im Laufe des heutigen Tages variieren, basierend auf der Spannweite (Differenz zwischen höchstem und niedrigstem Preis). Klassifizierung: niedrig = Spannweite < 5ct, moderat = 5-15ct, hoch = 15-30ct, sehr hoch = >30ct.",
-            "usage_tips": "Verwende dies, um zu entscheiden, ob preisbasierte Optimierung lohnenswert ist. Zum Beispiel lohnt sich bei einer Balkonbatterie mit 15% Effizienzverlusten die Optimierung nur, wenn die Volatilität mindestens moderat ist. Erstelle Automatisierungen, die die Volatilität prüfen, bevor Lade-/Entladezyklen geplant werden."
+            "description": "Wie stark sich die Strompreise heute verändern",
+            "long_description": "Zeigt, ob die heutigen Preise stabil bleiben oder stark schwanken. Niedrige Volatilität bedeutet recht konstante Preise – Timing ist kaum wichtig. Hohe Volatilität bedeutet spürbare Preisunterschiede über den Tag – gute Chance, den Verbrauch auf günstigere Zeiten zu verschieben. `price_coefficient_variation_%` zeigt den Prozentwert, `price_spread` die absolute Preisspanne.",
+            "usage_tips": "Nutze dies, um zu entscheiden, ob Optimierung sich lohnt. Bei niedriger Volatilität kannst du Geräte jederzeit laufen lassen. Bei hoher Volatilität sparst du spürbar, wenn du Best-Price-Perioden nutzt."
         },
         "tomorrow_volatility": {
-            "description": "Preisvolatilitätsklassifizierung für morgen",
-            "long_description": "Zeigt, wie stark die Strompreise im Laufe des morgigen Tages variieren werden, basierend auf der Spannweite (Differenz zwischen höchstem und niedrigstem Preis). Wird nicht verfügbar, bis morgige Daten veröffentlicht sind (typischerweise 13:00-14:00 MEZ).",
-            "usage_tips": "Verwende dies zur Vorausplanung des morgigen Energieverbrauchs. Bei hoher oder sehr hoher Volatilität morgen lohnt sich die Optimierung des Energieverbrauchs. Bei niedriger Volatilität kannst du Geräte jederzeit ohne wesentliche Kostenunterschiede betreiben."
+            "description": "Wie stark sich die Strompreise morgen verändern werden",
+            "long_description": "Zeigt, ob die Preise morgen stabil bleiben oder stark schwanken. Verfügbar, sobald die morgigen Daten veröffentlicht sind (typischerweise 13:00–14:00 MEZ). Niedrige Volatilität bedeutet recht konstante Preise – Timing ist nicht kritisch. Hohe Volatilität bedeutet deutliche Preisunterschiede über den Tag – gute Gelegenheit, energieintensive Aufgaben zu planen. `price_coefficient_variation_%` zeigt den Prozentwert, `price_spread` die absolute Preisspanne.",
+            "usage_tips": "Nutze dies für die Planung des morgigen Energieverbrauchs. Hohe Volatilität? Plane flexible Lasten in Best-Price-Perioden. Niedrige Volatilität? Lass Geräte laufen, wann es dir passt."
         },
         "next_24h_volatility": {
-            "description": "Preisvolatilitätsklassifizierung für die rollierenden nächsten 24 Stunden",
-            "long_description": "Zeigt, wie stark die Strompreise in den nächsten 24 Stunden ab jetzt variieren (rollierendes Fenster). Dies überschreitet Tagesgrenzen und aktualisiert sich alle 15 Minuten, wodurch eine vorausschauende Volatilitätsbewertung unabhängig von Kalendertagen bereitgestellt wird.",
-            "usage_tips": "Bester Sensor für Echtzeitoptimierungsentscheidungen. Im Gegensatz zu Heute/Morgen-Sensoren, die um Mitternacht wechseln, bietet dies eine kontinuierliche 24h-Volatilitätsbewertung. Verwende dies für Batterielade-Strategien, die Tagesgrenzen überschreiten."
+            "description": "Wie stark sich die Preise in den nächsten 24 Stunden verändern",
+            "long_description": "Zeigt die Preisvolatilität für ein rollierendes 24-Stunden-Fenster ab jetzt (aktualisiert alle 15 Minuten). Niedrige Volatilität bedeutet recht konstante Preise. Hohe Volatilität bedeutet spürbare Preisschwankungen und damit Chancen zur Optimierung. Im Unterschied zu Heute/Morgen-Sensoren überschreitet dieser Tagesgrenzen und liefert eine durchgängige Vorhersage. `price_coefficient_variation_%` zeigt den Prozentwert, `price_spread` die absolute Preisspanne.",
+            "usage_tips": "Am besten für Entscheidungen in Echtzeit. Nutze dies für Batterieladestrategien oder andere flexible Lasten, die über Mitternacht laufen könnten. Bietet eine konsistente 24h-Perspektive unabhängig vom Kalendertag."
         },
         "today_tomorrow_volatility": {
-            "description": "Kombinierte Preisvolatilitätsklassifizierung für heute und morgen",
-            "long_description": "Zeigt die Volatilität über heute und morgen zusammen (wenn morgige Daten verfügbar sind). Bietet eine erweiterte Ansicht der Preisvariation über bis zu 48 Stunden. Fällt auf Nur-Heute zurück, wenn morgige Daten noch nicht verfügbar sind.",
-            "usage_tips": "Verwende dies für Mehrtagsplanung und um zu verstehen, ob Preismöglichkeiten über die Tagesgrenze hinweg bestehen. Die Attribute 'today_volatility' und 'tomorrow_volatility' zeigen individuelle Tagesbeiträge. Nützlich für die Planung von Ladesitzungen, die Mitternacht überschreiten könnten."
+            "description": "Kombinierte Preisvolatilität für heute und morgen",
+            "long_description": "Zeigt die Gesamtvolatilität, wenn heute und morgen gemeinsam betrachtet werden (sobald die morgigen Daten verfügbar sind). Zeigt, ob über die Tagesgrenze hinweg deutliche Preisunterschiede bestehen. Fällt auf nur-heute zurück, wenn morgige Daten noch fehlen. Hilfreich für mehrtägige Optimierung. `price_coefficient_variation_%` zeigt den Prozentwert, `price_spread` die absolute Preisspanne.",
+            "usage_tips": "Nutze dies für Aufgaben, die sich über mehrere Tage erstrecken. Prüfe, ob die Preisunterschiede groß genug für eine Planung sind. Die einzelnen Tages-Sensoren zeigen die Beiträge pro Tag, falls du mehr Details brauchst."
         },
         "data_lifecycle_status": {
             "description": "Aktueller Status des Preisdaten-Lebenszyklus und der Zwischenspeicherung",
@@ -320,14 +322,14 @@
             "usage_tips": "Nutze dies, um einen Countdown wie 'Günstiger Zeitraum endet in 2 Stunden' (wenn aktiv) oder 'Nächster günstiger Zeitraum endet um 14:00' (wenn inaktiv) anzuzeigen. Home Assistant zeigt automatisch relative Zeit für Zeitstempel-Sensoren an."
         },
         "best_price_period_duration": {
-            "description": "Gesamtlänge des aktuellen oder nächsten günstigen Zeitraums in Minuten",
-            "long_description": "Zeigt, wie lange der günstige Zeitraum insgesamt dauert. Während eines aktiven Zeitraums zeigt dies die Dauer des aktuellen Zeitraums. Wenn kein Zeitraum aktiv ist, zeigt dies die Dauer des nächsten kommenden Zeitraums. Gibt nur 'Unbekannt' zurück, wenn keine Zeiträume ermittelt wurden.",
-            "usage_tips": "Nützlich für Planung: 'Der nächste günstige Zeitraum dauert 90 Minuten' oder 'Der aktuelle günstige Zeitraum ist 120 Minuten lang'. Kombiniere mit remaining_minutes, um zu berechnen, wann langlaufende Geräte gestartet werden sollten."
+            "description": "Gesamtlänge des aktuellen oder nächsten günstigen Zeitraums",
+            "long_description": "Zeigt, wie lange der günstige Zeitraum insgesamt dauert. Der State wird in Stunden angezeigt (z. B. 1,5 h) für eine einfache Lesbarkeit in der UI, während das Attribut `period_duration_minutes` denselben Wert in Minuten bereitstellt (z. B. 90) für Automationen. Während eines aktiven Zeitraums zeigt dies die Dauer des aktuellen Zeitraums. Wenn kein Zeitraum aktiv ist, zeigt dies die Dauer des nächsten kommenden Zeitraums. Gibt nur 'Unbekannt' zurück, wenn keine Zeiträume ermittelt wurden.",
+            "usage_tips": "Für Anzeige: State-Wert (Stunden) in Dashboards nutzen. Für Automationen: Attribut `period_duration_minutes` verwenden, um zu prüfen, ob genug Zeit für langläufige Geräte ist (z. B. 'Wenn period_duration_minutes >= 90, starte Waschmaschine')."
         },
         "best_price_remaining_minutes": {
-            "description": "Verbleibende Minuten im aktuellen günstigen Zeitraum (0 wenn inaktiv)",
-            "long_description": "Zeigt, wie viele Minuten im aktuellen günstigen Zeitraum noch verbleiben. Gibt 0 zurück, wenn kein Zeitraum aktiv ist. Aktualisiert sich jede Minute. Prüfe binary_sensor.best_price_period, um zu sehen, ob ein Zeitraum aktuell aktiv ist.",
-            "usage_tips": "Perfekt für Automatisierungen: 'Wenn remaining_minutes > 0 UND remaining_minutes < 30, starte Waschmaschine jetzt'. Der Wert 0 macht es einfach zu prüfen, ob ein Zeitraum aktiv ist (Wert > 0) oder nicht (Wert = 0)."
+            "description": "Verbleibende Zeit im aktuellen günstigen Zeitraum",
+            "long_description": "Zeigt, wie viel Zeit im aktuellen günstigen Zeitraum noch verbleibt. Der State wird in Stunden angezeigt (z. B. 0,5 h) für eine einfache Lesbarkeit, während das Attribut `remaining_minutes` Minuten bereitstellt (z. B. 30) für Automationslogik. Gibt 0 zurück, wenn kein Zeitraum aktiv ist. Aktualisiert sich jede Minute. Prüfe binary_sensor.best_price_period, um zu sehen, ob ein Zeitraum aktuell aktiv ist.",
+            "usage_tips": "Für Automationen: Attribut `remaining_minutes` mit numerischen Vergleichen nutzen wie 'Wenn remaining_minutes > 0 UND remaining_minutes < 30, starte Waschmaschine jetzt'. Der Wert 0 macht es einfach zu prüfen, ob ein Zeitraum aktiv ist (Wert > 0) oder nicht (Wert = 0)."
         },
         "best_price_progress": {
             "description": "Fortschritt durch aktuellen günstigen Zeitraum (0% wenn inaktiv)",
@@ -340,9 +342,9 @@
             "usage_tips": "Immer nützlich für Vorausplanung: 'Nächster günstiger Zeitraum startet in 3 Stunden' (egal, ob du gerade in einem Zeitraum bist oder nicht). Kombiniere mit Automatisierungen: 'Wenn nächste Startzeit in 10 Minuten ist, sende Benachrichtigung zur Vorbereitung der Waschmaschine'."
         },
         "best_price_next_in_minutes": {
-            "description": "Minuten bis nächster günstiger Zeitraum startet (0 beim Übergang)",
-            "long_description": "Zeigt Minuten bis der nächste günstige Zeitraum startet. Während eines aktiven Zeitraums zeigt dies die Zeit bis zum Zeitraum nach dem aktuellen. Gibt 0 während kurzer Übergangsphasen zurück. Aktualisiert sich jede Minute.",
-            "usage_tips": "Perfekt für 'warte bis günstiger Zeitraum' Automatisierungen: 'Wenn next_in_minutes > 0 UND next_in_minutes < 15, warte, bevor du die Geschirrspülmaschine startest'. Wert > 0 zeigt immer an, dass ein zukünftiger Zeitraum geplant ist."
+            "description": "Zeit bis zum nächsten günstigen Zeitraum",
+            "long_description": "Zeigt, wie lange es bis zum nächsten günstigen Zeitraum dauert. Der State wird in Stunden angezeigt (z. B. 2,25 h) für Dashboards, während das Attribut `next_in_minutes` Minuten bereitstellt (z. B. 135) für Automationsbedingungen. Während eines aktiven Zeitraums zeigt dies die Zeit bis zum Zeitraum nach dem aktuellen. Gibt 0 während kurzer Übergangsphasen zurück. Aktualisiert sich jede Minute.",
+            "usage_tips": "Für Automationen: Attribut `next_in_minutes` nutzen wie 'Wenn next_in_minutes > 0 UND next_in_minutes < 15, warte, bevor du die Geschirrspülmaschine startest'. Wert > 0 zeigt immer an, dass ein zukünftiger Zeitraum geplant ist."
         },
         "peak_price_end_time": {
             "description": "Wann der aktuelle oder nächste teure Zeitraum endet",
@@ -350,14 +352,14 @@
             "usage_tips": "Nutze dies, um 'Teurer Zeitraum endet in 1 Stunde' (wenn aktiv) oder 'Nächster teurer Zeitraum endet um 18:00' (wenn inaktiv) anzuzeigen. Kombiniere mit Automatisierungen, um den Betrieb nach der Spitzenzeit fortzusetzen."
         },
         "peak_price_period_duration": {
-            "description": "Gesamtlänge des aktuellen oder nächsten teuren Zeitraums in Minuten",
-            "long_description": "Zeigt, wie lange der teure Zeitraum insgesamt dauert. Während eines aktiven Zeitraums zeigt dies die Dauer des aktuellen Zeitraums. Wenn kein Zeitraum aktiv ist, zeigt dies die Dauer des nächsten kommenden Zeitraums. Gibt nur 'Unbekannt' zurück, wenn keine Zeiträume ermittelt wurden.",
-            "usage_tips": "Nützlich für Planung: 'Der nächste teure Zeitraum dauert 60 Minuten' oder 'Der aktuelle Spitzenzeitraum ist 90 Minuten lang'. Kombiniere mit remaining_minutes, um zu entscheiden, ob die Spitze abgewartet oder der Betrieb fortgesetzt werden soll."
+            "description": "Länge des aktuellen/nächsten teuren Zeitraums",
+            "long_description": "Gesamtdauer des aktuellen oder nächsten teuren Zeitraums. Der State wird in Stunden angezeigt (z. B. 1,5 h) für leichtes Ablesen in der UI, während das Attribut `period_duration_minutes` denselben Wert in Minuten bereitstellt (z. B. 90) für Automationen. Dieser Wert repräsentiert die **volle geplante Dauer** des Zeitraums und ist konstant während des gesamten Zeitraums, auch wenn die verbleibende Zeit (remaining_minutes) abnimmt.",
+            "usage_tips": "Kombiniere mit remaining_minutes, um zu berechnen, wann langlaufende Geräte gestoppt werden sollen: Zeitraum begann vor `period_duration_minutes - remaining_minutes` Minuten. Dieses Attribut unterstützt Energiespar-Strategien, indem es hilft, Hochverbrauchsaktivitäten außerhalb teurer Perioden zu planen."
         },
         "peak_price_remaining_minutes": {
-            "description": "Verbleibende Minuten im aktuellen teuren Zeitraum (0 wenn inaktiv)",
-            "long_description": "Zeigt, wie viele Minuten im aktuellen teuren Zeitraum noch verbleiben. Gibt 0 zurück, wenn kein Zeitraum aktiv ist. Aktualisiert sich jede Minute. Prüfe binary_sensor.peak_price_period, um zu sehen, ob ein Zeitraum aktuell aktiv ist.",
-            "usage_tips": "Nutze in Automatisierungen: 'Wenn remaining_minutes > 60, breche aufgeschobene Ladesitzung ab'. Wert 0 macht es einfach zu unterscheiden zwischen aktivem (Wert > 0) und inaktivem (Wert = 0) Zeitraum."
+            "description": "Verbleibende Zeit im aktuellen teuren Zeitraum",
+            "long_description": "Zeigt, wie viel Zeit im aktuellen teuren Zeitraum noch verbleibt. Der State wird in Stunden angezeigt (z. B. 0,75 h) für einfaches Ablesen in Dashboards, während das Attribut `remaining_minutes` dieselbe Zeit in Minuten liefert (z. B. 45) für Automationsbedingungen. **Countdown-Timer**: Dieser Wert dekrementiert jede Minute während eines aktiven Zeitraums. Gibt 0 zurück, wenn kein teurer Zeitraum aktiv ist. Aktualisiert sich minütlich.",
+            "usage_tips": "Für Automationen: Nutze Attribut `remaining_minutes` wie 'Wenn remaining_minutes > 60, setze Heizung auf Energiesparmodus' oder 'Wenn remaining_minutes < 15, erhöhe Temperatur wieder'. UI zeigt benutzerfreundliche Stunden (z. B. 1,25 h). Wert 0 zeigt an, dass kein teurer Zeitraum aktiv ist."
         },
         "peak_price_progress": {
             "description": "Fortschritt durch aktuellen teuren Zeitraum (0% wenn inaktiv)",
@@ -370,9 +372,9 @@
             "usage_tips": "Immer nützlich für Planung: 'Nächster teurer Zeitraum startet in 2 Stunden'. Automatisierung: 'Wenn nächste Startzeit in 30 Minuten ist, reduziere Heiztemperatur vorsorglich'."
         },
         "peak_price_next_in_minutes": {
-            "description": "Minuten bis nächster teurer Zeitraum startet (0 beim Übergang)",
-            "long_description": "Zeigt Minuten bis der nächste teure Zeitraum startet. Während eines aktiven Zeitraums zeigt dies die Zeit bis zum Zeitraum nach dem aktuellen. Gibt 0 während kurzer Übergangsphasen zurück. Aktualisiert sich jede Minute.",
-            "usage_tips": "Präventive Automatisierung: 'Wenn next_in_minutes > 0 UND next_in_minutes < 10, beende aktuellen Ladezyklus jetzt, bevor die Preise steigen'."
+            "description": "Zeit bis zum nächsten teuren Zeitraum",
+            "long_description": "Zeigt, wie lange es bis zum nächsten teuren Zeitraum dauert. Der State wird in Stunden angezeigt (z. B. 2,25 h) für Dashboards, während das Attribut `next_in_minutes` Minuten bereitstellt (z. B. 135) für Automationsbedingungen. Während eines aktiven Zeitraums zeigt dies die Zeit bis zum Zeitraum nach dem aktuellen. Gibt 0 während kurzer Übergangsphasen zurück. Aktualisiert sich jede Minute.",
+            "usage_tips": "Für Automationen: Attribut `next_in_minutes` nutzen wie 'Wenn next_in_minutes > 0 UND next_in_minutes < 10, reduziere Heizung vorsorglich bevor der teure Zeitraum beginnt'. Wert > 0 zeigt immer an, dass ein zukünftiger teurer Zeitraum geplant ist."
         },
         "home_type": {
             "description": "Art der Wohnung (Wohnung, Haus usw.)",
@@ -487,6 +489,80 @@
             "usage_tips": "Verwende dies, um zu überprüfen, ob Echtzeit-Verbrauchsdaten verfügbar sind. Aktiviere Benachrichtigungen, falls dies unerwartet auf 'Aus' wechselt, was auf potenzielle Hardware- oder Verbindungsprobleme hinweist."
         }
     },
+    "number": {
+        "best_price_flex_override": {
+            "description": "Maximaler Prozentsatz über dem Tagesminimumpreis, den Intervalle haben können und trotzdem als 'Bestpreis' gelten. Empfohlen: 15-20 mit Lockerung aktiviert (Standard), oder 25-35 ohne Lockerung. Maximum: 50 (Obergrenze für zuverlässige Periodenerkennung).",
+            "long_description": "Wenn diese Entität aktiviert ist, überschreibt ihr Wert die Einstellung 'Flexibilität' aus dem Optionen-Dialog für die Bestpreis-Periodenberechnung.",
+            "usage_tips": "Aktiviere diese Entität, um die Bestpreiserkennung dynamisch über Automatisierungen anzupassen, z.B. höhere Flexibilität bei kritischen Lasten oder engere Anforderungen für flexible Geräte."
+        },
+        "best_price_min_distance_override": {
+            "description": "Minimaler prozentualer Abstand unter dem Tagesdurchschnitt. Intervalle müssen so weit unter dem Durchschnitt liegen, um als 'Bestpreis' zu gelten. Hilft, echte Niedrigpreis-Perioden von durchschnittlichen Preisen zu unterscheiden.",
+            "long_description": "Wenn diese Entität aktiviert ist, überschreibt ihr Wert die Einstellung 'Mindestabstand' aus dem Optionen-Dialog für die Bestpreis-Periodenberechnung.",
+            "usage_tips": "Erhöhe den Wert, wenn du strengere Bestpreis-Kriterien möchtest. Verringere ihn, wenn zu wenige Perioden erkannt werden."
+        },
+        "best_price_min_period_length_override": {
+            "description": "Minimale Periodenl\u00e4nge in 15-Minuten-Intervallen. Perioden kürzer als diese werden nicht gemeldet. Beispiel: 2 = mindestens 30 Minuten.",
+            "long_description": "Wenn diese Entität aktiviert ist, überschreibt ihr Wert die Einstellung 'Mindestperiodenlänge' aus dem Optionen-Dialog für die Bestpreis-Periodenberechnung.",
+            "usage_tips": "Passe an die typische Laufzeit deiner Geräte an: 2 (30 Min) für Schnellprogramme, 4-8 (1-2 Std) für normale Zyklen, 8+ für lange ECO-Programme."
+        },
+        "best_price_min_periods_override": {
+            "description": "Minimale Anzahl an Bestpreis-Perioden, die täglich gefunden werden sollen. Wenn Lockerung aktiviert ist, wird das System die Kriterien automatisch anpassen, um diese Zahl zu erreichen.",
+            "long_description": "Wenn diese Entität aktiviert ist, überschreibt ihr Wert die Einstellung 'Mindestperioden' aus dem Optionen-Dialog für die Bestpreis-Periodenberechnung.",
+            "usage_tips": "Setze dies auf die Anzahl zeitkritischer Aufgaben, die du täglich hast. Beispiel: 2 für zwei Waschmaschinenladungen."
+        },
+        "best_price_relaxation_attempts_override": {
+            "description": "Anzahl der Versuche, die Kriterien schrittweise zu lockern, um die Mindestperiodenanzahl zu erreichen. Jeder Versuch erhöht die Flexibilität um 3 Prozent. Bei 0 werden nur Basis-Kriterien verwendet.",
+            "long_description": "Wenn diese Entität aktiviert ist, überschreibt ihr Wert die Einstellung 'Lockerungsversuche' aus dem Optionen-Dialog für die Bestpreis-Periodenberechnung.",
+            "usage_tips": "Höhere Werte machen die Periodenerkennung anpassungsfähiger an Tage mit stabilen Preisen. Setze auf 0, um strenge Kriterien ohne Lockerung zu erzwingen."
+        },
+        "best_price_gap_count_override": {
+            "description": "Maximale Anzahl teurerer Intervalle, die zwischen günstigen Intervallen erlaubt sind und trotzdem als eine zusammenhängende Periode gelten. Bei 0 müssen günstige Intervalle aufeinander folgen.",
+            "long_description": "Wenn diese Entität aktiviert ist, überschreibt ihr Wert die Einstellung 'Lückentoleranz' aus dem Optionen-Dialog für die Bestpreis-Periodenberechnung.",
+            "usage_tips": "Erhöhe dies für Geräte mit variabler Last (z.B. Wärmepumpen), die kurze teurere Intervalle tolerieren können. Setze auf 0 für kontinuierliche günstige Perioden."
+        },
+        "peak_price_flex_override": {
+            "description": "Maximaler Prozentsatz unter dem Tagesmaximumpreis, den Intervalle haben können und trotzdem als 'Spitzenpreis' gelten. Gleiche Empfehlungen wie für Bestpreis-Flexibilität.",
+            "long_description": "Wenn diese Entität aktiviert ist, überschreibt ihr Wert die Einstellung 'Flexibilität' aus dem Optionen-Dialog für die Spitzenpreis-Periodenberechnung.",
+            "usage_tips": "Nutze dies, um den Spitzenpreis-Schwellenwert zur Laufzeit für Automatisierungen anzupassen, die den Verbrauch während teurer Stunden vermeiden."
+        },
+        "peak_price_min_distance_override": {
+            "description": "Minimaler prozentualer Abstand über dem Tagesdurchschnitt. Intervalle müssen so weit über dem Durchschnitt liegen, um als 'Spitzenpreis' zu gelten.",
+            "long_description": "Wenn diese Entität aktiviert ist, überschreibt ihr Wert die Einstellung 'Mindestabstand' aus dem Optionen-Dialog für die Spitzenpreis-Periodenberechnung.",
+            "usage_tips": "Erhöhe den Wert, um nur extreme Preisspitzen zu erfassen. Verringere ihn, um mehr Hochpreiszeiten einzubeziehen."
+        },
+        "peak_price_min_period_length_override": {
+            "description": "Minimale Periodenl\u00e4nge in 15-Minuten-Intervallen für Spitzenpreise. Kürzere Preisspitzen werden nicht als Perioden gemeldet.",
+            "long_description": "Wenn diese Entität aktiviert ist, überschreibt ihr Wert die Einstellung 'Mindestperiodenlänge' aus dem Optionen-Dialog für die Spitzenpreis-Periodenberechnung.",
+            "usage_tips": "Kürzere Werte erfassen kurze Preisspitzen. Längere Werte fokussieren auf anhaltende Hochpreisphasen."
+        },
+        "peak_price_min_periods_override": {
+            "description": "Minimale Anzahl an Spitzenpreis-Perioden, die täglich gefunden werden sollen.",
+            "long_description": "Wenn diese Entität aktiviert ist, überschreibt ihr Wert die Einstellung 'Mindestperioden' aus dem Optionen-Dialog für die Spitzenpreis-Periodenberechnung.",
+            "usage_tips": "Setze dies basierend darauf, wie viele Hochpreisphasen du pro Tag für Automatisierungen erfassen möchtest."
+        },
+        "peak_price_relaxation_attempts_override": {
+            "description": "Anzahl der Versuche, die Kriterien zu lockern, um die Mindestanzahl an Spitzenpreis-Perioden zu erreichen.",
+            "long_description": "Wenn diese Entität aktiviert ist, überschreibt ihr Wert die Einstellung 'Lockerungsversuche' aus dem Optionen-Dialog für die Spitzenpreis-Periodenberechnung.",
+            "usage_tips": "Erhöhe dies, wenn an Tagen mit stabilen Preisen keine Perioden gefunden werden. Setze auf 0, um strenge Kriterien zu erzwingen."
+        },
+        "peak_price_gap_count_override": {
+            "description": "Maximale Anzahl günstigerer Intervalle, die zwischen teuren Intervallen erlaubt sind und trotzdem als eine Spitzenpreis-Periode gelten.",
+            "long_description": "Wenn diese Entität aktiviert ist, überschreibt ihr Wert die Einstellung 'Lückentoleranz' aus dem Optionen-Dialog für die Spitzenpreis-Periodenberechnung.",
+            "usage_tips": "Höhere Werte erfassen längere Hochpreisphasen auch mit kurzen Preiseinbrüchen. Setze auf 0, um strikt zusammenhängende Spitzenpreise zu erfassen."
+        }
+    },
+    "switch": {
+        "best_price_enable_relaxation_override": {
+            "description": "Wenn aktiviert, werden die Kriterien automatisch gelockert, um die Mindestperiodenanzahl zu erreichen. Wenn deaktiviert, werden nur Perioden gemeldet, die die strengen Kriterien erfüllen (möglicherweise null Perioden bei stabilen Preisen).",
+            "long_description": "Wenn diese Entität aktiviert ist, überschreibt ihr Wert die Einstellung 'Mindestanzahl erreichen' aus dem Optionen-Dialog für die Bestpreis-Periodenberechnung.",
+            "usage_tips": "Aktiviere dies für garantierte tägliche Automatisierungsmöglichkeiten. Deaktiviere es, wenn du nur wirklich günstige Zeiträume willst, auch wenn das bedeutet, dass an manchen Tagen keine Perioden gefunden werden."
+        },
+        "peak_price_enable_relaxation_override": {
+            "description": "Wenn aktiviert, werden die Kriterien automatisch gelockert, um die Mindestperiodenanzahl zu erreichen. Wenn deaktiviert, werden nur echte Preisspitzen gemeldet.",
+            "long_description": "Wenn diese Entität aktiviert ist, überschreibt ihr Wert die Einstellung 'Mindestanzahl erreichen' aus dem Optionen-Dialog für die Spitzenpreis-Periodenberechnung.",
+            "usage_tips": "Aktiviere dies für konsistente Spitzenpreis-Warnungen. Deaktiviere es, um nur extreme Preisspitzen zu erfassen."
+        }
+    },
     "home_types": {
         "APARTMENT": "Wohnung",
         "ROWHOUSE": "Reihenhaus",

custom_components/tibber_prices/custom_translations/en.json

@@ -2,7 +2,9 @@
     "apexcharts": {
         "title_rating_level": "Price Phases Daily Progress",
         "title_level": "Price Level",
+        "hourly_suffix": "(Ø hourly)",
         "best_price_period_name": "Best Price Period",
+        "peak_price_period_name": "Peak Price Period",
         "notification": {
             "metadata_sensor_unavailable": {
                 "title": "Tibber Prices: ApexCharts YAML Generated with Limited Functionality",
@@ -56,9 +58,9 @@
             "usage_tips": "Use this to avoid running appliances during peak price times"
         },
         "average_price_today": {
-            "description": "The average electricity price for today per kWh",
-            "long_description": "Shows the average price per kWh for the current day from your Tibber subscription",
-            "usage_tips": "Use this as a baseline for comparing current prices"
+            "description": "The typical electricity price for today per kWh (configurable display format)",
+            "long_description": "Shows the typical price per kWh for today. **By default, the state displays the median** (resistant to extreme spikes, showing what you can generally expect). You can change this in the integration options to show the arithmetic mean instead. The alternate value is always available as attribute `price_mean` or `price_median` for automations.",
+            "usage_tips": "Use the state value for display. For exact cost calculations in automations, use: {{ state_attr('sensor.average_price_today', 'price_mean') }}"
         },
         "lowest_price_tomorrow": {
             "description": "The lowest electricity price for tomorrow per kWh",
@@ -71,9 +73,9 @@
             "usage_tips": "Use this to avoid running appliances during tomorrow's peak price times. Helpful for planning around expensive periods."
         },
         "average_price_tomorrow": {
-            "description": "The average electricity price for tomorrow per kWh",
-            "long_description": "Shows the average price per kWh for tomorrow from your Tibber subscription. This sensor becomes unavailable until tomorrow's data is published by Tibber (typically around 13:00-14:00 CET).",
-            "usage_tips": "Use this as a baseline for comparing tomorrow's prices and planning consumption. Compare with today's average to see if tomorrow will be more or less expensive overall."
+            "description": "The typical electricity price for tomorrow per kWh (configurable display format)",
+            "long_description": "Shows the typical price per kWh for tomorrow. **By default, the state displays the median** (resistant to extreme spikes). You can change this in the integration options to show the arithmetic mean instead. The alternate value is available as attribute. This sensor becomes unavailable until tomorrow's data is published by Tibber (typically around 13:00-14:00 CET).",
+            "usage_tips": "Use this to plan tomorrow's energy consumption. For cost calculations, use: {{ state_attr('sensor.average_price_tomorrow', 'price_mean') }}"
         },
         "yesterday_price_level": {
             "description": "Aggregated price level for yesterday",
@@ -106,14 +108,14 @@
             "usage_tips": "Use this to plan tomorrow's energy consumption based on your personalized price thresholds. Compare with today to decide if you should shift consumption to tomorrow or use energy today."
         },
         "trailing_price_average": {
-            "description": "The average electricity price for the past 24 hours per kWh",
-            "long_description": "Shows the average price per kWh calculated from the past 24 hours (trailing average) from your Tibber subscription. This provides a rolling average that updates every 15 minutes based on historical data.",
-            "usage_tips": "Use this to compare current prices against recent trends. A current price significantly above this average may indicate a good time to reduce consumption."
+            "description": "The typical electricity price for the past 24 hours per kWh (configurable display format)",
+            "long_description": "Shows the typical price per kWh for the past 24 hours. **By default, the state displays the median** (resistant to extreme spikes, showing what price level was typical). You can change this in the integration options to show the arithmetic mean instead. The alternate value is available as attribute. Updates every 15 minutes.",
+            "usage_tips": "Use the state value to see the typical recent price level. For cost calculations, use: {{ state_attr('sensor.trailing_price_average', 'price_mean') }}"
         },
         "leading_price_average": {
-            "description": "The average electricity price for the next 24 hours per kWh",
-            "long_description": "Shows the average price per kWh calculated from the next 24 hours (leading average) from your Tibber subscription. This provides a forward-looking average based on available forecast data.",
-            "usage_tips": "Use this to plan energy usage. If the current price is below the leading average, it may be a good time to run energy-intensive appliances."
+            "description": "The typical electricity price for the next 24 hours per kWh (configurable display format)",
+            "long_description": "Shows the typical price per kWh for the next 24 hours. **By default, the state displays the median** (resistant to extreme spikes, showing what price level to expect). You can change this in the integration options to show the arithmetic mean instead. The alternate value is available as attribute.",
+            "usage_tips": "Use the state value to see the typical upcoming price level. For cost calculations, use: {{ state_attr('sensor.leading_price_average', 'price_mean') }}"
         },
         "trailing_price_min": {
             "description": "The minimum electricity price for the past 24 hours per kWh",
@@ -290,24 +292,24 @@
             "long_description": "Shows the timestamp of the latest available price data interval from your Tibber subscription"
         },
         "today_volatility": {
-            "description": "Price volatility classification for today",
-            "long_description": "Shows how much electricity prices vary throughout today based on the spread (difference between highest and lowest price). Classification: low = spread < 5ct, moderate = 5-15ct, high = 15-30ct, very high = >30ct.",
-            "usage_tips": "Use this to decide if price-based optimization is worthwhile. For example, with a balcony battery that has 15% efficiency losses, optimization only makes sense when volatility is at least moderate. Create automations that check volatility before scheduling charging/discharging cycles."
+            "description": "How much electricity prices change throughout today",
+            "long_description": "Indicates whether today's prices are stable or have big swings. Low volatility means prices stay fairly consistent—timing doesn't matter much. High volatility means significant price differences throughout the day—great opportunity to shift consumption to cheaper periods. Check `price_coefficient_variation_%` for the variance percentage and `price_spread` for the absolute price span.",
+            "usage_tips": "Use this to decide if optimization is worth your effort. On low-volatility days, you can run devices anytime. On high-volatility days, following Best Price periods saves meaningful money."
         },
         "tomorrow_volatility": {
-            "description": "Price volatility classification for tomorrow",
-            "long_description": "Shows how much electricity prices will vary throughout tomorrow based on the spread (difference between highest and lowest price). Becomes unavailable until tomorrow's data is published (typically 13:00-14:00 CET).",
-            "usage_tips": "Use this for advance planning of tomorrow's energy usage. If tomorrow has high or very high volatility, it's worth optimizing energy consumption timing. If low, you can run devices anytime without significant cost differences."
+            "description": "How much electricity prices will change tomorrow",
+            "long_description": "Indicates whether tomorrow's prices will be stable or have big swings. Available once tomorrow's data is published (typically 13:00-14:00 CET). Low volatility means prices stay fairly consistent—timing isn't critical. High volatility means significant price differences throughout the day—good opportunity for scheduling energy-intensive activities. Check `price_coefficient_variation_%` for the variance percentage and `price_spread` for the absolute price span.",
+            "usage_tips": "Use for planning tomorrow's energy consumption. High volatility? Schedule flexible loads during Best Price periods. Low volatility? Run devices whenever is convenient."
         },
         "next_24h_volatility": {
-            "description": "Price volatility classification for the rolling next 24 hours",
-            "long_description": "Shows how much electricity prices vary in the next 24 hours from now (rolling window). This crosses day boundaries and updates every 15 minutes, providing a forward-looking volatility assessment independent of calendar days.",
-            "usage_tips": "Best sensor for real-time optimization decisions. Unlike today/tomorrow sensors that switch at midnight, this provides continuous 24h volatility assessment. Use for battery charging strategies that span across day boundaries."
+            "description": "How much prices will change over the next 24 hours",
+            "long_description": "Indicates price volatility for a rolling 24-hour window from now (updates every 15 minutes). Low volatility means prices stay fairly consistent. High volatility means significant price swings offer optimization opportunities. Unlike today/tomorrow sensors, this crosses day boundaries and provides a continuous forward-looking assessment. Check `price_coefficient_variation_%` for the variance percentage and `price_spread` for the absolute price span.",
+            "usage_tips": "Best for real-time decisions. Use when planning battery charging strategies or other flexible loads that might span across midnight. Provides consistent 24h perspective regardless of calendar day."
         },
         "today_tomorrow_volatility": {
-            "description": "Combined price volatility classification for today and tomorrow",
-            "long_description": "Shows volatility across both today and tomorrow combined (when tomorrow's data is available). Provides an extended view of price variation spanning up to 48 hours. Falls back to today-only when tomorrow's data isn't available yet.",
-            "usage_tips": "Use this for multi-day planning and to understand if price opportunities exist across the day boundary. The 'today_volatility' and 'tomorrow_volatility' breakdown attributes show individual day contributions. Useful for scheduling charging sessions that might span midnight."
+            "description": "Combined price volatility across today and tomorrow",
+            "long_description": "Shows overall price volatility when considering both today and tomorrow together (when available). Indicates whether there are significant price differences across the day boundary. Falls back to today-only when tomorrow's data isn't available yet. Useful for understanding multi-day optimization opportunities. Check `price_coefficient_variation_%` for the variance percentage and `price_spread` for the absolute price span.",
+            "usage_tips": "Use for planning tasks that span multiple days. Check if prices vary enough to make scheduling worthwhile. The individual day volatility sensors show breakdown per day if you need more detail."
         },
         "data_lifecycle_status": {
             "description": "Current state of price data lifecycle and caching",
@@ -320,14 +322,14 @@
             "usage_tips": "Use this to display a countdown like 'Cheap period ends in 2 hours' (when active) or 'Next cheap period ends at 14:00' (when inactive). Home Assistant automatically shows relative time for timestamp sensors."
         },
         "best_price_period_duration": {
-            "description": "Total length of current or next best price period in minutes",
-            "long_description": "Shows how long the best price period lasts in total. During an active period, shows the duration of the current period. When no period is active, shows the duration of the next upcoming period. Returns 'Unknown' only when no periods are configured.",
-            "usage_tips": "Useful for planning: 'The next cheap period lasts 90 minutes' or 'Current cheap period is 120 minutes long'. Combine with remaining_minutes to calculate when to start long-running appliances."
+            "description": "Total length of current or next best price period",
+            "long_description": "Shows how long the best price period lasts in total. The state is displayed in hours (e.g., 1.5 h) for easy reading in the UI, while the `period_duration_minutes` attribute provides the same value in minutes (e.g., 90) for use in automations. During an active period, shows the duration of the current period. When no period is active, shows the duration of the next upcoming period. Returns 'Unknown' only when no periods are configured.",
+            "usage_tips": "For display: Use the state value (hours) in dashboards. For automations: Use `period_duration_minutes` attribute to check if there's enough time for long-running tasks (e.g., 'If period_duration_minutes >= 90, start washing machine')."
         },
         "best_price_remaining_minutes": {
-            "description": "Minutes remaining in current best price period (0 when inactive)",
-            "long_description": "Shows how many minutes are left in the current best price period. Returns 0 when no period is active. Updates every minute. Check binary_sensor.best_price_period to see if a period is currently active.",
-            "usage_tips": "Perfect for automations: 'If remaining_minutes > 0 AND remaining_minutes < 30, start washing machine now'. The value 0 makes it easy to check if a period is active (value > 0) or not (value = 0)."
+            "description": "Time remaining in current best price period",
+            "long_description": "Shows how much time is left in the current best price period. The state displays in hours (e.g., 0.5 h) for easy reading, while the `remaining_minutes` attribute provides minutes (e.g., 30) for automation logic. Returns 0 when no period is active. Updates every minute. Check binary_sensor.best_price_period to see if a period is currently active.",
+            "usage_tips": "For automations: Use `remaining_minutes` attribute with numeric comparisons like 'If remaining_minutes > 0 AND remaining_minutes < 30, start washing machine now'. The value 0 makes it easy to check if a period is active (value > 0) or not (value = 0)."
         },
         "best_price_progress": {
             "description": "Progress through current best price period (0% when inactive)",
@@ -340,9 +342,9 @@
             "usage_tips": "Always useful for planning ahead: 'Next cheap period starts in 3 hours' (whether you're in a period now or not). Combine with automations: 'When next start time is in 10 minutes, send notification to prepare washing machine'."
         },
         "best_price_next_in_minutes": {
-            "description": "Minutes until next best price period starts (0 when in transition)",
-            "long_description": "Shows minutes until the next best price period starts. During an active period, shows time until the period AFTER the current one. Returns 0 during brief transition moments. Updates every minute.",
-            "usage_tips": "Perfect for 'wait until cheap period' automations: 'If next_in_minutes > 0 AND next_in_minutes < 15, wait before starting dishwasher'. Value > 0 always indicates a future period is scheduled."
+            "description": "Time until next best price period starts",
+            "long_description": "Shows how long until the next best price period starts. The state displays in hours (e.g., 2.25 h) for dashboards, while the `next_in_minutes` attribute provides minutes (e.g., 135) for automation conditions. During an active period, shows time until the period AFTER the current one. Returns 0 during brief transition moments. Updates every minute.",
+            "usage_tips": "For automations: Use `next_in_minutes` attribute like 'If next_in_minutes > 0 AND next_in_minutes < 15, wait before starting dishwasher'. Value > 0 always indicates a future period is scheduled."
         },
         "peak_price_end_time": {
             "description": "When the current or next peak price period ends",
@@ -350,14 +352,14 @@
             "usage_tips": "Use this to display 'Expensive period ends in 1 hour' (when active) or 'Next expensive period ends at 18:00' (when inactive). Combine with automations to resume operations after peak."
         },
         "peak_price_period_duration": {
-            "description": "Total length of current or next peak price period in minutes",
-            "long_description": "Shows how long the peak price period lasts in total. During an active period, shows the duration of the current period. When no period is active, shows the duration of the next upcoming period. Returns 'Unknown' only when no periods are configured.",
-            "usage_tips": "Useful for planning: 'The next expensive period lasts 60 minutes' or 'Current peak is 90 minutes long'. Combine with remaining_minutes to decide whether to wait out the peak or proceed with operations."
+            "description": "Total length of current or next peak price period",
+            "long_description": "Shows how long the peak price period lasts in total. The state is displayed in hours (e.g., 0.75 h) for easy reading in the UI, while the `period_duration_minutes` attribute provides the same value in minutes (e.g., 45) for use in automations. During an active period, shows the duration of the current period. When no period is active, shows the duration of the next upcoming period. Returns 'Unknown' only when no periods are configured.",
+            "usage_tips": "For display: Use the state value (hours) in dashboards. For automations: Use `period_duration_minutes` attribute to decide whether to wait out the peak or proceed (e.g., 'If period_duration_minutes <= 60, pause operations')."
         },
         "peak_price_remaining_minutes": {
-            "description": "Minutes remaining in current peak price period (0 when inactive)",
-            "long_description": "Shows how many minutes are left in the current peak price period. Returns 0 when no period is active. Updates every minute. Check binary_sensor.peak_price_period to see if a period is currently active.",
-            "usage_tips": "Use in automations: 'If remaining_minutes > 60, cancel deferred charging session'. Value 0 makes it easy to distinguish active (value > 0) from inactive (value = 0) periods."
+            "description": "Time remaining in current peak price period",
+            "long_description": "Shows how much time is left in the current peak price period. The state displays in hours (e.g., 1.0 h) for easy reading, while the `remaining_minutes` attribute provides minutes (e.g., 60) for automation logic. Returns 0 when no period is active. Updates every minute. Check binary_sensor.peak_price_period to see if a period is currently active.",
+            "usage_tips": "For automations: Use `remaining_minutes` attribute like 'If remaining_minutes > 60, cancel deferred charging session'. Value 0 makes it easy to distinguish active (value > 0) from inactive (value = 0) periods."
         },
         "peak_price_progress": {
             "description": "Progress through current peak price period (0% when inactive)",
@@ -370,9 +372,9 @@
             "usage_tips": "Always useful for planning: 'Next expensive period starts in 2 hours'. Automation: 'When next start time is in 30 minutes, reduce heating temperature preemptively'."
         },
         "peak_price_next_in_minutes": {
-            "description": "Minutes until next peak price period starts (0 when in transition)",
-            "long_description": "Shows minutes until the next peak price period starts. During an active period, shows time until the period AFTER the current one. Returns 0 during brief transition moments. Updates every minute.",
-            "usage_tips": "Pre-emptive automation: 'If next_in_minutes > 0 AND next_in_minutes < 10, complete current charging cycle now before prices increase'."
+            "description": "Time until next peak price period starts",
+            "long_description": "Shows how long until the next peak price period starts. The state displays in hours (e.g., 0.5 h) for dashboards, while the `next_in_minutes` attribute provides minutes (e.g., 30) for automation conditions. During an active period, shows time until the period AFTER the current one. Returns 0 during brief transition moments. Updates every minute.",
+            "usage_tips": "For automations: Use `next_in_minutes` attribute like 'If next_in_minutes > 0 AND next_in_minutes < 10, complete current charging cycle now before prices increase'."
         },
         "home_type": {
             "description": "Type of home (apartment, house, etc.)",
@@ -487,6 +489,80 @@
             "usage_tips": "Use this to verify that realtime consumption data is available. Enable notifications if this changes to 'off' unexpectedly, indicating potential hardware or connectivity issues."
         }
     },
+    "number": {
+        "best_price_flex_override": {
+            "description": "Maximum above the daily minimum price that intervals can be and still qualify as 'best price'. Recommended: 15-20 with relaxation enabled (default), or 25-35 without relaxation. Maximum: 50 (hard cap for reliable period detection).",
+            "long_description": "When this entity is enabled, its value overrides the 'Flexibility' setting from the options flow for best price period calculations.",
+            "usage_tips": "Enable this entity to dynamically adjust best price detection via automations. Higher values create longer periods, lower values are stricter."
+        },
+        "best_price_min_distance_override": {
+            "description": "Ensures periods are significantly cheaper than the daily average, not just marginally below it. This filters out noise and prevents marking slightly-below-average periods as 'best price' on days with flat prices. Higher values = stricter filtering (only truly cheap periods qualify).",
+            "long_description": "When this entity is enabled, its value overrides the 'Minimum Distance' setting from the options flow for best price period calculations.",
+            "usage_tips": "Use in automations to adjust how much better than average the best price periods must be. Higher values require prices to be further below average."
+        },
+        "best_price_min_period_length_override": {
+            "description": "Minimum duration for a period to be considered as 'best price'. Longer periods are more practical for running appliances like dishwashers or heat pumps. Best price periods require 60 minutes minimum (vs. 30 minutes for peak price warnings) because they should provide meaningful time windows for consumption planning.",
+            "long_description": "When this entity is enabled, its value overrides the 'Minimum Period Length' setting from the options flow for best price period calculations.",
+            "usage_tips": "Increase when your appliances need longer uninterrupted run times (e.g., washing machines, dishwashers)."
+        },
+        "best_price_min_periods_override": {
+            "description": "Minimum number of best price periods to aim for per day. Filters will be relaxed step-by-step to try achieving this count. Only active when 'Achieve Minimum Count' is enabled.",
+            "long_description": "When this entity is enabled, its value overrides the 'Minimum Periods' setting from the options flow for best price period calculations.",
+            "usage_tips": "Adjust dynamically based on how many times per day you need cheap electricity windows."
+        },
+        "best_price_relaxation_attempts_override": {
+            "description": "How many flex levels (attempts) to try before giving up. Each attempt runs all filter combinations at the new flex level. More attempts increase the chance of finding additional periods at the cost of longer processing time.",
+            "long_description": "When this entity is enabled, its value overrides the 'Relaxation Attempts' setting from the options flow for best price period calculations.",
+            "usage_tips": "Increase when periods are hard to find. Decrease for stricter price filtering."
+        },
+        "best_price_gap_count_override": {
+            "description": "Maximum number of consecutive intervals allowed that deviate by exactly one level step from the required level. This prevents periods from being split by occasional level deviations. Gap tolerance requires periods ≥90 minutes (6 intervals) to detect outliers effectively.",
+            "long_description": "When this entity is enabled, its value overrides the 'Gap Tolerance' setting from the options flow for best price period calculations.",
+            "usage_tips": "Increase to allow longer periods with occasional price spikes. Keep low for stricter continuous cheap periods."
+        },
+        "peak_price_flex_override": {
+            "description": "Maximum below the daily maximum price that intervals can be and still qualify as 'peak price'. Recommended: -15 to -20 with relaxation enabled (default), or -25 to -35 without relaxation. Maximum: -50 (hard cap for reliable period detection). Note: Negative values indicate distance below maximum.",
+            "long_description": "When this entity is enabled, its value overrides the 'Flexibility' setting from the options flow for peak price period calculations.",
+            "usage_tips": "Enable this entity to dynamically adjust peak price detection via automations. Higher values create longer peak periods."
+        },
+        "peak_price_min_distance_override": {
+            "description": "Ensures periods are significantly more expensive than the daily average, not just marginally above it. This filters out noise and prevents marking slightly-above-average periods as 'peak price' on days with flat prices. Higher values = stricter filtering (only truly expensive periods qualify).",
+            "long_description": "When this entity is enabled, its value overrides the 'Minimum Distance' setting from the options flow for peak price period calculations.",
+            "usage_tips": "Use in automations to adjust how much higher than average the peak price periods must be."
+        },
+        "peak_price_min_period_length_override": {
+            "description": "Minimum duration for a period to be considered as 'peak price'. Peak price warnings are allowed for shorter periods (30 minutes minimum vs. 60 minutes for best price) because brief expensive spikes are worth alerting about, even if they're too short for consumption planning.",
+            "long_description": "When this entity is enabled, its value overrides the 'Minimum Period Length' setting from the options flow for peak price period calculations.",
+            "usage_tips": "Increase to filter out brief price spikes, focusing on sustained expensive periods."
+        },
+        "peak_price_min_periods_override": {
+            "description": "Minimum number of peak price periods to aim for per day. Filters will be relaxed step-by-step to try achieving this count. Only active when 'Achieve Minimum Count' is enabled.",
+            "long_description": "When this entity is enabled, its value overrides the 'Minimum Periods' setting from the options flow for peak price period calculations.",
+            "usage_tips": "Adjust based on how many peak periods you want to identify and avoid."
+        },
+        "peak_price_relaxation_attempts_override": {
+            "description": "How many flex levels (attempts) to try before giving up. Each attempt runs all filter combinations at the new flex level. More attempts increase the chance of finding additional peak periods at the cost of longer processing time.",
+            "long_description": "When this entity is enabled, its value overrides the 'Relaxation Attempts' setting from the options flow for peak price period calculations.",
+            "usage_tips": "Increase when peak periods are hard to detect. Decrease for stricter peak price filtering."
+        },
+        "peak_price_gap_count_override": {
+            "description": "Maximum number of consecutive intervals allowed that deviate by exactly one level step from the required level. This prevents periods from being split by occasional level deviations. Gap tolerance requires periods ≥90 minutes (6 intervals) to detect outliers effectively.",
+            "long_description": "When this entity is enabled, its value overrides the 'Gap Tolerance' setting from the options flow for peak price period calculations.",
+            "usage_tips": "Increase to identify sustained expensive periods with brief dips. Keep low for stricter continuous peak detection."
+        }
+    },
+    "switch": {
+        "best_price_enable_relaxation_override": {
+            "description": "When enabled, filters will be gradually relaxed if not enough periods are found. This attempts to reach the desired minimum number of periods, which may include less optimal time windows as best-price periods.",
+            "long_description": "When this entity is enabled, its value overrides the 'Achieve Minimum Count' setting from the options flow for best price period calculations.",
+            "usage_tips": "Turn OFF to disable relaxation and use strict filtering only. Turn ON to allow the algorithm to relax criteria to find more periods."
+        },
+        "peak_price_enable_relaxation_override": {
+            "description": "When enabled, filters will be gradually relaxed if not enough periods are found. This attempts to reach the desired minimum number of periods to ensure you're warned about expensive periods even on days with unusual price patterns.",
+            "long_description": "When this entity is enabled, its value overrides the 'Achieve Minimum Count' setting from the options flow for peak price period calculations.",
+            "usage_tips": "Turn OFF to disable relaxation and use strict filtering only. Turn ON to allow the algorithm to relax criteria to find more peak periods."
+        }
+    },
     "home_types": {
         "APARTMENT": "Apartment",
         "ROWHOUSE": "Rowhouse",

custom_components/tibber_prices/custom_translations/nb.json

@@ -2,7 +2,9 @@
     "apexcharts": {
         "title_rating_level": "Prisfaser dagsfremdrift",
         "title_level": "Prisnivå",
+        "hourly_suffix": "(Ø per time)",
         "best_price_period_name": "Beste prisperiode",
+        "peak_price_period_name": "Toppprisperiode",
         "notification": {
             "metadata_sensor_unavailable": {
                 "title": "Tibber Prices: ApexCharts YAML generert med begrenset funksjonalitet",
@@ -56,9 +58,9 @@
             "usage_tips": "Bruk dette til å unngå å kjøre apparater i toppristider"
         },
         "average_price_today": {
-            "description": "Den gjennomsnittlige elektrisitetsprisen i dag per kWh",
-            "long_description": "Viser gjennomsnittsprisen per kWh for gjeldende dag fra ditt Tibber-abonnement",
-            "usage_tips": "Bruk dette som en baseline for å sammenligne nåværende priser"
+            "description": "Typisk elektrisitetspris i dag per kWh (konfigurerbart visningsformat)",
+            "long_description": "Viser prisen per kWh for gjeldende dag fra ditt Tibber-abonnement. **Som standard viser statusen medianen** (motstandsdyktig mot ekstreme prisspiss, viser typisk prisnivå). Du kan endre dette i integrasjonsinnstillingene for å vise det aritmetiske gjennomsnittet i stedet. Den alternative verdien er tilgjengelig som attributt.",
+            "usage_tips": "Bruk dette som baseline for å sammenligne nåværende priser. For beregninger bruk: {{ state_attr('sensor.average_price_today', 'price_mean') }}"
         },
         "lowest_price_tomorrow": {
             "description": "Den laveste elektrisitetsprisen i morgen per kWh",
@@ -71,9 +73,9 @@
             "usage_tips": "Bruk dette til å unngå å kjøre apparater i morgendagens toppristider. Nyttig for å planlegge rundt dyre perioder."
         },
         "average_price_tomorrow": {
-            "description": "Den gjennomsnittlige elektrisitetsprisen i morgen per kWh",
-            "long_description": "Viser gjennomsnittsprisen per kWh for morgendagen fra ditt Tibber-abonnement. Denne sensoren blir utilgjengelig inntil morgendagens data er publisert av Tibber (vanligvis rundt 13:00-14:00 CET).",
-            "usage_tips": "Bruk dette som en baseline for å sammenligne morgendagens priser og planlegge forbruk. Sammenlign med dagens gjennomsnitt for å se om morgendagen vil være mer eller mindre dyr totalt sett."
+            "description": "Typisk elektrisitetspris i morgen per kWh (konfigurerbart visningsformat)",
+            "long_description": "Viser prisen per kWh for morgendagen fra ditt Tibber-abonnement. **Som standard viser statusen medianen** (motstandsdyktig mot ekstreme prisspiss). Du kan endre dette i integrasjonsinnstillingene for å vise det aritmetiske gjennomsnittet i stedet. Den alternative verdien er tilgjengelig som attributt. Denne sensoren blir utilgjengelig inntil morgendagens data er publisert av Tibber (vanligvis rundt 13:00-14:00 CET).",
+            "usage_tips": "Bruk dette som baseline for å sammenligne morgendagens priser og planlegge forbruk. Sammenlign med dagens median for å se om morgendagen vil være mer eller mindre dyr totalt sett."
         },
         "yesterday_price_level": {
             "description": "Aggregert prisnivå for i går",
@@ -106,14 +108,14 @@
             "usage_tips": "Bruk dette for å planlegge morgendagens energiforbruk basert på dine personlige pristerskelverdier. Sammenlign med i dag for å bestemme om du skal flytte forbruk til i morgen eller bruke energi i dag."
         },
         "trailing_price_average": {
-            "description": "Den gjennomsnittlige elektrisitetsprisen for de siste 24 timene per kWh",
-            "long_description": "Viser gjennomsnittsprisen per kWh beregnet fra de siste 24 timene (glidende gjennomsnitt) fra ditt Tibber-abonnement. Dette gir et rullende gjennomsnitt som oppdateres hvert 15. minutt basert på historiske data.",
-            "usage_tips": "Bruk dette til å sammenligne nåværende priser mot nylige trender. En nåværende pris betydelig over dette gjennomsnittet kan indikere et godt tidspunkt å redusere forbruket."
+            "description": "Typisk elektrisitetspris for de siste 24 timene per kWh (konfigurerbart visningsformat)",
+            "long_description": "Viser prisen per kWh beregnet fra de siste 24 timene. **Som standard viser statusen medianen** (motstandsdyktig mot ekstreme prisspiss, viser typisk prisnivå). Du kan endre dette i integrasjonsinnstillingene for å vise det aritmetiske gjennomsnittet i stedet. Den alternative verdien er tilgjengelig som attributt. Oppdateres hvert 15. minutt.",
+            "usage_tips": "Bruk statusverdien for å se det typiske nåværende prisnivået. For kostnadsberegninger bruk: {{ state_attr('sensor.trailing_price_average', 'price_mean') }}"
         },
         "leading_price_average": {
-            "description": "Den gjennomsnittlige elektrisitetsprisen for de neste 24 timene per kWh",
-            "long_description": "Viser gjennomsnittsprisen per kWh beregnet fra de neste 24 timene (fremtidsrettet gjennomsnitt) fra ditt Tibber-abonnement. Dette gir et fremtidsrettet gjennomsnitt basert på tilgjengelige prognosedata.",
-            "usage_tips": "Bruk dette til å planlegge energibruk. Hvis nåværende pris er under det fremtidsrettede gjennomsnittet, kan det være et godt tidspunkt å kjøre energikrevende apparater."
+            "description": "Typisk elektrisitetspris for de neste 24 timene per kWh (konfigurerbart visningsformat)",
+            "long_description": "Viser prisen per kWh beregnet fra de neste 24 timene. **Som standard viser statusen medianen** (motstandsdyktig mot ekstreme prisspiss, viser forventet prisnivå). Du kan endre dette i integrasjonsinnstillingene for å vise det aritmetiske gjennomsnittet i stedet. Den alternative verdien er tilgjengelig som attributt.",
+            "usage_tips": "Bruk statusverdien for å se det typiske kommende prisnivået. For kostnadsberegninger bruk: {{ state_attr('sensor.leading_price_average', 'price_mean') }}"
         },
         "trailing_price_min": {
             "description": "Den minste elektrisitetsprisen for de siste 24 timene per kWh",
@@ -290,24 +292,24 @@
             "long_description": "Viser tidsstempelet for siste tilgjengelige prisdataintervall fra ditt Tibber-abonnement"
         },
         "today_volatility": {
-            "description": "Prisvolatilitetsklassifisering for i dag",
-            "long_description": "Viser hvor mye strømprisene varierer gjennom dagen basert på spredningen (forskjellen mellom høyeste og laveste pris). Klassifisering: lav = spredning < 5øre, moderat = 5-15øre, høy = 15-30øre, veldig høy = >30øre.",
-            "usage_tips": "Bruk dette til å bestemme om prisbasert optimalisering er verdt det. For eksempel, med et balkongbatteri som har 15% effektivitetstap, er optimalisering kun meningsfull når volatiliteten er minst moderat. Opprett automatiseringer som sjekker volatilitet før planlegging av lade-/utladingssykluser."
+            "description": "Hvor mye strømprisene endrer seg i dag",
+            "long_description": "Viser om dagens priser er stabile eller har store svingninger. Lav volatilitet betyr ganske jevne priser – timing betyr lite. Høy volatilitet betyr tydelige prisforskjeller gjennom dagen – en god sjanse til å flytte forbruk til billigere perioder. `price_coefficient_variation_%` viser prosentverdien, `price_spread` viser den absolutte prisspennet.",
+            "usage_tips": "Bruk dette for å avgjøre om optimalisering er verdt innsatsen. Ved lav volatilitet kan du kjøre enheter når som helst. Ved høy volatilitet sparer du merkbart ved å følge Best Price-perioder."
         },
         "tomorrow_volatility": {
-            "description": "Prisvolatilitetsklassifisering for i morgen",
-            "long_description": "Viser hvor mye strømprisene vil variere gjennom morgendagen basert på spredningen (forskjellen mellom høyeste og laveste pris). Blir utilgjengelig til morgendagens data er publisert (typisk 13:00-14:00 CET).",
-            "usage_tips": "Bruk dette til forhåndsplanlegging av morgendagens energiforbruk. Hvis morgendagen har høy eller veldig høy volatilitet, er det verdt å optimalisere tidspunktet for energiforbruk. Hvis lav, kan du kjøre enheter når som helst uten betydelige kostnadsforskjeller."
+            "description": "Hvor mye strømprisene vil endre seg i morgen",
+            "long_description": "Viser om prisene i morgen blir stabile eller får store svingninger. Tilgjengelig når morgendagens data er publisert (vanligvis 13:00–14:00 CET). Lav volatilitet betyr jevne priser – timing er ikke kritisk. Høy volatilitet betyr tydelige prisforskjeller gjennom dagen – en god mulighet til å planlegge energikrevende oppgaver. `price_coefficient_variation_%` viser prosentverdien, `price_spread` viser den absolutte prisspennet.",
+            "usage_tips": "Bruk dette til å planlegge morgendagens forbruk. Høy volatilitet? Planlegg fleksible laster i Best Price-perioder. Lav volatilitet? Kjør enheter når det passer deg."
         },
         "next_24h_volatility": {
-            "description": "Prisvolatilitetsklassifisering for de rullerende neste 24 timene",
-            "long_description": "Viser hvor mye strømprisene varierer i de neste 24 timene fra nå (rullerende vindu). Dette krysser daggrenser og oppdateres hvert 15. minutt, og gir en fremoverskuende volatilitetsvurdering uavhengig av kalenderdager.",
-            "usage_tips": "Beste sensor for sanntids optimaliseringsbeslutninger. I motsetning til dagens/morgendagens sensorer som bytter ved midnatt, gir denne kontinuerlig 24t volatilitetsvurdering. Bruk til batteriladingsstrategier som spenner over daggrenser."
+            "description": "Hvor mye prisene endrer seg de neste 24 timene",
+            "long_description": "Viser prisvolatilitet for et rullerende 24-timers vindu fra nå (oppdateres hvert 15. minutt). Lav volatilitet betyr jevne priser. Høy volatilitet betyr merkbare prissvingninger og mulighet for optimalisering. I motsetning til i dag/i morgen-sensorer krysser denne daggrenser og gir en kontinuerlig fremoverskuende vurdering. `price_coefficient_variation_%` viser prosentverdien, `price_spread` viser den absolutte prisspennet.",
+            "usage_tips": "Best for beslutninger i sanntid. Bruk når du planlegger batterilading eller andre fleksible laster som kan gå over midnatt. Gir et konsistent 24t-bilde uavhengig av kalenderdag."
         },
         "today_tomorrow_volatility": {
-            "description": "Kombinert prisvolatilitetsklassifisering for i dag og i morgen",
-            "long_description": "Viser volatilitet på tvers av både i dag og i morgen kombinert (når morgendagens data er tilgjengelig). Gir en utvidet visning av prisvariasjoner som spenner over opptil 48 timer. Faller tilbake til bare i dag når morgendagens data ikke er tilgjengelig ennå.",
-            "usage_tips": "Bruk dette for flersdagers planlegging og for å forstå om prismuligheter eksisterer på tvers av dags grensen. Attributtene 'today_volatility' og 'tomorrow_volatility' viser individuelle dagbidrag. Nyttig for planlegging av ladeøkter som kan strekke seg over midnatt."
+            "description": "Kombinert prisvolatilitet for i dag og i morgen",
+            "long_description": "Viser samlet volatilitet når i dag og i morgen sees sammen (når morgendata er tilgjengelig). Viser om det finnes klare prisforskjeller over dagsgrensen. Faller tilbake til kun i dag hvis morgendata mangler. Nyttig for flerdagers optimalisering. `price_coefficient_variation_%` viser prosentverdien, `price_spread` viser den absolutte prisspennet.",
+            "usage_tips": "Bruk for oppgaver som går over flere dager. Sjekk om prisforskjellene er store nok til å planlegge etter. De enkelte dagssensorene viser bidrag per dag om du trenger mer detalj."
         },
         "data_lifecycle_status": {
             "description": "Gjeldende tilstand for prisdatalivssyklus og hurtigbufring",
@@ -315,39 +317,49 @@
             "usage_tips": "Bruk denne diagnosesensoren for å forstå dataferskhet og API-anropsmønstre. Sjekk 'cache_age'-attributtet for å se hvor gamle de nåværende dataene er. Overvåk 'next_api_poll' for å vite når neste oppdatering er planlagt. Bruk 'data_completeness' for å se om data for i går/i dag/i morgen er tilgjengelig. 'api_calls_today'-telleren hjelper med å spore API-bruk. Perfekt for feilsøking eller forståelse av integrasjonens oppførsel."
         },
         "best_price_end_time": {
-            "description": "Når gjeldende eller neste billigperiode slutter",
-            "long_description": "Viser sluttidspunktet for gjeldende billigperiode når aktiv, eller slutten av neste periode når ingen periode er aktiv. Viser alltid en nyttig tidsreferanse for planlegging. Returnerer 'Ukjent' bare når ingen perioder er konfigurert.",
-            "usage_tips": "Bruk dette til å vise en nedtelling som 'Billigperiode slutter om 2 timer' (når aktiv) eller 'Neste billigperiode slutter kl 14:00' (når inaktiv). Home Assistant viser automatisk relativ tid for tidsstempelsensorer."
+            "description": "Total lengde på nåværende eller neste billigperiode (state i timer, attributt i minutter)",
+            "long_description": "Viser hvor lenge billigperioden varer. State bruker timer (desimal) for lesbar UI; attributtet `period_duration_minutes` beholder avrundede minutter for automasjoner. Aktiv → varighet for gjeldende periode, ellers neste.",
+            "usage_tips": "UI kan vise 1,5 t mens `period_duration_minutes` = 90 for automasjoner."
+        },
+        "best_price_period_duration": {
+            "description": "Lengde på gjeldende/neste billigperiode",
+            "long_description": "Total varighet av gjeldende eller neste billigperiode. State vises i timer (f.eks. 1,5 t) for enkel lesing i UI, mens attributtet `period_duration_minutes` gir samme verdi i minutter (f.eks. 90) for automasjoner. Denne verdien representerer den **fulle planlagte varigheten** av perioden og er konstant gjennom hele perioden, selv om gjenværende tid (remaining_minutes) reduseres.",
+            "usage_tips": "Kombiner med remaining_minutes for å beregne når langvarige enheter skal stoppes: Perioden startet for `period_duration_minutes - remaining_minutes` minutter siden. Dette attributtet støtter energioptimeringsstrategier ved å hjelpe til med å planlegge høyforbruksaktiviteter innenfor billige perioder."
         },
         "best_price_remaining_minutes": {
-            "description": "Gjenværende minutter i gjeldende billigperiode (0 når inaktiv)",
-            "long_description": "Viser hvor mange minutter som er igjen i gjeldende billigperiode. Returnerer 0 når ingen periode er aktiv. Oppdateres hvert minutt. Sjekk binary_sensor.best_price_period for å se om en periode er aktiv.",
-            "usage_tips": "Perfekt for automatiseringer: 'Hvis remaining_minutes > 0 OG remaining_minutes < 30, start vaskemaskin nå'. Verdien 0 gjør det enkelt å sjekke om en periode er aktiv (verdi > 0) eller ikke (verdi = 0)."
+            "description": "Gjenværende tid i gjeldende billigperiode",
+            "long_description": "Viser hvor mye tid som gjenstår i gjeldende billigperiode. State vises i timer (f.eks. 0,75 t) for enkel lesing i dashboards, mens attributtet `remaining_minutes` gir samme tid i minutter (f.eks. 45) for automasjonsbetingelser. **Nedtellingstimer**: Denne verdien reduseres hvert minutt under en aktiv periode. Returnerer 0 når ingen billigperiode er aktiv. Oppdateres hvert minutt.",
+            "usage_tips": "For automasjoner: Bruk attributtet `remaining_minutes` som 'Hvis remaining_minutes > 60, start oppvaskmaskinen nå (nok tid til å fullføre)' eller 'Hvis remaining_minutes < 15, fullfør gjeldende syklus snart'. UI viser brukervennlige timer (f.eks. 1,25 t). Verdi 0 indikerer ingen aktiv billigperiode."
         },
         "best_price_progress": {
             "description": "Fremdrift gjennom gjeldende billigperiode (0% når inaktiv)",
-            "long_description": "Viser fremdrift gjennom gjeldende billigperiode som 0-100%. Returnerer 0% når ingen periode er aktiv. Oppdateres hvert minutt. 0% betyr periode nettopp startet, 100% betyr den snart slutter.",
-            "usage_tips": "Flott for visuelle fremdriftslinjer. Bruk i automatiseringer: 'Hvis progress > 0 OG progress > 75, send varsel om at billigperiode snart slutter'. Verdi 0 indikerer ingen aktiv periode."
+            "long_description": "Viser fremdrift gjennom gjeldende billigperiode som 0-100%. Returnerer 0% når ingen periode er aktiv. Oppdateres hvert minutt. 0% betyr perioden nettopp startet, 100% betyr den slutter snart.",
+            "usage_tips": "Flott for visuelle fremgangsindikatorer. Bruk i automatiseringer: 'Hvis progress > 0 OG progress > 75, send varsel om at billigperioden snart slutter'. Verdi 0 indikerer ingen aktiv periode."
         },
         "best_price_next_start_time": {
-            "description": "Når neste billigperiode starter",
-            "long_description": "Viser når neste kommende billigperiode starter. Under en aktiv periode viser dette starten av NESTE periode etter den gjeldende. Returnerer 'Ukjent' bare når ingen fremtidige perioder er konfigurert.",
-            "usage_tips": "Alltid nyttig for planlegging: 'Neste billigperiode starter om 3 timer' (enten du er i en periode nå eller ikke). Kombiner med automatiseringer: 'Når neste starttid er om 10 minutter, send varsel for å forberede vaskemaskin'."
+            "description": "Total lengde på nåværende eller neste dyr-periode (state i timer, attributt i minutter)",
+            "long_description": "Viser hvor lenge den dyre perioden varer. State bruker timer (desimal) for UI; attributtet `period_duration_minutes` beholder avrundede minutter for automasjoner. Aktiv → varighet for gjeldende periode, ellers neste.",
+            "usage_tips": "UI kan vise 0,75 t mens `period_duration_minutes` = 45 for automasjoner."
         },
         "best_price_next_in_minutes": {
-            "description": "Minutter til neste billigperiode starter (0 ved overgang)",
-            "long_description": "Viser minutter til neste billigperiode starter. Under en aktiv periode viser dette tiden til perioden ETTER den gjeldende. Returnerer 0 under korte overgangsmomenter. Oppdateres hvert minutt.",
-            "usage_tips": "Perfekt for 'vent til billigperiode' automatiseringer: 'Hvis next_in_minutes > 0 OG next_in_minutes < 15, vent før oppvaskmaskin startes'. Verdi > 0 indikerer alltid at en fremtidig periode er planlagt."
+            "description": "Tid til neste billigperiode",
+            "long_description": "Viser hvor lenge til neste billigperiode. State vises i timer (f.eks. 2,25 t) for dashboards, mens attributtet `next_in_minutes` gir minutter (f.eks. 135) for automasjonsbetingelser. Under en aktiv periode viser dette tiden til perioden ETTER den gjeldende. Returnerer 0 under korte overgangsmomenter. Oppdateres hvert minutt.",
+            "usage_tips": "For automasjoner: Bruk attributtet `next_in_minutes` som 'Hvis next_in_minutes > 0 OG next_in_minutes < 15, vent før start av oppvaskmaskin'. Verdi > 0 indikerer alltid at en fremtidig periode er planlagt."
         },
         "peak_price_end_time": {
-            "description": "Når gjeldende eller neste dyrperiode slutter",
-            "long_description": "Viser sluttidspunktet for gjeldende dyrperiode når aktiv, eller slutten av neste periode når ingen periode er aktiv. Viser alltid en nyttig tidsreferanse for planlegging. Returnerer 'Ukjent' bare når ingen perioder er konfigurert.",
-            "usage_tips": "Bruk dette til å vise 'Dyrperiode slutter om 1 time' (når aktiv) eller 'Neste dyrperiode slutter kl 18:00' (når inaktiv). Kombiner med automatiseringer for å gjenoppta drift etter topp."
+            "description": "Tid til neste dyr-periode (state i timer, attributt i minutter)",
+            "long_description": "Viser hvor lenge til neste dyre periode starter. State bruker timer (desimal); attributtet `next_in_minutes` beholder avrundede minutter for automasjoner. Under aktiv periode viser dette tiden til perioden etter den nåværende. 0 i korte overgangsøyeblikk. Oppdateres hvert minutt.",
+            "usage_tips": "Bruk `next_in_minutes` i automasjoner (f.eks. < 10) mens state er lett å lese i timer."
+        },
+        "peak_price_period_duration": {
+            "description": "Lengde på gjeldende/neste dyr periode",
+            "long_description": "Total varighet av gjeldende eller neste dyre periode. State vises i timer (f.eks. 1,5 t) for enkel lesing i UI, mens attributtet `period_duration_minutes` gir samme verdi i minutter (f.eks. 90) for automasjoner. Denne verdien representerer den **fulle planlagte varigheten** av perioden og er konstant gjennom hele perioden, selv om gjenværende tid (remaining_minutes) reduseres.",
+            "usage_tips": "Kombiner med remaining_minutes for å beregne når langvarige enheter skal stoppes: Perioden startet for `period_duration_minutes - remaining_minutes` minutter siden. Dette attributtet støtter energisparingsstrategier ved å hjelpe til med å planlegge høyforbruksaktiviteter utenfor dyre perioder."
         },
         "peak_price_remaining_minutes": {
-            "description": "Gjenværende minutter i gjeldende dyrperiode (0 når inaktiv)",
-            "long_description": "Viser hvor mange minutter som er igjen i gjeldende dyrperiode. Returnerer 0 når ingen periode er aktiv. Oppdateres hvert minutt. Sjekk binary_sensor.peak_price_period for å se om en periode er aktiv.",
-            "usage_tips": "Bruk i automatiseringer: 'Hvis remaining_minutes > 60, avbryt utsatt ladeøkt'. Verdi 0 gjør det enkelt å skille mellom aktive (verdi > 0) og inaktive (verdi = 0) perioder."
+            "description": "Gjenværende tid i gjeldende dyre periode",
+            "long_description": "Viser hvor mye tid som gjenstår i gjeldende dyre periode. State vises i timer (f.eks. 0,75 t) for enkel lesing i dashboards, mens attributtet `remaining_minutes` gir samme tid i minutter (f.eks. 45) for automasjonsbetingelser. **Nedtellingstimer**: Denne verdien reduseres hvert minutt under en aktiv periode. Returnerer 0 når ingen dyr periode er aktiv. Oppdateres hvert minutt.",
+            "usage_tips": "For automasjoner: Bruk attributtet `remaining_minutes` som 'Hvis remaining_minutes > 60, avbryt utsatt ladeøkt' eller 'Hvis remaining_minutes < 15, fortsett normal drift snart'. UI viser brukervennlige timer (f.eks. 1,0 t). Verdi 0 indikerer ingen aktiv dyr periode."
         },
         "peak_price_progress": {
             "description": "Fremdrift gjennom gjeldende dyrperiode (0% når inaktiv)",
@@ -360,19 +372,9 @@
             "usage_tips": "Alltid nyttig for planlegging: 'Neste dyrperiode starter om 2 timer'. Automatisering: 'Når neste starttid er om 30 minutter, reduser varmetemperatur forebyggende'."
         },
         "peak_price_next_in_minutes": {
-            "description": "Minutter til neste dyrperiode starter (0 ved overgang)",
-            "long_description": "Viser minutter til neste dyrperiode starter. Under en aktiv periode viser dette tiden til perioden ETTER den gjeldende. Returnerer 0 under korte overgangsmomenter. Oppdateres hvert minutt.",
-            "usage_tips": "Forebyggende automatisering: 'Hvis next_in_minutes > 0 OG next_in_minutes < 10, fullfør gjeldende ladesyklus nå før prisene øker'."
-        },
-        "best_price_period_duration": {
-            "description": "Total varighet av gjeldende eller neste billigperiode i minutter",
-            "long_description": "Viser den totale varigheten av billigperioden i minutter. Under en aktiv periode viser dette hele varigheten av gjeldende periode. Når ingen periode er aktiv, viser dette varigheten av neste kommende periode. Eksempel: '90 minutter' for en 1,5-timers periode.",
-            "usage_tips": "Kombiner med remaining_minutes for å planlegge oppgaver: 'Hvis duration = 120 OG remaining_minutes > 90, start vaskemaskin (nok tid til å fullføre)'. Nyttig for å forstå om perioder er lange nok for strømkrevende oppgaver."
-        },
-        "peak_price_period_duration": {
-            "description": "Total varighet av gjeldende eller neste dyrperiode i minutter",
-            "long_description": "Viser den totale varigheten av dyrperioden i minutter. Under en aktiv periode viser dette hele varigheten av gjeldende periode. Når ingen periode er aktiv, viser dette varigheten av neste kommende periode. Eksempel: '60 minutter' for en 1-times periode.",
-            "usage_tips": "Bruk til å planlegge energibesparelsestiltak: 'Hvis duration > 120, reduser varmetemperatur mer aggressivt (lang dyr periode)'. Hjelper med å vurdere hvor mye energiforbruk må reduseres."
+            "description": "Tid til neste dyre periode",
+            "long_description": "Viser hvor lenge til neste dyre periode starter. State vises i timer (f.eks. 0,5 t) for dashboards, mens attributtet `next_in_minutes` gir minutter (f.eks. 30) for automasjonsbetingelser. Under en aktiv periode viser dette tiden til perioden ETTER den gjeldende. Returnerer 0 under korte overgangsmomenter. Oppdateres hvert minutt.",
+            "usage_tips": "For automasjoner: Bruk attributtet `next_in_minutes` som 'Hvis next_in_minutes > 0 OG next_in_minutes < 10, fullfør gjeldende ladesyklus nå før prisene øker'. Verdi > 0 indikerer alltid at en fremtidig dyr periode er planlagt."
         },
         "home_type": {
             "description": "Type bolig (leilighet, hus osv.)",
@@ -487,6 +489,80 @@
             "usage_tips": "Bruk dette for å bekrefte at sanntidsforbruksdata er tilgjengelig. Aktiver varsler hvis dette endres til 'av' uventet, noe som indikerer potensielle maskinvare- eller tilkoblingsproblemer."
         }
     },
+    "number": {
+        "best_price_flex_override": {
+            "description": "Maksimal prosent over daglig minimumspris som intervaller kan ha og fortsatt kvalifisere som 'beste pris'. Anbefalt: 15-20 med lemping aktivert (standard), eller 25-35 uten lemping. Maksimum: 50 (tak for pålitelig periodedeteksjon).",
+            "long_description": "Når denne entiteten er aktivert, overstyrer verdien 'Fleksibilitet'-innstillingen fra alternativer-dialogen for beste pris-periodeberegninger.",
+            "usage_tips": "Aktiver denne entiteten for å dynamisk justere beste pris-deteksjon via automatiseringer, f.eks. høyere fleksibilitet for kritiske laster eller strengere krav for fleksible apparater."
+        },
+        "best_price_min_distance_override": {
+            "description": "Minimum prosentavstand under daglig gjennomsnitt. Intervaller må være så langt under gjennomsnittet for å kvalifisere som 'beste pris'. Hjelper med å skille ekte lavprisperioder fra gjennomsnittspriser.",
+            "long_description": "Når denne entiteten er aktivert, overstyrer verdien 'Minimumsavstand'-innstillingen fra alternativer-dialogen for beste pris-periodeberegninger.",
+            "usage_tips": "Øk verdien for strengere beste pris-kriterier. Reduser hvis for få perioder blir oppdaget."
+        },
+        "best_price_min_period_length_override": {
+            "description": "Minimum periodelengde i 15-minutters intervaller. Perioder kortere enn dette blir ikke rapportert. Eksempel: 2 = minimum 30 minutter.",
+            "long_description": "Når denne entiteten er aktivert, overstyrer verdien 'Minimum periodelengde'-innstillingen fra alternativer-dialogen for beste pris-periodeberegninger.",
+            "usage_tips": "Juster til typisk apparatkjøretid: 2 (30 min) for hurtigprogrammer, 4-8 (1-2 timer) for normale sykluser, 8+ for lange ECO-programmer."
+        },
+        "best_price_min_periods_override": {
+            "description": "Minimum antall beste pris-perioder å finne daglig. Når lemping er aktivert, vil systemet automatisk justere kriterier for å oppnå dette antallet.",
+            "long_description": "Når denne entiteten er aktivert, overstyrer verdien 'Minimum perioder'-innstillingen fra alternativer-dialogen for beste pris-periodeberegninger.",
+            "usage_tips": "Sett dette til antall tidskritiske oppgaver du har daglig. Eksempel: 2 for to vaskemaskinkjøringer."
+        },
+        "best_price_relaxation_attempts_override": {
+            "description": "Antall forsøk på å gradvis lempe kriteriene for å oppnå minimum periodeantall. Hvert forsøk øker fleksibiliteten med 3 prosent. Ved 0 brukes kun basiskriterier.",
+            "long_description": "Når denne entiteten er aktivert, overstyrer verdien 'Lemping forsøk'-innstillingen fra alternativer-dialogen for beste pris-periodeberegninger.",
+            "usage_tips": "Høyere verdier gjør periodedeteksjon mer adaptiv for dager med stabile priser. Sett til 0 for å tvinge strenge kriterier uten lemping."
+        },
+        "best_price_gap_count_override": {
+            "description": "Maksimalt antall dyrere intervaller som kan tillates mellom billige intervaller mens de fortsatt regnes som en sammenhengende periode. Ved 0 må billige intervaller være påfølgende.",
+            "long_description": "Når denne entiteten er aktivert, overstyrer verdien 'Gaptoleranse'-innstillingen fra alternativer-dialogen for beste pris-periodeberegninger.",
+            "usage_tips": "Øk dette for apparater med variabel last (f.eks. varmepumper) som kan tåle korte dyrere intervaller. Sett til 0 for kontinuerlige billige perioder."
+        },
+        "peak_price_flex_override": {
+            "description": "Maksimal prosent under daglig maksimumspris som intervaller kan ha og fortsatt kvalifisere som 'topppris'. Samme anbefalinger som for beste pris-fleksibilitet.",
+            "long_description": "Når denne entiteten er aktivert, overstyrer verdien 'Fleksibilitet'-innstillingen fra alternativer-dialogen for topppris-periodeberegninger.",
+            "usage_tips": "Bruk dette for å justere topppris-terskelen ved kjøretid for automatiseringer som unngår forbruk under dyre timer."
+        },
+        "peak_price_min_distance_override": {
+            "description": "Minimum prosentavstand over daglig gjennomsnitt. Intervaller må være så langt over gjennomsnittet for å kvalifisere som 'topppris'.",
+            "long_description": "Når denne entiteten er aktivert, overstyrer verdien 'Minimumsavstand'-innstillingen fra alternativer-dialogen for topppris-periodeberegninger.",
+            "usage_tips": "Øk verdien for kun å fange ekstreme pristopper. Reduser for å inkludere flere høypristider."
+        },
+        "peak_price_min_period_length_override": {
+            "description": "Minimum periodelengde i 15-minutters intervaller for topppriser. Kortere pristopper rapporteres ikke som perioder.",
+            "long_description": "Når denne entiteten er aktivert, overstyrer verdien 'Minimum periodelengde'-innstillingen fra alternativer-dialogen for topppris-periodeberegninger.",
+            "usage_tips": "Kortere verdier fanger korte pristopper. Lengre verdier fokuserer på vedvarende høyprisperioder."
+        },
+        "peak_price_min_periods_override": {
+            "description": "Minimum antall topppris-perioder å finne daglig.",
+            "long_description": "Når denne entiteten er aktivert, overstyrer verdien 'Minimum perioder'-innstillingen fra alternativer-dialogen for topppris-periodeberegninger.",
+            "usage_tips": "Sett dette basert på hvor mange høyprisperioder du vil fange per dag for automatiseringer."
+        },
+        "peak_price_relaxation_attempts_override": {
+            "description": "Antall forsøk på å lempe kriteriene for å oppnå minimum antall topppris-perioder.",
+            "long_description": "Når denne entiteten er aktivert, overstyrer verdien 'Lemping forsøk'-innstillingen fra alternativer-dialogen for topppris-periodeberegninger.",
+            "usage_tips": "Øk dette hvis ingen perioder blir funnet på dager med stabile priser. Sett til 0 for å tvinge strenge kriterier."
+        },
+        "peak_price_gap_count_override": {
+            "description": "Maksimalt antall billigere intervaller som kan tillates mellom dyre intervaller mens de fortsatt regnes som en topppris-periode.",
+            "long_description": "Når denne entiteten er aktivert, overstyrer verdien 'Gaptoleranse'-innstillingen fra alternativer-dialogen for topppris-periodeberegninger.",
+            "usage_tips": "Høyere verdier fanger lengre høyprisperioder selv med korte prisdykk. Sett til 0 for strengt sammenhengende topppriser."
+        }
+    },
+    "switch": {
+        "best_price_enable_relaxation_override": {
+            "description": "Når aktivert, lempes kriteriene automatisk for å oppnå minimum periodeantall. Når deaktivert, rapporteres kun perioder som oppfyller strenge kriterier (muligens null perioder på dager med stabile priser).",
+            "long_description": "Når denne entiteten er aktivert, overstyrer verdien 'Oppnå minimumsantall'-innstillingen fra alternativer-dialogen for beste pris-periodeberegninger.",
+            "usage_tips": "Aktiver dette for garanterte daglige automatiseringsmuligheter. Deaktiver hvis du kun vil ha virkelig billige perioder, selv om det betyr ingen perioder på noen dager."
+        },
+        "peak_price_enable_relaxation_override": {
+            "description": "Når aktivert, lempes kriteriene automatisk for å oppnå minimum periodeantall. Når deaktivert, rapporteres kun ekte pristopper.",
+            "long_description": "Når denne entiteten er aktivert, overstyrer verdien 'Oppnå minimumsantall'-innstillingen fra alternativer-dialogen for topppris-periodeberegninger.",
+            "usage_tips": "Aktiver dette for konsistente topppris-varsler. Deaktiver for kun å fange ekstreme pristopper."
+        }
+    },
     "home_types": {
         "APARTMENT": "Leilighet",
         "ROWHOUSE": "Rekkehus",

custom_components/tibber_prices/custom_translations/nl.json

@@ -2,7 +2,9 @@
     "apexcharts": {
         "title_rating_level": "Prijsfasen dagverloop",
         "title_level": "Prijsniveau",
+        "hourly_suffix": "(Ø per uur)",
         "best_price_period_name": "Beste prijsperiode",
+        "peak_price_period_name": "Piekprijsperiode",
         "notification": {
             "metadata_sensor_unavailable": {
                 "title": "Tibber Prices: ApexCharts YAML gegenereerd met beperkte functionaliteit",
@@ -56,9 +58,9 @@
             "usage_tips": "Gebruik dit om te voorkomen dat je apparaten draait tijdens piekprijstijden"
         },
         "average_price_today": {
-            "description": "De gemiddelde elektriciteitsprijs voor vandaag per kWh",
-            "long_description": "Toont de gemiddelde prijs per kWh voor de huidige dag van je Tibber-abonnement",
-            "usage_tips": "Gebruik dit als basislijn voor het vergelijken van huidige prijzen"
+            "description": "Typische elektriciteitsprijs voor vandaag per kWh (configureerbare weergave)",
+            "long_description": "Toont de prijs per kWh voor de huidige dag van je Tibber-abonnement. **Standaard toont de status de mediaan** (resistent tegen extreme prijspieken, toont typisch prijsniveau). Je kunt dit wijzigen in de integratie-instellingen om het rekenkundig gemiddelde te tonen. De alternatieve waarde is beschikbaar als attribuut.",
+            "usage_tips": "Gebruik dit als basislijn voor het vergelijken van huidige prijzen. Voor berekeningen gebruik: {{ state_attr('sensor.average_price_today', 'price_mean') }}"
         },
         "lowest_price_tomorrow": {
             "description": "De laagste elektriciteitsprijs voor morgen per kWh",
@@ -71,9 +73,9 @@
             "usage_tips": "Gebruik dit om te voorkomen dat je apparaten draait tijdens de piekprijstijden van morgen. Handig voor het plannen rond dure perioden."
         },
         "average_price_tomorrow": {
-            "description": "De gemiddelde elektriciteitsprijs voor morgen per kWh",
-            "long_description": "Toont de gemiddelde prijs per kWh voor morgen van je Tibber-abonnement. Deze sensor wordt niet beschikbaar totdat de gegevens van morgen door Tibber worden gepubliceerd (meestal rond 13:00-14:00 CET).",
-            "usage_tips": "Gebruik dit als basislijn voor het vergelijken van prijzen van morgen en het plannen van verbruik. Vergelijk met het gemiddelde van vandaag om te zien of morgen over het algemeen duurder of goedkoper wordt."
+            "description": "Typische elektriciteitsprijs voor morgen per kWh (configureerbare weergave)",
+            "long_description": "Toont de prijs per kWh voor morgen van je Tibber-abonnement. **Standaard toont de status de mediaan** (resistent tegen extreme prijspieken). Je kunt dit wijzigen in de integratie-instellingen om het rekenkundig gemiddelde te tonen. De alternatieve waarde is beschikbaar als attribuut. Deze sensor wordt niet beschikbaar totdat de gegevens van morgen door Tibber worden gepubliceerd (meestal rond 13:00-14:00 CET).",
+            "usage_tips": "Gebruik dit als basislijn voor het vergelijken van prijzen van morgen en het plannen van verbruik. Vergelijk met de mediaan van vandaag om te zien of morgen over het algemeen duurder of goedkoper wordt."
         },
         "yesterday_price_level": {
             "description": "Geaggregeerd prijsniveau voor gisteren",
@@ -106,14 +108,14 @@
             "usage_tips": "Gebruik dit om het energieverbruik van morgen te plannen op basis van jouw persoonlijke prijsdrempelwaarden. Vergelijk met vandaag om te beslissen of je verbruik naar morgen moet verschuiven of vandaag energie moet gebruiken."
         },
         "trailing_price_average": {
-            "description": "De gemiddelde elektriciteitsprijs voor de afgelopen 24 uur per kWh",
-            "long_description": "Toont de gemiddelde prijs per kWh berekend uit de afgelopen 24 uur (voortschrijdend gemiddelde) van je Tibber-abonnement. Dit biedt een voortschrijdend gemiddelde dat elke 15 minuten wordt bijgewerkt op basis van historische gegevens.",
-            "usage_tips": "Gebruik dit om huidige prijzen te vergelijken met recente trends. Een huidige prijs die aanzienlijk boven dit gemiddelde ligt, kan aangeven dat het een goed moment is om het verbruik te verminderen."
+            "description": "Typische elektriciteitsprijs voor de afgelopen 24 uur per kWh (configureerbare weergave)",
+            "long_description": "Toont de prijs per kWh berekend uit de afgelopen 24 uur. **Standaard toont de status de mediaan** (resistent tegen extreme prijspieken, toont typisch prijsniveau). Je kunt dit wijzigen in de integratie-instellingen om het rekenkundig gemiddelde te tonen. De alternatieve waarde is beschikbaar als attribuut. Wordt elke 15 minuten bijgewerkt.",
+            "usage_tips": "Gebruik de statuswaarde om het typische huidige prijsniveau te zien. Voor kostenberekeningen gebruik: {{ state_attr('sensor.trailing_price_average', 'price_mean') }}"
         },
         "leading_price_average": {
-            "description": "De gemiddelde elektriciteitsprijs voor de komende 24 uur per kWh",
-            "long_description": "Toont de gemiddelde prijs per kWh berekend uit de komende 24 uur (vooruitlopend gemiddelde) van je Tibber-abonnement. Dit biedt een vooruitkijkend gemiddelde op basis van beschikbare prognosegegevens.",
-            "usage_tips": "Gebruik dit om energieverbruik te plannen. Als de huidige prijs onder het vooruitlopende gemiddelde ligt, kan het een goed moment zijn om energie-intensieve apparaten te laten draaien."
+            "description": "Typische elektriciteitsprijs voor de komende 24 uur per kWh (configureerbare weergave)",
+            "long_description": "Toont de prijs per kWh berekend uit de komende 24 uur. **Standaard toont de status de mediaan** (resistent tegen extreme prijspieken, toont verwacht prijsniveau). Je kunt dit wijzigen in de integratie-instellingen om het rekenkundig gemiddelde te tonen. De alternatieve waarde is beschikbaar als attribuut.",
+            "usage_tips": "Gebruik de statuswaarde om het typische toekomstige prijsniveau te zien. Voor kostenberekeningen gebruik: {{ state_attr('sensor.leading_price_average', 'price_mean') }}"
         },
         "trailing_price_min": {
             "description": "De minimale elektriciteitsprijs voor de afgelopen 24 uur per kWh",
@@ -290,24 +292,24 @@
             "long_description": "Toont het tijdstempel van het laatst beschikbare prijsgegevensinterval van je Tibber-abonnement"
         },
         "today_volatility": {
-            "description": "Prijsvolatiliteitsclassificatie voor vandaag",
-            "long_description": "Toont hoeveel elektriciteitsprijzen variëren gedurende vandaag op basis van de spreiding (verschil tussen hoogste en laagste prijs). Classificatie: laag = spreiding < 5ct, matig = 5-15ct, hoog = 15-30ct, zeer hoog = >30ct.",
-            "usage_tips": "Gebruik dit om te bepalen of prijsgebaseerde optimalisatie de moeite waard is. Bijvoorbeeld, met een balkonbatterij met 15% efficiëntieverlies is optimalisatie alleen zinvol wanneer volatiliteit ten minste matig is. Maak automatiseringen die volatiliteit controleren voordat je laad-/ontlaadcycli plant."
+            "description": "Hoeveel de stroomprijzen vandaag schommelen",
+            "long_description": "Geeft aan of de prijzen vandaag stabiel blijven of grote schommelingen hebben. Lage volatiliteit betekent vrij constante prijzen – timing maakt weinig uit. Hoge volatiliteit betekent duidelijke prijsverschillen gedurende de dag – goede kans om verbruik naar goedkopere periodes te verschuiven. `price_coefficient_variation_%` toont het percentage, `price_spread` de absolute prijsspanne.",
+            "usage_tips": "Gebruik dit om te beslissen of optimaliseren de moeite waard is. Bij lage volatiliteit kun je apparaten op elk moment laten draaien. Bij hoge volatiliteit bespaar je merkbaar door Best Price-periodes te volgen."
         },
         "tomorrow_volatility": {
-            "description": "Prijsvolatiliteitsclassificatie voor morgen",
-            "long_description": "Toont hoeveel elektriciteitsprijzen zullen variëren gedurende morgen op basis van de spreiding (verschil tussen hoogste en laagste prijs). Wordt onbeschikbaar totdat de gegevens van morgen zijn gepubliceerd (meestal 13:00-14:00 CET).",
-            "usage_tips": "Gebruik dit voor vooruitplanning van het energieverbruik van morgen. Als morgen hoog of zeer hoog volatiliteit heeft, is het de moeite waard om de timing van energieverbruik te optimaliseren. Bij laag kun je apparaten op elk moment gebruiken zonder significante kostenverschillen."
+            "description": "Hoeveel de stroomprijzen morgen zullen schommelen",
+            "long_description": "Geeft aan of de prijzen morgen stabiel blijven of grote schommelingen hebben. Beschikbaar zodra de gegevens voor morgen zijn gepubliceerd (meestal 13:00–14:00 CET). Lage volatiliteit betekent vrij constante prijzen – timing is niet kritisch. Hoge volatiliteit betekent duidelijke prijsverschillen gedurende de dag – goede kans om energie-intensieve taken te plannen. `price_coefficient_variation_%` toont het percentage, `price_spread` de absolute prijsspanne.",
+            "usage_tips": "Gebruik dit om het verbruik van morgen te plannen. Hoge volatiliteit? Plan flexibele lasten in Best Price-periodes. Lage volatiliteit? Laat apparaten draaien wanneer het jou uitkomt."
         },
         "next_24h_volatility": {
-            "description": "Prijsvolatiliteitsclassificatie voor de rollende volgende 24 uur",
-            "long_description": "Toont hoeveel elektriciteitsprijzen variëren in de volgende 24 uur vanaf nu (rollend venster). Dit overschrijdt daggrenzen en wordt elke 15 minuten bijgewerkt, wat een vooruitkijkende volatiliteitsbeoordeling biedt onafhankelijk van kalenderdagen.",
-            "usage_tips": "Beste sensor voor realtime optimalisatiebeslissingen. In tegenstelling tot vandaag/morgen-sensoren die om middernacht wisselen, biedt deze een continue 24-uurs volatiliteitsbeoordeling. Gebruik voor batterijlaadstrategieën die over daggrenzen heen gaan."
+            "description": "Hoeveel de prijzen de komende 24 uur zullen schommelen",
+            "long_description": "Geeft de prijsvolatiliteit aan voor een rollend 24-uursvenster vanaf nu (wordt elke 15 minuten bijgewerkt). Lage volatiliteit betekent vrij constante prijzen. Hoge volatiliteit betekent merkbare prijsschommelingen en dus optimalisatiemogelijkheden. In tegenstelling tot vandaag/morgen-sensoren overschrijdt deze daggrenzen en geeft een doorlopende vooruitblik. `price_coefficient_variation_%` toont het percentage, `price_spread` de absolute prijsspanne.",
+            "usage_tips": "Het beste voor beslissingen in real-time. Gebruik bij het plannen van batterijladen of andere flexibele lasten die over middernacht kunnen lopen. Biedt een consistent 24-uurs beeld, los van de kalenderdag."
         },
         "today_tomorrow_volatility": {
-            "description": "Gecombineerde prijsvolatiliteitsclassificatie voor vandaag en morgen",
-            "long_description": "Toont volatiliteit over zowel vandaag als morgen gecombineerd (wanneer de gegevens van morgen beschikbaar zijn). Biedt een uitgebreid overzicht van prijsvariatie over maximaal 48 uur. Valt terug op alleen vandaag wanneer de gegevens van morgen nog niet beschikbaar zijn.",
-            "usage_tips": "Gebruik dit voor meerdaagse planning en om te begrijpen of prijskansen bestaan over de daggrenzen heen. De attributen 'today_volatility' en 'tomorrow_volatility' tonen individuele dagbijdragen. Handig voor het plannen van laadsessies die middernacht kunnen overschrijden."
+            "description": "Gecombineerde prijsvolatiliteit voor vandaag en morgen",
+            "long_description": "Geeft de totale volatiliteit weer wanneer vandaag en morgen samen worden bekeken (zodra morgengegevens beschikbaar zijn). Toont of er duidelijke prijsverschillen over de daggrens heen zijn. Valt terug naar alleen vandaag als morgengegevens ontbreken. Handig voor meerdaagse optimalisatie. `price_coefficient_variation_%` toont het percentage, `price_spread` de absolute prijsspanne.",
+            "usage_tips": "Gebruik voor taken die meerdere dagen beslaan. Kijk of de prijsverschillen groot genoeg zijn om plannen op te baseren. De afzonderlijke dag-sensoren tonen per-dag bijdragen als je meer detail wilt."
         },
         "data_lifecycle_status": {
             "description": "Huidige status van prijsgegevenslevenscyclus en caching",
@@ -315,39 +317,49 @@
             "usage_tips": "Gebruik deze diagnostische sensor om gegevensfrisheid en API-aanroeppatronen te begrijpen. Controleer het 'cache_age'-attribuut om te zien hoe oud de huidige gegevens zijn. Monitor 'next_api_poll' om te weten wanneer de volgende update is gepland. Gebruik 'data_completeness' om te zien of gisteren/vandaag/morgen gegevens beschikbaar zijn. De 'api_calls_today'-teller helpt API-gebruik bij te houden. Perfect voor probleemoplossing of begrip van integratiegedrag."
         },
         "best_price_end_time": {
-            "description": "Wanneer de huidige of volgende goedkope periode eindigt",
-            "long_description": "Toont het eindtijdstempel van de huidige goedkope periode wanneer actief, of het einde van de volgende periode wanneer geen periode actief is. Toont altijd een nuttige tijdreferentie voor planning. Geeft alleen 'Onbekend' terug wanneer geen periodes zijn geconfigureerd.",
-            "usage_tips": "Gebruik dit om een aftelling weer te geven zoals 'Goedkope periode eindigt over 2 uur' (wanneer actief) of 'Volgende goedkope periode eindigt om 14:00' (wanneer inactief). Home Assistant toont automatisch relatieve tijd voor tijdstempelsensoren."
+            "description": "Totale lengte van huidige of volgende voordelige periode (state in uren, attribuut in minuten)",
+            "long_description": "Toont hoe lang de voordelige periode duurt. State gebruikt uren (float) voor een leesbare UI; attribuut `period_duration_minutes` behoudt afgeronde minuten voor automatiseringen. Actief → duur van de huidige periode, anders de volgende.",
+            "usage_tips": "UI kan 1,5 u tonen terwijl `period_duration_minutes` = 90 voor automatiseringen blijft."
+        },
+        "best_price_period_duration": {
+            "description": "Lengte van huidige/volgende goedkope periode",
+            "long_description": "Totale duur van huidige of volgende goedkope periode. De state wordt weergegeven in uren (bijv. 1,5 u) voor gemakkelijk aflezen in de UI, terwijl het attribuut `period_duration_minutes` dezelfde waarde in minuten levert (bijv. 90) voor automatiseringen. Deze waarde vertegenwoordigt de **volledige geplande duur** van de periode en is constant gedurende de gehele periode, zelfs als de resterende tijd (remaining_minutes) afneemt.",
+            "usage_tips": "Combineer met remaining_minutes om te berekenen wanneer langlopende apparaten moeten worden gestopt: Periode is `period_duration_minutes - remaining_minutes` minuten geleden gestart. Dit attribuut ondersteunt energie-optimalisatiestrategieën door te helpen bij het plannen van hoog-verbruiksactiviteiten binnen goedkope periodes."
         },
         "best_price_remaining_minutes": {
-            "description": "Resterende minuten in huidige goedkope periode (0 wanneer inactief)",
-            "long_description": "Toont hoeveel minuten er nog over zijn in de huidige goedkope periode. Geeft 0 terug wanneer geen periode actief is. Werkt elke minuut bij. Controleer binary_sensor.best_price_period om te zien of een periode momenteel actief is.",
-            "usage_tips": "Perfect voor automatiseringen: 'Als remaining_minutes > 0 EN remaining_minutes < 30, start wasmachine nu'. De waarde 0 maakt het gemakkelijk om te controleren of een periode actief is (waarde > 0) of niet (waarde = 0)."
+            "description": "Resterende tijd in huidige goedkope periode",
+            "long_description": "Toont hoeveel tijd er nog overblijft in de huidige goedkope periode. De state wordt weergegeven in uren (bijv. 0,75 u) voor gemakkelijk aflezen in dashboards, terwijl het attribuut `remaining_minutes` dezelfde tijd in minuten levert (bijv. 45) voor automatiseringsvoorwaarden. **Afteltimer**: Deze waarde neemt elke minuut af tijdens een actieve periode. Geeft 0 terug wanneer geen goedkope periode actief is. Werkt elke minuut bij.",
+            "usage_tips": "Voor automatiseringen: Gebruik attribuut `remaining_minutes` zoals 'Als remaining_minutes > 60, start vaatwasser nu (genoeg tijd om te voltooien)' of 'Als remaining_minutes < 15, rond huidige cyclus binnenkort af'. UI toont gebruiksvriendelijke uren (bijv. 1,25 u). Waarde 0 geeft aan dat geen goedkope periode actief is."
         },
         "best_price_progress": {
             "description": "Voortgang door huidige goedkope periode (0% wanneer inactief)",
-            "long_description": "Toont de voortgang door de huidige goedkope periode als 0-100%. Geeft 0% terug wanneer geen periode actief is. Werkt elke minuut bij. 0% betekent periode net gestart, 100% betekent het eindigt bijna.",
-            "usage_tips": "Geweldig voor visuele voortgangsbalken. Gebruik in automatiseringen: 'Als progress > 0 EN progress > 75, stuur melding dat goedkope periode bijna eindigt'. Waarde 0 geeft aan dat er geen actieve periode is."
+            "long_description": "Toont voortgang door de huidige goedkope periode als 0-100%. Geeft 0% terug wanneer geen periode actief is. Werkt elke minuut bij. 0% betekent periode net gestart, 100% betekent dat deze bijna eindigt.",
+            "usage_tips": "Geweldig voor visuele voortgangsbalken. Gebruik in automatiseringen: 'Als progress > 0 EN progress > 75, stuur melding dat goedkope periode bijna eindigt'. Waarde 0 geeft aan dat geen periode actief is."
         },
         "best_price_next_start_time": {
-            "description": "Wanneer de volgende goedkope periode begint",
-            "long_description": "Toont wanneer de volgende komende goedkope periode begint. Tijdens een actieve periode toont dit de start van de VOLGENDE periode na de huidige. Geeft alleen 'Onbekend' terug wanneer geen toekomstige periodes zijn geconfigureerd.",
-            "usage_tips": "Altijd nuttig voor vooruitplanning: 'Volgende goedkope periode begint over 3 uur' (of je nu in een periode zit of niet). Combineer met automatiseringen: 'Wanneer volgende starttijd over 10 minuten is, stuur melding om wasmachine voor te bereiden'."
+            "description": "Totale lengte van huidige of volgende dure periode (state in uren, attribuut in minuten)",
+            "long_description": "Toont hoe lang de dure periode duurt. State gebruikt uren (float) voor de UI; attribuut `period_duration_minutes` behoudt afgeronde minuten voor automatiseringen. Actief → duur van de huidige periode, anders de volgende.",
+            "usage_tips": "UI kan 0,75 u tonen terwijl `period_duration_minutes` = 45 voor automatiseringen blijft."
         },
         "best_price_next_in_minutes": {
-            "description": "Minuten tot volgende goedkope periode begint (0 bij overgang)",
-            "long_description": "Toont minuten tot de volgende goedkope periode begint. Tijdens een actieve periode toont dit de tijd tot de periode NA de huidige. Geeft 0 terug tijdens korte overgangsmomenten. Werkt elke minuut bij.",
-            "usage_tips": "Perfect voor 'wacht tot goedkope periode' automatiseringen: 'Als next_in_minutes > 0 EN next_in_minutes < 15, wacht voordat vaatwasser wordt gestart'. Waarde > 0 geeft altijd aan dat een toekomstige periode is gepland."
+            "description": "Resterende tijd in huidige dure periode (state in uren, attribuut in minuten)",
+            "long_description": "Toont hoeveel tijd er nog over is. State gebruikt uren (float); attribuut `remaining_minutes` behoudt afgeronde minuten voor automatiseringen. Geeft 0 terug wanneer er geen periode actief is. Werkt elke minuut bij.",
+            "usage_tips": "Gebruik `remaining_minutes` voor drempels (bijv. > 60) terwijl de state in uren goed leesbaar blijft."
         },
         "peak_price_end_time": {
-            "description": "Wanneer de huidige of volgende dure periode eindigt",
-            "long_description": "Toont het eindtijdstempel van de huidige dure periode wanneer actief, of het einde van de volgende periode wanneer geen periode actief is. Toont altijd een nuttige tijdreferentie voor planning. Geeft alleen 'Onbekend' terug wanneer geen periodes zijn geconfigureerd.",
-            "usage_tips": "Gebruik dit om 'Dure periode eindigt over 1 uur' weer te geven (wanneer actief) of 'Volgende dure periode eindigt om 18:00' (wanneer inactief). Combineer met automatiseringen om activiteiten te hervatten na piek."
+            "description": "Tijd tot volgende dure periode (state in uren, attribuut in minuten)",
+            "long_description": "Toont hoe lang het duurt tot de volgende dure periode start. State gebruikt uren (float); attribuut `next_in_minutes` behoudt afgeronde minuten voor automatiseringen. Tijdens een actieve periode is dit de tijd tot de periode na de huidige. 0 tijdens korte overgangen. Werkt elke minuut bij.",
+            "usage_tips": "Gebruik `next_in_minutes` in automatiseringen (bijv. < 10) terwijl de state in uren leesbaar blijft."
+        },
+        "peak_price_period_duration": {
+            "description": "Totale duur van huidige of volgende dure periode in minuten",
+            "long_description": "Toont de totale duur van de dure periode in minuten. Tijdens een actieve periode toont dit de volledige lengte van de huidige periode. Wanneer geen periode actief is, toont dit de duur van de volgende komende periode. Voorbeeld: '60 minuten' voor een 1-uur periode.",
+            "usage_tips": "Gebruik om energiebesparende maatregelen te plannen: 'Als duration > 120, verlaag verwarmingstemperatuur agressiever (lange dure periode)'. Helpt bij het inschatten hoeveel energieverbruik moet worden verminderd."
         },
         "peak_price_remaining_minutes": {
-            "description": "Resterende minuten in huidige dure periode (0 wanneer inactief)",
-            "long_description": "Toont hoeveel minuten er nog over zijn in de huidige dure periode. Geeft 0 terug wanneer geen periode actief is. Werkt elke minuut bij. Controleer binary_sensor.peak_price_period om te zien of een periode momenteel actief is.",
-            "usage_tips": "Gebruik in automatiseringen: 'Als remaining_minutes > 60, annuleer uitgestelde laadronde'. Waarde 0 maakt het gemakkelijk om onderscheid te maken tussen actieve (waarde > 0) en inactieve (waarde = 0) periodes."
+            "description": "Resterende tijd in huidige dure periode",
+            "long_description": "Toont hoeveel tijd er nog overblijft in de huidige dure periode. De state wordt weergegeven in uren (bijv. 0,75 u) voor gemakkelijk aflezen in dashboards, terwijl het attribuut `remaining_minutes` dezelfde tijd in minuten levert (bijv. 45) voor automatiseringsvoorwaarden. **Afteltimer**: Deze waarde neemt elke minuut af tijdens een actieve periode. Geeft 0 terug wanneer geen dure periode actief is. Werkt elke minuut bij.",
+            "usage_tips": "Voor automatiseringen: Gebruik attribuut `remaining_minutes` zoals 'Als remaining_minutes > 60, annuleer uitgestelde laadronde' of 'Als remaining_minutes < 15, hervat normaal gebruik binnenkort'. UI toont gebruiksvriendelijke uren (bijv. 1,0 u). Waarde 0 geeft aan dat geen dure periode actief is."
         },
         "peak_price_progress": {
             "description": "Voortgang door huidige dure periode (0% wanneer inactief)",
@@ -360,19 +372,9 @@
             "usage_tips": "Altijd nuttig voor planning: 'Volgende dure periode begint over 2 uur'. Automatisering: 'Wanneer volgende starttijd over 30 minuten is, verlaag verwarmingstemperatuur preventief'."
         },
         "peak_price_next_in_minutes": {
-            "description": "Minuten tot volgende dure periode begint (0 bij overgang)",
-            "long_description": "Toont minuten tot de volgende dure periode begint. Tijdens een actieve periode toont dit de tijd tot de periode NA de huidige. Geeft 0 terug tijdens korte overgangsmomenten. Werkt elke minuut bij.",
-            "usage_tips": "Preventieve automatisering: 'Als next_in_minutes > 0 EN next_in_minutes < 10, voltooi huidige laadcyclus nu voordat prijzen stijgen'."
-        },
-        "best_price_period_duration": {
-            "description": "Totale duur van huidige of volgende goedkope periode in minuten",
-            "long_description": "Toont de totale duur van de goedkope periode in minuten. Tijdens een actieve periode toont dit de volledige lengte van de huidige periode. Wanneer geen periode actief is, toont dit de duur van de volgende komende periode. Voorbeeld: '90 minuten' voor een 1,5-uur periode.",
-            "usage_tips": "Combineer met remaining_minutes voor taakplanning: 'Als duration = 120 EN remaining_minutes > 90, start wasmachine (genoeg tijd om te voltooien)'. Nuttig om te begrijpen of periodes lang genoeg zijn voor energie-intensieve taken."
-        },
-        "peak_price_period_duration": {
-            "description": "Totale duur van huidige of volgende dure periode in minuten",
-            "long_description": "Toont de totale duur van de dure periode in minuten. Tijdens een actieve periode toont dit de volledige lengte van de huidige periode. Wanneer geen periode actief is, toont dit de duur van de volgende komende periode. Voorbeeld: '60 minuten' voor een 1-uur periode.",
-            "usage_tips": "Gebruik om energiebesparende maatregelen te plannen: 'Als duration > 120, verlaag verwarmingstemperatuur agressiever (lange dure periode)'. Helpt bij het inschatten hoeveel energieverbruik moet worden verminderd."
+            "description": "Tijd tot volgende dure periode",
+            "long_description": "Toont hoe lang het duurt tot de volgende dure periode. De state wordt weergegeven in uren (bijv. 0,5 u) voor dashboards, terwijl het attribuut `next_in_minutes` minuten levert (bijv. 30) voor automatiseringsvoorwaarden. Tijdens een actieve periode toont dit de tijd tot de periode NA de huidige. Geeft 0 terug tijdens korte overgangsmomenten. Werkt elke minuut bij.",
+            "usage_tips": "Voor automatiseringen: Gebruik attribuut `next_in_minutes` zoals 'Als next_in_minutes > 0 EN next_in_minutes < 10, voltooi huidige laadcyclus nu voordat prijzen stijgen'. Waarde > 0 geeft altijd aan dat een toekomstige dure periode is gepland."
         },
         "home_type": {
             "description": "Type woning (appartement, huis enz.)",
@@ -487,6 +489,80 @@
             "usage_tips": "Gebruik dit om te verifiëren dat realtimeverbruiksgegevens beschikbaar zijn. Schakel meldingen in als dit onverwacht verandert naar 'uit', wat wijst op mogelijke hardware- of verbindingsproblemen."
         }
     },
+    "number": {
+        "best_price_flex_override": {
+            "description": "Maximaal percentage boven de dagelijkse minimumprijs dat intervallen kunnen hebben en nog steeds als 'beste prijs' kwalificeren. Aanbevolen: 15-20 met versoepeling ingeschakeld (standaard), of 25-35 zonder versoepeling. Maximum: 50 (harde limiet voor betrouwbare periodedetectie).",
+            "long_description": "Wanneer deze entiteit is ingeschakeld, overschrijft de waarde de 'Flexibiliteit'-instelling uit de opties-dialoog voor beste prijs-periodeberekeningen.",
+            "usage_tips": "Schakel deze entiteit in om beste prijs-detectie dynamisch aan te passen via automatiseringen, bijv. hogere flexibiliteit voor kritieke lasten of strengere eisen voor flexibele apparaten."
+        },
+        "best_price_min_distance_override": {
+            "description": "Minimale procentuele afstand onder het daggemiddelde. Intervallen moeten zo ver onder het gemiddelde liggen om als 'beste prijs' te kwalificeren. Helpt echte lage prijsperioden te onderscheiden van gemiddelde prijzen.",
+            "long_description": "Wanneer deze entiteit is ingeschakeld, overschrijft de waarde de 'Minimale afstand'-instelling uit de opties-dialoog voor beste prijs-periodeberekeningen.",
+            "usage_tips": "Verhoog de waarde voor strengere beste prijs-criteria. Verlaag als te weinig perioden worden gedetecteerd."
+        },
+        "best_price_min_period_length_override": {
+            "description": "Minimale periodelengte in 15-minuten intervallen. Perioden korter dan dit worden niet gerapporteerd. Voorbeeld: 2 = minimaal 30 minuten.",
+            "long_description": "Wanneer deze entiteit is ingeschakeld, overschrijft de waarde de 'Minimale periodelengte'-instelling uit de opties-dialoog voor beste prijs-periodeberekeningen.",
+            "usage_tips": "Pas aan op typische apparaatlooptijd: 2 (30 min) voor snelle programma's, 4-8 (1-2 uur) voor normale cycli, 8+ voor lange ECO-programma's."
+        },
+        "best_price_min_periods_override": {
+            "description": "Minimum aantal beste prijs-perioden om dagelijks te vinden. Wanneer versoepeling is ingeschakeld, past het systeem automatisch de criteria aan om dit aantal te bereiken.",
+            "long_description": "Wanneer deze entiteit is ingeschakeld, overschrijft de waarde de 'Minimum periodes'-instelling uit de opties-dialoog voor beste prijs-periodeberekeningen.",
+            "usage_tips": "Stel dit in op het aantal tijdkritieke taken dat je dagelijks hebt. Voorbeeld: 2 voor twee wasladingen."
+        },
+        "best_price_relaxation_attempts_override": {
+            "description": "Aantal pogingen om de criteria geleidelijk te versoepelen om het minimum aantal perioden te bereiken. Elke poging verhoogt de flexibiliteit met 3 procent. Bij 0 worden alleen basiscriteria gebruikt.",
+            "long_description": "Wanneer deze entiteit is ingeschakeld, overschrijft de waarde de 'Versoepeling pogingen'-instelling uit de opties-dialoog voor beste prijs-periodeberekeningen.",
+            "usage_tips": "Hogere waarden maken periodedetectie adaptiever voor dagen met stabiele prijzen. Stel in op 0 om strikte criteria af te dwingen zonder versoepeling."
+        },
+        "best_price_gap_count_override": {
+            "description": "Maximum aantal duurdere intervallen dat mag worden toegestaan tussen goedkope intervallen terwijl ze nog steeds als één aaneengesloten periode tellen. Bij 0 moeten goedkope intervallen opeenvolgend zijn.",
+            "long_description": "Wanneer deze entiteit is ingeschakeld, overschrijft de waarde de 'Gap tolerantie'-instelling uit de opties-dialoog voor beste prijs-periodeberekeningen.",
+            "usage_tips": "Verhoog dit voor apparaten met variabele belasting (bijv. warmtepompen) die korte duurdere intervallen kunnen tolereren. Stel in op 0 voor continu goedkope perioden."
+        },
+        "peak_price_flex_override": {
+            "description": "Maximaal percentage onder de dagelijkse maximumprijs dat intervallen kunnen hebben en nog steeds als 'piekprijs' kwalificeren. Dezelfde aanbevelingen als voor beste prijs-flexibiliteit.",
+            "long_description": "Wanneer deze entiteit is ingeschakeld, overschrijft de waarde de 'Flexibiliteit'-instelling uit de opties-dialoog voor piekprijs-periodeberekeningen.",
+            "usage_tips": "Gebruik dit om de piekprijs-drempel tijdens runtime aan te passen voor automatiseringen die verbruik tijdens dure uren vermijden."
+        },
+        "peak_price_min_distance_override": {
+            "description": "Minimale procentuele afstand boven het daggemiddelde. Intervallen moeten zo ver boven het gemiddelde liggen om als 'piekprijs' te kwalificeren.",
+            "long_description": "Wanneer deze entiteit is ingeschakeld, overschrijft de waarde de 'Minimale afstand'-instelling uit de opties-dialoog voor piekprijs-periodeberekeningen.",
+            "usage_tips": "Verhoog de waarde om alleen extreme prijspieken te vangen. Verlaag om meer dure tijden mee te nemen."
+        },
+        "peak_price_min_period_length_override": {
+            "description": "Minimale periodelengte in 15-minuten intervallen voor piekprijzen. Kortere prijspieken worden niet als perioden gerapporteerd.",
+            "long_description": "Wanneer deze entiteit is ingeschakeld, overschrijft de waarde de 'Minimale periodelengte'-instelling uit de opties-dialoog voor piekprijs-periodeberekeningen.",
+            "usage_tips": "Kortere waarden vangen korte prijspieken. Langere waarden focussen op aanhoudende dure perioden."
+        },
+        "peak_price_min_periods_override": {
+            "description": "Minimum aantal piekprijs-perioden om dagelijks te vinden.",
+            "long_description": "Wanneer deze entiteit is ingeschakeld, overschrijft de waarde de 'Minimum periodes'-instelling uit de opties-dialoog voor piekprijs-periodeberekeningen.",
+            "usage_tips": "Stel dit in op basis van hoeveel dure perioden je per dag wilt vangen voor automatiseringen."
+        },
+        "peak_price_relaxation_attempts_override": {
+            "description": "Aantal pogingen om de criteria te versoepelen om het minimum aantal piekprijs-perioden te bereiken.",
+            "long_description": "Wanneer deze entiteit is ingeschakeld, overschrijft de waarde de 'Versoepeling pogingen'-instelling uit de opties-dialoog voor piekprijs-periodeberekeningen.",
+            "usage_tips": "Verhoog dit als geen perioden worden gevonden op dagen met stabiele prijzen. Stel in op 0 om strikte criteria af te dwingen."
+        },
+        "peak_price_gap_count_override": {
+            "description": "Maximum aantal goedkopere intervallen dat mag worden toegestaan tussen dure intervallen terwijl ze nog steeds als één piekprijs-periode tellen.",
+            "long_description": "Wanneer deze entiteit is ingeschakeld, overschrijft de waarde de 'Gap tolerantie'-instelling uit de opties-dialoog voor piekprijs-periodeberekeningen.",
+            "usage_tips": "Hogere waarden vangen langere dure perioden zelfs met korte prijsdips. Stel in op 0 voor strikt aaneengesloten piekprijzen."
+        }
+    },
+    "switch": {
+        "best_price_enable_relaxation_override": {
+            "description": "Indien ingeschakeld, worden criteria automatisch versoepeld om het minimum aantal perioden te bereiken. Indien uitgeschakeld, worden alleen perioden gerapporteerd die aan strikte criteria voldoen (mogelijk nul perioden op dagen met stabiele prijzen).",
+            "long_description": "Wanneer deze entiteit is ingeschakeld, overschrijft de waarde de 'Minimum aantal bereiken'-instelling uit de opties-dialoog voor beste prijs-periodeberekeningen.",
+            "usage_tips": "Schakel dit in voor gegarandeerde dagelijkse automatiseringsmogelijkheden. Schakel uit als je alleen echt goedkope perioden wilt, ook als dat betekent dat er op sommige dagen geen perioden zijn."
+        },
+        "peak_price_enable_relaxation_override": {
+            "description": "Indien ingeschakeld, worden criteria automatisch versoepeld om het minimum aantal perioden te bereiken. Indien uitgeschakeld, worden alleen echte prijspieken gerapporteerd.",
+            "long_description": "Wanneer deze entiteit is ingeschakeld, overschrijft de waarde de 'Minimum aantal bereiken'-instelling uit de opties-dialoog voor piekprijs-periodeberekeningen.",
+            "usage_tips": "Schakel dit in voor consistente piekprijs-waarschuwingen. Schakel uit om alleen extreme prijspieken te vangen."
+        }
+    },
     "home_types": {
         "APARTMENT": "Appartement",
         "ROWHOUSE": "Rijhuis",

custom_components/tibber_prices/custom_translations/sv.json

@@ -2,7 +2,9 @@
     "apexcharts": {
         "title_rating_level": "Prisfaser dagsprogress",
         "title_level": "Prisnivå",
+        "hourly_suffix": "(Ø per timme)",
         "best_price_period_name": "Bästa prisperiod",
+        "peak_price_period_name": "Toppprisperiod",
         "notification": {
             "metadata_sensor_unavailable": {
                 "title": "Tibber Prices: ApexCharts YAML genererad med begränsad funktionalitet",
@@ -56,9 +58,9 @@
             "usage_tips": "Använd detta för att undvika att köra apparater under topppristider"
         },
         "average_price_today": {
-            "description": "Det genomsnittliga elpriset för idag per kWh",
-            "long_description": "Visar genomsnittspriset per kWh för nuvarande dag från ditt Tibber-abonnemang",
-            "usage_tips": "Använd detta som baslinje för att jämföra nuvarande priser"
+            "description": "Typiskt elpris för idag per kWh (konfigurerbart visningsformat)",
+            "long_description": "Visar priset per kWh för nuvarande dag från ditt Tibber-abonnemang. **Som standard visar statusen medianen** (motståndskraftig mot extrema prispikar, visar typisk prisnåvå). Du kan ändra detta i integrationsinstllningarna för att visa det aritmetiska medelvärdet istället. Det alternativa värdet är tillgängligt som attribut.",
+            "usage_tips": "Använd detta som baslinje för att jämföra nuvarande priser. För beräkningar använd: {{ state_attr('sensor.average_price_today', 'price_mean') }}"
         },
         "lowest_price_tomorrow": {
             "description": "Det lägsta elpriset för imorgon per kWh",
@@ -71,9 +73,9 @@
             "usage_tips": "Använd detta för att undvika att köra apparater under morgondagens topppristider. Användbart för att planera runt dyra perioder."
         },
         "average_price_tomorrow": {
-            "description": "Det genomsnittliga elpriset för imorgon per kWh",
-            "long_description": "Visar genomsnittspriset per kWh för morgondagen från ditt Tibber-abonnemang. Denna sensor blir otillgänglig tills morgondagens data publiceras av Tibber (vanligtvis runt 13:00-14:00 CET).",
-            "usage_tips": "Använd detta som baslinje för att jämföra morgondagens priser och planera konsumtion. Jämför med dagens genomsnitt för att se om morgondagen kommer att bli dyrare eller billigare totalt sett."
+            "description": "Typiskt elpris för imorgon per kWh (konfigurerbart visningsformat)",
+            "long_description": "Visar priset per kWh för morgondagen från ditt Tibber-abonnemang. **Som standard visar statusen medianen** (motståndskraftig mot extrema prispikar). Du kan ändra detta i integrationsinstllningarna för att visa det aritmetiska medelvärdet istället. Det alternativa värdet är tillgängligt som attribut. Denna sensor blir otillgänglig tills morgondagens data publiceras av Tibber (vanligtvis runt 13:00-14:00 CET).",
+            "usage_tips": "Använd detta som baslinje för att jämföra morgondagens priser och planera konsumtion. Jämför med dagens median för att se om morgondagen kommer att bli dyrare eller billigare totalt sett."
         },
         "yesterday_price_level": {
             "description": "Aggregerad prisnivå för igår",
@@ -106,14 +108,14 @@
             "usage_tips": "Använd detta för att planera imorgonens energiförbrukning baserat på dina personliga priströskelvärden. Jämför med idag för att avgöra om du ska skjuta upp förbrukning till imorgon eller använda energi idag."
         },
         "trailing_price_average": {
-            "description": "Det genomsnittliga elpriset för de senaste 24 timmarna per kWh",
-            "long_description": "Visar genomsnittspriset per kWh beräknat från de senaste 24 timmarna (rullande genomsnitt) från ditt Tibber-abonnemang. Detta ger ett rullande genomsnitt som uppdateras var 15:e minut baserat på historiska data.",
-            "usage_tips": "Använd detta för att jämföra nuvarande priser mot senaste trender. Ett nuvarande pris som ligger väsentligt över detta genomsnitt kan indikera ett bra tillfälle att minska konsumtionen."
+            "description": "Typiskt elpris för de senaste 24 timmarna per kWh (konfigurerbart visningsformat)",
+            "long_description": "Visar priset per kWh beräknat från de senaste 24 timmarna. **Som standard visar statusen medianen** (motståndskraftig mot extrema prispikar, visar typisk prisnåvå). Du kan ändra detta i integrationsinstllningarna för att visa det aritmetiska medelvärdet istället. Det alternativa värdet är tillgängligt som attribut. Uppdateras var 15:e minut.",
+            "usage_tips": "Använd statusvärdet för att se den typiska nuvarande prisnåvån. För kostnadsberäkningar använd: {{ state_attr('sensor.trailing_price_average', 'price_mean') }}"
         },
         "leading_price_average": {
-            "description": "Det genomsnittliga elpriset för nästa 24 timmar per kWh",
-            "long_description": "Visar genomsnittspriset per kWh beräknat från nästa 24 timmar (framåtblickande genomsnitt) från ditt Tibber-abonnemang. Detta ger ett framåtblickande genomsnitt baserat på tillgängliga prognosdata.",
-            "usage_tips": "Använd detta för att planera energianvändning. Om nuvarande pris är under det framåtblickande genomsnittet kan det vara ett bra tillfälle att köra energikrävande apparater."
+            "description": "Typiskt elpris för nästa 24 timmar per kWh (konfigurerbart visningsformat)",
+            "long_description": "Visar priset per kWh beräknat från nästa 24 timmar. **Som standard visar statusen medianen** (motståndskraftig mot extrema prispikar, visar förväntad prisnåvå). Du kan ändra detta i integrationsinstllningarna för att visa det aritmetiska medelvärdet istället. Det alternativa värdet är tillgängligt som attribut.",
+            "usage_tips": "Använd statusvärdet för att se den typiska kommande prisnåvån. För kostnadsberäkningar använd: {{ state_attr('sensor.leading_price_average', 'price_mean') }}"
         },
         "trailing_price_min": {
             "description": "Det minsta elpriset för de senaste 24 timmarna per kWh",
@@ -290,64 +292,74 @@
             "long_description": "Visar tidsstämpeln för det senaste tillgängliga prisdataintervallet från ditt Tibber-abonnemang"
         },
         "today_volatility": {
-            "description": "Prisvolatilitetsklassificering för idag",
-            "long_description": "Visar hur mycket elpriserna varierar under dagen baserat på spridningen (skillnaden mellan högsta och lägsta pris). Klassificering: låg = spridning < 5 öre, måttlig = 5-15 öre, hög = 15-30 öre, mycket hög = >30 öre.",
-            "usage_tips": "Använd detta för att avgöra om prisbaserad optimering är värt besväret. Till exempel, med ett balkongbatteri som har 15% effektivitetsförlust är optimering endast meningsfull när volatiliteten är åtminstone måttlig. Skapa automationer som kontrollerar volatiliteten innan laddnings-/urladdningscykler planeras."
+            "description": "Hur mycket elpriserna varierar idag",
+            "long_description": "Visar om dagens priser är stabila eller har stora svängningar. Låg volatilitet innebär ganska jämna priser – timing spelar liten roll. Hög volatilitet innebär tydliga prisskillnader under dagen – bra tillfälle att flytta förbrukning till billigare perioder. `price_coefficient_variation_%` visar procentvärdet, `price_spread` visar den absoluta prisspannet.",
+            "usage_tips": "Använd detta för att avgöra om optimering är värt besväret. Vid låg volatilitet kan du köra enheter när som helst. Vid hög volatilitet sparar du märkbart genom att följa Best Price-perioder."
         },
         "tomorrow_volatility": {
-            "description": "Prisvolatilitetsklassificering för imorgon",
-            "long_description": "Visar hur mycket elpriserna kommer att variera under morgondagen baserat på spridningen (skillnaden mellan högsta och lägsta pris). Blir otillgänglig tills morgondagens data publiceras (vanligtvis 13:00-14:00 CET).",
-            "usage_tips": "Använd detta för förhandsplanering av morgondagens energianvändning. Om morgondagen har hög eller mycket hög volatilitet är det värt att optimera energiförbrukningstiming. Vid låg volatilitet kan du köra enheter när som helst utan betydande kostnadsskillnader."
+            "description": "Hur mycket elpriserna kommer att variera i morgon",
+            "long_description": "Visar om priserna i morgon blir stabila eller får stora svängningar. Tillgänglig när morgondagens data är publicerad (vanligen 13:00–14:00 CET). Låg volatilitet innebär ganska jämna priser – timing är inte kritisk. Hög volatilitet innebär tydliga prisskillnader under dagen – bra läge att planera energikrävande uppgifter. `price_coefficient_variation_%` visar procentvärdet, `price_spread` visar den absoluta prisspannet.",
+            "usage_tips": "Använd för att planera morgondagens förbrukning. Hög volatilitet? Planera flexibla laster i Best Price-perioder. Låg volatilitet? Kör enheter när det passar dig."
         },
         "next_24h_volatility": {
-            "description": "Prisvolatilitetsklassificering för rullande nästa 24 timmar",
-            "long_description": "Visar hur mycket elpriserna varierar under de nästa 24 timmarna från nu (rullande fönster). Detta korsar daggränser och uppdateras var 15:e minut, vilket ger en framåtblickande volatilitetsbedömning oberoende av kalenderdagar.",
-            "usage_tips": "Bästa sensorn för realtidsoptimeringsbeslut. Till skillnad från idag/imorgon-sensorer som växlar vid midnatt ger detta en kontinuerlig 24t volatilitetsbedömning. Använd för batteriladningsstrategier som sträcker sig över daggränser."
+            "description": "Hur mycket priserna varierar de kommande 24 timmarna",
+            "long_description": "Visar prisvolatilitet för ett rullande 24-timmarsfönster från nu (uppdateras var 15:e minut). Låg volatilitet innebär ganska jämna priser. Hög volatilitet innebär märkbara prissvängningar och därmed optimeringsmöjligheter. Till skillnad från idag/i morgon-sensorer korsar den här dagsgränser och ger en kontinuerlig framåtblickande bedömning. `price_coefficient_variation_%` visar procentvärdet, `price_spread` visar den absoluta prisspannet.",
+            "usage_tips": "Bäst för beslut i realtid. Använd vid planering av batteriladdning eller andra flexibla laster som kan gå över midnatt. Ger en konsekvent 24h-bild oberoende av kalenderdag."
         },
         "today_tomorrow_volatility": {
-            "description": "Kombinerad prisvolatilitetsklassificering för idag och imorgon",
-            "long_description": "Visar volatilitet över både idag och imorgon kombinerat (när morgondagens data är tillgänglig). Ger en utökad vy av prisvariation över upp till 48 timmar. Faller tillbaka till endast idag när morgondagens data inte är tillgänglig ännu.",
-            "usage_tips": "Använd detta för flerdagarsplanering och för att förstå om prismöjligheter existerar över dagsgränsen. Attributen 'today_volatility' och 'tomorrow_volatility' visar individuella dagsbidrag. Användbart för planering av laddningssessioner som kan sträcka sig över midnatt."
+            "description": "Kombinerad prisvolatilitet för idag och imorgon",
+            "long_description": "Visar den samlade volatiliteten när idag och imorgon ses tillsammans (när morgondatan finns). Visar om det finns tydliga prisskillnader över dagsgränsen. Faller tillbaka till endast idag om morgondatan saknas. Nyttig för flerdagarsoptimering. `price_coefficient_variation_%` visar procentvärdet, `price_spread` visar den absoluta prisspannet.",
+            "usage_tips": "Använd för uppgifter som sträcker sig över flera dagar. Kontrollera om prisskillnaderna är stora nog för att planera efter. De enskilda dag-sensorerna visar bidrag per dag om du behöver mer detaljer."
         },
         "data_lifecycle_status": {
-            "description": "Aktuell status för prisdatalivscykel och cachning",
-            "long_description": "Visar om integrationen använder cachad data eller färsk data från API:et. Visar aktuell livscykelstatus: 'cached' (använder lagrad data), 'fresh' (nyss hämtad från API), 'refreshing' (hämtar för närvarande), 'searching_tomorrow' (söker aktivt efter morgondagens data efter 13:00), 'turnover_pending' (inom 15 minuter före midnatt, 23:45-00:00), eller 'error' (hämtning misslyckades). Inkluderar omfattande attribut som cache-ålder, nästa API-polling, datafullständighet och API-anropsstatistik.",
-            "usage_tips": "Använd denna diagnostiksensor för att förstå datafärskhet och API-anropsmönster. Kontrollera 'cache_age'-attributet för att se hur gammal den aktuella datan är. Övervaka 'next_api_poll' för att veta när nästa uppdatering är schemalagd. Använd 'data_completeness' för att se om data för igår/idag/imorgon är tillgänglig. Räknaren 'api_calls_today' hjälper till att spåra API-användning. Perfekt för felsökning eller förståelse av integrationens beteende."
+            "description": "Gjeldende tilstand for prisdatalivssyklus og hurtigbufring",
+            "long_description": "Viser om integrasjonen bruker hurtigbufrede data eller ferske data fra API-et. Viser gjeldende livssyklustilstand: 'cached' (bruker lagrede data), 'fresh' (nettopp hentet fra API), 'refreshing' (henter for øyeblikket), 'searching_tomorrow' (søker aktivt etter morgendagens data etter 13:00), 'turnover_pending' (innen 15 minutter før midnatt, 23:45-00:00), eller 'error' (henting mislyktes). Inkluderer omfattende attributter som cache-alder, neste API-spørring, datafullstendighet og API-anropsstatistikk.",
+            "usage_tips": "Bruk denne diagnosesensoren for å forstå dataferskhet og API-anropsmønstre. Sjekk 'cache_age'-attributtet for å se hvor gamle de nåværende dataene er. Overvåk 'next_api_poll' for å vite når neste oppdatering er planlagt. Bruk 'data_completeness' for å se om data for i går/i dag/i morgen er tilgjengelig. 'api_calls_today'-telleren hjelper med å spore API-bruk. Perfekt for feilsøking eller forståelse av integrasjonens oppførsel."
         },
         "best_price_end_time": {
-            "description": "När nuvarande eller nästa billigperiod slutar",
-            "long_description": "Visar sluttidsstämpeln för nuvarande billigperiod när aktiv, eller slutet av nästa period när ingen period är aktiv. Visar alltid en användbar tidsreferens för planering. Returnerar 'Okänt' endast när inga perioder är konfigurerade.",
-            "usage_tips": "Använd detta för att visa en nedräkning som 'Billigperiod slutar om 2 timmar' (när aktiv) eller 'Nästa billigperiod slutar kl 14:00' (när inaktiv). Home Assistant visar automatiskt relativ tid för tidsstämpelsensorer."
+            "description": "Total längd för nuvarande eller nästa billigperiod (state i timmar, attribut i minuter)",
+            "long_description": "Visar hur länge billigperioden varar. State använder timmar (decimal) för en läsbar UI; attributet `period_duration_minutes` behåller avrundade minuter för automationer. Aktiv → varaktighet för aktuell period, annars nästa.",
+            "usage_tips": "UI kan visa 1,5 h medan `period_duration_minutes` = 90 för automationer."
+        },
+        "best_price_period_duration": {
+            "description": "Längd på nuvarande/nästa billigperiod",
+            "long_description": "Total längd av nuvarande eller nästa billigperiod. State visas i timmar (t.ex. 1,5 h) för enkel avläsning i UI, medan attributet `period_duration_minutes` ger samma värde i minuter (t.ex. 90) för automationer. Detta värde representerar den **fullständigt planerade längden** av perioden och är konstant under hela perioden, även när återstående tid (remaining_minutes) minskar.",
+            "usage_tips": "Kombinera med remaining_minutes för att beräkna när långvariga enheter ska stoppas: Perioden startade för `period_duration_minutes - remaining_minutes` minuter sedan. Detta attribut stöder energioptimeringsstrategier genom att hjälpa till med att planera högförbruksaktiviteter inom billiga perioder."
         },
         "best_price_remaining_minutes": {
-            "description": "Återstående minuter i nuvarande billigperiod (0 när inaktiv)",
-            "long_description": "Visar hur många minuter som återstår i nuvarande billigperiod. Returnerar 0 när ingen period är aktiv. Uppdateras varje minut. Kontrollera binary_sensor.best_price_period för att se om en period är aktiv.",
-            "usage_tips": "Perfekt för automationer: 'Om remaining_minutes > 0 OCH remaining_minutes < 30, starta tvättmaskin nu'. Värdet 0 gör det enkelt att kontrollera om en period är aktiv (värde > 0) eller inte (värde = 0)."
+            "description": "Tid kvar i nuvarande billigperiod",
+            "long_description": "Visar hur mycket tid som återstår i nuvarande billigperiod. State visas i timmar (t.ex. 0,75 h) för enkel avläsning i instrumentpaneler, medan attributet `remaining_minutes` ger samma tid i minuter (t.ex. 45) för automationsvillkor. **Nedräkningstimer**: Detta värde minskar varje minut under en aktiv period. Returnerar 0 när ingen billigperiod är aktiv. Uppdateras varje minut.",
+            "usage_tips": "För automationer: Använd attribut `remaining_minutes` som 'Om remaining_minutes > 60, starta diskmaskin nu (tillräckligt med tid för att slutföra)' eller 'Om remaining_minutes < 15, avsluta nuvarande cykel snart'. UI visar användarvänliga timmar (t.ex. 1,25 h). Värde 0 indikerar ingen aktiv billigperiod."
         },
         "best_price_progress": {
             "description": "Framsteg genom nuvarande billigperiod (0% när inaktiv)",
-            "long_description": "Visar framsteg genom nuvarande billigperiod som 0-100%. Returnerar 0% när ingen period är aktiv. Uppdateras varje minut. 0% betyder period just startad, 100% betyder den snart slutar.",
-            "usage_tips": "Bra för visuella framstegsstaplar. Använd i automationer: 'Om progress > 0 OCH progress > 75, skicka meddelande att billigperiod snart slutar'. Värde 0 indikerar ingen aktiv period."
+            "long_description": "Visar framsteg genom nuvarande billigperiod som 0-100%. Returnerar 0% när ingen period är aktiv. Uppdateras varje minut. 0% betyder att perioden just startade, 100% betyder att den snart slutar.",
+            "usage_tips": "Perfekt för visuella framstegsindikatorer. Använd i automationer: 'Om progress > 0 OCH progress > 75, skicka avisering om att billigperioden snart slutar'. Värde 0 indikerar ingen aktiv period."
         },
         "best_price_next_start_time": {
-            "description": "När nästa billigperiod startar",
-            "long_description": "Visar när nästa kommande billigperiod startar. Under en aktiv period visar detta starten av NÄSTA period efter den nuvarande. Returnerar 'Okänt' endast när inga framtida perioder är konfigurerade.",
-            "usage_tips": "Alltid användbart för framåtplanering: 'Nästa billigperiod startar om 3 timmar' (oavsett om du är i en period nu eller inte). Kombinera med automationer: 'När nästa starttid är om 10 minuter, skicka meddelande för att förbereda tvättmaskin'."
+            "description": "Total längd för nuvarande eller nästa dyrperiod (state i timmar, attribut i minuter)",
+            "long_description": "Visar hur länge den dyra perioden varar. State använder timmar (decimal) för UI; attributet `period_duration_minutes` behåller avrundade minuter för automationer. Aktiv → varaktighet för aktuell period, annars nästa.",
+            "usage_tips": "UI kan visa 0,75 h medan `period_duration_minutes` = 45 för automationer."
         },
         "best_price_next_in_minutes": {
-            "description": "Minuter tills nästa billigperiod startar (0 vid övergång)",
-            "long_description": "Visar minuter tills nästa billigperiod startar. Under en aktiv period visar detta tiden till perioden EFTER den nuvarande. Returnerar 0 under korta övergångsmoment. Uppdateras varje minut.",
-            "usage_tips": "Perfekt för 'vänta tills billigperiod' automationer: 'Om next_in_minutes > 0 OCH next_in_minutes < 15, vänta innan diskmaskin startas'. Värde > 0 indikerar alltid att en framtida period är planerad."
+            "description": "Tid kvar i nuvarande dyrperiod (state i timmar, attribut i minuter)",
+            "long_description": "Visar hur mycket tid som återstår. State använder timmar (decimal); attributet `remaining_minutes` behåller avrundade minuter för automationer. Returnerar 0 när ingen period är aktiv. Uppdateras varje minut.",
+            "usage_tips": "Använd `remaining_minutes` för trösklar (t.ex. > 60) medan state är lätt att läsa i timmar."
         },
         "peak_price_end_time": {
-            "description": "När nuvarande eller nästa dyrperiod slutar",
-            "long_description": "Visar sluttidsstämpeln för nuvarande dyrperiod när aktiv, eller slutet av nästa period när ingen period är aktiv. Visar alltid en användbar tidsreferens för planering. Returnerar 'Okänt' endast när inga perioder är konfigurerade.",
-            "usage_tips": "Använd detta för att visa 'Dyrperiod slutar om 1 timme' (när aktiv) eller 'Nästa dyrperiod slutar kl 18:00' (när inaktiv). Kombinera med automationer för att återuppta drift efter topp."
+            "description": "Tid tills nästa dyrperiod startar (state i timmar, attribut i minuter)",
+            "long_description": "Visar hur länge tills nästa dyrperiod startar. State använder timmar (decimal); attributet `next_in_minutes` behåller avrundade minuter för automationer. Under en aktiv period visar detta tiden till perioden efter den aktuella. 0 under korta övergångar. Uppdateras varje minut.",
+            "usage_tips": "Använd `next_in_minutes` i automationer (t.ex. < 10) medan state är lätt att läsa i timmar."
+        },
+        "peak_price_period_duration": {
+            "description": "Längd på nuvarande/nästa dyrperiod",
+            "long_description": "Total längd av nuvarande eller nästa dyrperiod. State visas i timmar (t.ex. 1,5 h) för enkel avläsning i UI, medan attributet `period_duration_minutes` ger samma värde i minuter (t.ex. 90) för automationer. Detta värde representerar den **fullständigt planerade längden** av perioden och är konstant under hela perioden, även när återstående tid (remaining_minutes) minskar.",
+            "usage_tips": "Kombinera med remaining_minutes för att beräkna när långvariga enheter ska stoppas: Perioden startade för `period_duration_minutes - remaining_minutes` minuter sedan. Detta attribut stöder energibesparingsstrategier genom att hjälpa till med att planera högförbruksaktiviteter utanför dyra perioder."
         },
         "peak_price_remaining_minutes": {
-            "description": "Återstående minuter i nuvarande dyrperiod (0 när inaktiv)",
-            "long_description": "Visar hur många minuter som återstår i nuvarande dyrperiod. Returnerar 0 när ingen period är aktiv. Uppdateras varje minut. Kontrollera binary_sensor.peak_price_period för att se om en period är aktiv.",
-            "usage_tips": "Använd i automationer: 'Om remaining_minutes > 60, avbryt uppskjuten laddningssession'. Värde 0 gör det enkelt att skilja mellan aktiva (värde > 0) och inaktiva (värde = 0) perioder."
+            "description": "Tid kvar i nuvarande dyrperiod",
+            "long_description": "Visar hur mycket tid som återstår i nuvarande dyrperiod. State visas i timmar (t.ex. 0,75 h) för enkel avläsning i instrumentpaneler, medan attributet `remaining_minutes` ger samma tid i minuter (t.ex. 45) för automationsvillkor. **Nedräkningstimer**: Detta värde minskar varje minut under en aktiv period. Returnerar 0 när ingen dyrperiod är aktiv. Uppdateras varje minut.",
+            "usage_tips": "För automationer: Använd attribut `remaining_minutes` som 'Om remaining_minutes > 60, avbryt uppskjuten laddningssession' eller 'Om remaining_minutes < 15, återuppta normal drift snart'. UI visar användarvänliga timmar (t.ex. 1,0 h). Värde 0 indikerar ingen aktiv dyrperiod."
         },
         "peak_price_progress": {
             "description": "Framsteg genom nuvarande dyrperiod (0% när inaktiv)",
@@ -360,19 +372,9 @@
             "usage_tips": "Alltid användbart för planering: 'Nästa dyrperiod startar om 2 timmar'. Automation: 'När nästa starttid är om 30 minuter, minska värmetemperatur förebyggande'."
         },
         "peak_price_next_in_minutes": {
-            "description": "Minuter tills nästa dyrperiod startar (0 vid övergång)",
-            "long_description": "Visar minuter tills nästa dyrperiod startar. Under en aktiv period visar detta tiden till perioden EFTER den nuvarande. Returnerar 0 under korta övergångsmoment. Uppdateras varje minut.",
-            "usage_tips": "Förebyggande automation: 'Om next_in_minutes > 0 OCH next_in_minutes < 10, slutför nuvarande laddcykel nu innan priserna ökar'."
-        },
-        "best_price_period_duration": {
-            "description": "Total längd på nuvarande eller nästa billigperiod i minuter",
-            "long_description": "Visar den totala längden på billigperioden i minuter. Under en aktiv period visar detta hela längden av nuvarande period. När ingen period är aktiv visar detta längden på nästa kommande period. Exempel: '90 minuter' för en 1,5-timmars period.",
-            "usage_tips": "Kombinera med remaining_minutes för att planera uppgifter: 'Om duration = 120 OCH remaining_minutes > 90, starta tvättmaskin (tillräckligt med tid för att slutföra)'. Användbart för att förstå om perioder är tillräckligt långa för energikrävande uppgifter."
-        },
-        "peak_price_period_duration": {
-            "description": "Total längd på nuvarande eller nästa dyrperiod i minuter",
-            "long_description": "Visar den totala längden på dyrperioden i minuter. Under en aktiv period visar detta hela längden av nuvarande period. När ingen period är aktiv visar detta längden på nästa kommande period. Exempel: '60 minuter' för en 1-timmars period.",
-            "usage_tips": "Använd för att planera energisparåtgärder: 'Om duration > 120, minska värmetemperatur mer aggressivt (lång dyr period)'. Hjälper till att bedöma hur mycket energiförbrukning måste minskas."
+            "description": "Tid till nästa dyrperiod",
+            "long_description": "Visar hur länge till nästa dyrperiod. State visas i timmar (t.ex. 0,5 h) för instrumentpaneler, medan attributet `next_in_minutes` ger minuter (t.ex. 30) för automationsvillkor. Under en aktiv period visar detta tiden till perioden EFTER den nuvarande. Returnerar 0 under korta övergångsmoment. Uppdateras varje minut.",
+            "usage_tips": "För automationer: Använd attribut `next_in_minutes` som 'Om next_in_minutes > 0 OCH next_in_minutes < 10, slutför nuvarande laddcykel nu innan priserna ökar'. Värde > 0 indikerar alltid att en framtida dyrperiod är planerad."
         },
         "home_type": {
             "description": "Bostadstyp (lägenhet, hus osv.)",
@@ -487,6 +489,80 @@
             "usage_tips": "Använd detta för att verifiera att realtidsförbrukningen är tillgänglig. Aktivera meddelanden om detta oväntat ändras till 'av', vilket indikerar potentiella hårdvaru- eller anslutningsproblem."
         }
     },
+    "number": {
+        "best_price_flex_override": {
+            "description": "Maximal procent över daglig minimumpris som intervaller kan ha och fortfarande kvalificera som 'bästa pris'. Rekommenderas: 15-20 med lättnad aktiverad (standard), eller 25-35 utan lättnad. Maximum: 50 (hårt tak för tillförlitlig perioddetektering).",
+            "long_description": "När denna entitet är aktiverad överskriver värdet 'Flexibilitet'-inställningen från alternativ-dialogen för bästa pris-periodberäkningar.",
+            "usage_tips": "Aktivera denna entitet för att dynamiskt justera bästa pris-detektering via automatiseringar, t.ex. högre flexibilitet för kritiska laster eller striktare krav för flexibla apparater."
+        },
+        "best_price_min_distance_override": {
+            "description": "Minsta procentuella avstånd under dagligt genomsnitt. Intervaller måste vara så långt under genomsnittet för att kvalificera som 'bästa pris'. Hjälper att skilja äkta lågprisperioder från genomsnittspriser.",
+            "long_description": "När denna entitet är aktiverad överskriver värdet 'Minimiavstånd'-inställningen från alternativ-dialogen för bästa pris-periodberäkningar.",
+            "usage_tips": "Öka värdet för striktare bästa pris-kriterier. Minska om för få perioder detekteras."
+        },
+        "best_price_min_period_length_override": {
+            "description": "Minsta periodlängd i 15-minuters intervaller. Perioder kortare än detta rapporteras inte. Exempel: 2 = minst 30 minuter.",
+            "long_description": "När denna entitet är aktiverad överskriver värdet 'Minsta periodlängd'-inställningen från alternativ-dialogen för bästa pris-periodberäkningar.",
+            "usage_tips": "Anpassa till typisk apparatkörtid: 2 (30 min) för snabbprogram, 4-8 (1-2 timmar) för normala cykler, 8+ för långa ECO-program."
+        },
+        "best_price_min_periods_override": {
+            "description": "Minsta antal bästa pris-perioder att hitta dagligen. När lättnad är aktiverad kommer systemet automatiskt att justera kriterierna för att uppnå detta antal.",
+            "long_description": "När denna entitet är aktiverad överskriver värdet 'Minsta antal perioder'-inställningen från alternativ-dialogen för bästa pris-periodberäkningar.",
+            "usage_tips": "Ställ in detta på antalet tidskritiska uppgifter du har dagligen. Exempel: 2 för två tvattmaskinskörningar."
+        },
+        "best_price_relaxation_attempts_override": {
+            "description": "Antal försök att gradvis lätta på kriterierna för att uppnå minsta periodantal. Varje försök ökar flexibiliteten med 3 procent. Vid 0 används endast baskriterier.",
+            "long_description": "När denna entitet är aktiverad överskriver värdet 'Lättnadsförsök'-inställningen från alternativ-dialogen för bästa pris-periodberäkningar.",
+            "usage_tips": "Högre värden gör perioddetektering mer adaptiv för dagar med stabila priser. Ställ in på 0 för att tvinga strikta kriterier utan lättnad."
+        },
+        "best_price_gap_count_override": {
+            "description": "Maximalt antal dyrare intervaller som kan tillåtas mellan billiga intervaller medan de fortfarande räknas som en sammanhängande period. Vid 0 måste billiga intervaller vara påföljande.",
+            "long_description": "När denna entitet är aktiverad överskriver värdet 'Glaptolerans'-inställningen från alternativ-dialogen för bästa pris-periodberäkningar.",
+            "usage_tips": "Öka detta för apparater med variabel last (t.ex. värmepumpar) som kan tolerera korta dyrare intervaller. Ställ in på 0 för kontinuerligt billiga perioder."
+        },
+        "peak_price_flex_override": {
+            "description": "Maximal procent under daglig maximumpris som intervaller kan ha och fortfarande kvalificera som 'topppris'. Samma rekommendationer som för bästa pris-flexibilitet.",
+            "long_description": "När denna entitet är aktiverad överskriver värdet 'Flexibilitet'-inställningen från alternativ-dialogen för topppris-periodberäkningar.",
+            "usage_tips": "Använd detta för att justera topppris-tröskeln vid körtid för automatiseringar som undviker förbrukning under dyra timmar."
+        },
+        "peak_price_min_distance_override": {
+            "description": "Minsta procentuella avstånd över dagligt genomsnitt. Intervaller måste vara så långt över genomsnittet för att kvalificera som 'topppris'.",
+            "long_description": "När denna entitet är aktiverad överskriver värdet 'Minimiavstånd'-inställningen från alternativ-dialogen för topppris-periodberäkningar.",
+            "usage_tips": "Öka värdet för att endast fånga extrema pristoppar. Minska för att inkludera fler högpristider."
+        },
+        "peak_price_min_period_length_override": {
+            "description": "Minsta periodlängd i 15-minuters intervaller för topppriser. Kortare pristoppar rapporteras inte som perioder.",
+            "long_description": "När denna entitet är aktiverad överskriver värdet 'Minsta periodlängd'-inställningen från alternativ-dialogen för topppris-periodberäkningar.",
+            "usage_tips": "Kortare värden fångar korta pristoppar. Längre värden fokuserar på ihållande högprisperioder."
+        },
+        "peak_price_min_periods_override": {
+            "description": "Minsta antal topppris-perioder att hitta dagligen.",
+            "long_description": "När denna entitet är aktiverad överskriver värdet 'Minsta antal perioder'-inställningen från alternativ-dialogen för topppris-periodberäkningar.",
+            "usage_tips": "Ställ in detta baserat på hur många högprisperioder du vill fånga per dag för automatiseringar."
+        },
+        "peak_price_relaxation_attempts_override": {
+            "description": "Antal försök att lätta på kriterierna för att uppnå minsta antal topppris-perioder.",
+            "long_description": "När denna entitet är aktiverad överskriver värdet 'Lättnadsförsök'-inställningen från alternativ-dialogen för topppris-periodberäkningar.",
+            "usage_tips": "Öka detta om inga perioder hittas på dagar med stabila priser. Ställ in på 0 för att tvinga strikta kriterier."
+        },
+        "peak_price_gap_count_override": {
+            "description": "Maximalt antal billigare intervaller som kan tillåtas mellan dyra intervaller medan de fortfarande räknas som en topppris-period.",
+            "long_description": "När denna entitet är aktiverad överskriver värdet 'Glaptolerans'-inställningen från alternativ-dialogen för topppris-periodberäkningar.",
+            "usage_tips": "Högre värden fångar längre högprisperioder även med korta prisdipp. Ställ in på 0 för strikt sammanhängande topppriser."
+        }
+    },
+    "switch": {
+        "best_price_enable_relaxation_override": {
+            "description": "När aktiverad lättas kriterierna automatiskt för att uppnå minsta periodantal. När inaktiverad rapporteras endast perioder som uppfyller strikta kriterier (möjligen noll perioder på dagar med stabila priser).",
+            "long_description": "När denna entitet är aktiverad överskriver värdet 'Uppnå minimiantal'-inställningen från alternativ-dialogen för bästa pris-periodberäkningar.",
+            "usage_tips": "Aktivera detta för garanterade dagliga automatiseringsmöjligheter. Inaktivera om du endast vill ha riktigt billiga perioder, även om det innebär inga perioder vissa dagar."
+        },
+        "peak_price_enable_relaxation_override": {
+            "description": "När aktiverad lättas kriterierna automatiskt för att uppnå minsta periodantal. När inaktiverad rapporteras endast äkta pristoppar.",
+            "long_description": "När denna entitet är aktiverad överskriver värdet 'Uppnå minimiantal'-inställningen från alternativ-dialogen för topppris-periodberäkningar.",
+            "usage_tips": "Aktivera detta för konsekventa topppris-varningar. Inaktivera för att endast fånga extrema pristoppar."
+        }
+    },
     "home_types": {
         "APARTMENT": "Lägenhet",
         "ROWHOUSE": "Radhus",

custom_components/tibber_prices/diagnostics.py

@@ -70,7 +70,7 @@ async def async_get_config_entry_diagnostics(
         },
         "cache_status": {
             "user_data_cached": coordinator._cached_user_data is not None,  # noqa: SLF001
-            "price_data_cached": coordinator._cached_price_data is not None,  # noqa: SLF001
+            "has_price_data": coordinator.data is not None and "priceInfo" in (coordinator.data or {}),
             "transformer_cache_valid": coordinator._data_transformer._cached_transformed_data is not None,  # noqa: SLF001
             "period_calculator_cache_valid": coordinator._period_calculator._cached_periods is not None,  # noqa: SLF001
         },

custom_components/tibber_prices/entity.py

@@ -118,8 +118,10 @@ class TibberPricesEntity(CoordinatorEntity[TibberPricesDataUpdateCoordinator]):
             return "Tibber Home", None
 
         try:
-            address1 = str(self.coordinator.data.get("address", {}).get("address1", ""))
-            city = str(self.coordinator.data.get("address", {}).get("city", ""))
+            # Use 'or {}' to handle None values (API may return None during maintenance)
+            address = self.coordinator.data.get("address") or {}
+            address1 = str(address.get("address1", ""))
+            city = str(address.get("city", ""))
             app_nickname = str(self.coordinator.data.get("appNickname", ""))
             home_type = str(self.coordinator.data.get("type", ""))
 

custom_components/tibber_prices/entity_utils/icons.py

@@ -85,19 +85,25 @@ def get_dynamic_icon(
 
 
 def get_trend_icon(key: str, value: Any) -> str | None:
-    """Get icon for trend sensors."""
+    """Get icon for trend sensors using 5-level trend scale."""
     # Handle next_price_trend_change TIMESTAMP sensor differently
     # (icon based on attributes, not value which is a timestamp)
     if key == "next_price_trend_change":
         return None  # Will be handled by sensor's icon property using attributes
 
-    if not key.startswith("price_trend_") or not isinstance(value, str):
+    if not key.startswith("price_trend_") and key != "current_price_trend":
         return None
 
+    if not isinstance(value, str):
+        return None
+
+    # 5-level trend icons: strongly uses double arrows, normal uses single
     trend_icons = {
-        "rising": "mdi:trending-up",
-        "falling": "mdi:trending-down",
-        "stable": "mdi:trending-neutral",
+        "strongly_rising": "mdi:chevron-double-up",  # Strong upward movement
+        "rising": "mdi:trending-up",  # Normal upward trend
+        "stable": "mdi:trending-neutral",  # No significant change
+        "falling": "mdi:trending-down",  # Normal downward trend
+        "strongly_falling": "mdi:chevron-double-down",  # Strong downward movement
     }
     return trend_icons.get(value)
 
@@ -197,7 +203,7 @@ def get_price_sensor_icon(
         return None
 
     # Only current price sensors get dynamic icons
-    if key == "current_interval_price":
+    if key in ("current_interval_price", "current_interval_price_base"):
         level = get_price_level_for_icon(coordinator_data, interval_offset=0, time=time)
         if level:
             return PRICE_LEVEL_CASH_ICON_MAPPING.get(level.upper())

custom_components/tibber_prices/icons.json

@@ -16,7 +16,15 @@
             }
         },
         "get_apexcharts_yaml": {
-            "service": "mdi:chart-line"
+            "service": "mdi:chart-line",
+            "sections": {
+                "entry_id": "mdi:identifier",
+                "day": "mdi:calendar-range",
+                "level_type": "mdi:format-list-bulleted-type",
+                "resolution": "mdi:timer-sand",
+                "highlight_best_price": "mdi:battery-charging-low",
+                "highlight_peak_price": "mdi:battery-alert"
+            }
         },
         "refresh_user_data": {
             "service": "mdi:refresh"

custom_components/tibber_prices/interval_pool/cache.py

@@ -4,10 +4,15 @@ from __future__ import annotations
 
 import logging
 from datetime import datetime, timedelta
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 from homeassistant.util import dt as dt_utils
 
+if TYPE_CHECKING:
+    from custom_components.tibber_prices.coordinator.time_service import (
+        TibberPricesTimeService,
+    )
+
 _LOGGER = logging.getLogger(__name__)
 _LOGGER_DETAILS = logging.getLogger(__name__ + ".details")
 
@@ -37,9 +42,10 @@ class TibberPricesIntervalPoolFetchGroupCache:
         Protected: 2025-11-23 00:00 to 2025-11-27 00:00
     """
 
-    def __init__(self) -> None:
-        """Initialize empty fetch group cache."""
+    def __init__(self, *, time_service: TibberPricesTimeService | None = None) -> None:
+        """Initialize empty fetch group cache with optional TimeService."""
         self._fetch_groups: list[dict[str, Any]] = []
+        self._time_service = time_service
 
         # Protected range cache (invalidated daily)
         self._protected_range_cache: tuple[str, str] | None = None
@@ -93,6 +99,11 @@ class TibberPricesIntervalPoolFetchGroupCache:
         Protected range: day-before-yesterday 00:00 to day-after-tomorrow 00:00.
         This range shifts daily automatically.
 
+        Time Machine Support:
+            If time_service was provided at init, uses time_service.now() for
+            "today" calculation. This protects the correct date range when
+            simulating a different date.
+
         Returns:
             Tuple of (start_iso, end_iso) for protected range.
             Start is inclusive, end is exclusive.
@@ -102,10 +113,11 @@ class TibberPricesIntervalPoolFetchGroupCache:
             Protected days: 2025-11-23, 2025-11-24, 2025-11-25, 2025-11-26
 
         """
-        # Check cache validity (invalidate daily)
-        now = dt_utils.now()
+        # Use TimeService if available (Time Machine support), else real time
+        now = self._time_service.now() if self._time_service else dt_utils.now()
         today_date_str = now.date().isoformat()
 
+        # Check cache validity (invalidate daily)
         if self._protected_range_cache_date == today_date_str and self._protected_range_cache:
             return self._protected_range_cache
 

custom_components/tibber_prices/interval_pool/fetcher.py

@@ -1,4 +1,4 @@
-"""Interval fetcher - gap detection and API coordination for interval pool."""
+"""Interval fetcher - coverage check and API coordination for interval pool."""
 
 from __future__ import annotations
 
@@ -38,7 +38,7 @@ TIME_TOLERANCE_MINUTES = 1
 
 
 class TibberPricesIntervalPoolFetcher:
-    """Fetch missing intervals from API based on gap detection."""
+    """Fetch missing intervals from API based on coverage check."""
 
     def __init__(
         self,
@@ -62,14 +62,14 @@ class TibberPricesIntervalPoolFetcher:
         self._index = index
         self._home_id = home_id
 
-    def detect_gaps(
+    def check_coverage(
         self,
         cached_intervals: list[dict[str, Any]],
         start_time_iso: str,
         end_time_iso: str,
     ) -> list[tuple[str, str]]:
         """
-        Detect missing time ranges that need to be fetched.
+        Check cache coverage and find missing time ranges.
 
         This method minimizes API calls by:
         1. Finding all gaps in cached intervals
@@ -130,7 +130,7 @@ class TibberPricesIntervalPoolFetcher:
         if time_diff_before_first > TIME_TOLERANCE_SECONDS:
             missing_ranges.append((start_time_iso, sorted_intervals[0]["startsAt"]))
             _LOGGER_DETAILS.debug(
-                "Gap before first cached interval: %s to %s (%.1f seconds)",
+                "Missing range before first cached interval: %s to %s (%.1f seconds)",
                 start_time_iso,
                 sorted_intervals[0]["startsAt"],
                 time_diff_before_first,
@@ -163,7 +163,7 @@ class TibberPricesIntervalPoolFetcher:
                 current_interval_end = current_dt + timedelta(minutes=expected_interval_minutes)
                 missing_ranges.append((current_interval_end.isoformat(), next_start))
                 _LOGGER_DETAILS.debug(
-                    "Gap between cached intervals: %s (ends at %s) to %s (%.1f min gap, expected %d min)",
+                    "Missing range between cached intervals: %s (ends at %s) to %s (%.1f min, expected %d min)",
                     current_start,
                     current_interval_end.isoformat(),
                     next_start,
@@ -190,7 +190,7 @@ class TibberPricesIntervalPoolFetcher:
             # Missing range starts AFTER the last cached interval ends
             missing_ranges.append((last_interval_end_dt.isoformat(), end_time_iso))
             _LOGGER_DETAILS.debug(
-                "Gap after last cached interval: %s (ends at %s) to %s (%.1f seconds, need >= %d)",
+                "Missing range after last cached interval: %s (ends at %s) to %s (%.1f seconds, need >= %d)",
                 sorted_intervals[-1]["startsAt"],
                 last_interval_end_dt.isoformat(),
                 end_time_iso,
@@ -200,7 +200,7 @@ class TibberPricesIntervalPoolFetcher:
 
         if not missing_ranges:
             _LOGGER.debug(
-                "No gaps detected - all intervals cached for range %s to %s",
+                "Full coverage - all intervals cached for range %s to %s",
                 start_time_iso,
                 end_time_iso,
             )
@@ -285,7 +285,7 @@ class TibberPricesIntervalPoolFetcher:
 
         for idx, (missing_start_iso, missing_end_iso) in enumerate(missing_ranges, start=1):
             _LOGGER_DETAILS.debug(
-                "API call %d/%d for home %s: fetching range %s to %s",
+                "Fetching from Tibber API (%d/%d) for home %s: range %s to %s",
                 idx,
                 len(missing_ranges),
                 self._home_id,
@@ -309,10 +309,9 @@ class TibberPricesIntervalPoolFetcher:
             all_fetched_intervals.append(fetched_intervals)
 
             _LOGGER_DETAILS.debug(
-                "Fetched %d intervals from API for home %s (fetch time: %s)",
+                "Received %d intervals from Tibber API for home %s",
                 len(fetched_intervals),
                 self._home_id,
-                fetch_time_iso,
             )
 
             # Notify callback if provided (for immediate caching)

custom_components/tibber_prices/interval_pool/garbage_collector.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import logging
+from datetime import datetime
 from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
@@ -17,6 +18,13 @@ _LOGGER_DETAILS = logging.getLogger(__name__ + ".details")
 MAX_CACHE_SIZE = 960
 
 
+def _normalize_starts_at(starts_at: datetime | str) -> str:
+    """Normalize startsAt to consistent format (YYYY-MM-DDTHH:MM:SS)."""
+    if isinstance(starts_at, datetime):
+        return starts_at.strftime("%Y-%m-%dT%H:%M:%S")
+    return starts_at[:19]
+
+
 class TibberPricesIntervalPoolGarbageCollector:
     """
     Manages cache eviction and dead interval cleanup.
@@ -77,6 +85,15 @@ class TibberPricesIntervalPoolGarbageCollector:
                 self._home_id,
             )
 
+        # Phase 1.5: Remove empty fetch groups (after dead interval cleanup)
+        empty_removed = self._remove_empty_groups(fetch_groups)
+        if empty_removed > 0:
+            _LOGGER_DETAILS.debug(
+                "GC removed %d empty fetch groups (home %s)",
+                empty_removed,
+                self._home_id,
+            )
+
         # Phase 2: Count total intervals after cleanup
         total_intervals = self._cache.count_total_intervals()
 
@@ -94,7 +111,7 @@ class TibberPricesIntervalPoolGarbageCollector:
 
         if not evicted_indices:
             # All intervals are protected, cannot evict
-            return dead_count > 0
+            return dead_count > 0 or empty_removed > 0
 
         # Phase 4: Rebuild cache and index
         new_fetch_groups = [group for idx, group in enumerate(fetch_groups) if idx not in evicted_indices]
@@ -110,6 +127,35 @@ class TibberPricesIntervalPoolGarbageCollector:
 
         return True
 
+    def _remove_empty_groups(self, fetch_groups: list[dict[str, Any]]) -> int:
+        """
+        Remove fetch groups with no intervals.
+
+        After dead interval cleanup, some groups may be completely empty.
+        These should be removed to prevent memory accumulation.
+
+        Note: This modifies the cache's internal list in-place and rebuilds
+        the index to maintain consistency.
+
+        Args:
+            fetch_groups: List of fetch groups (will be modified).
+
+        Returns:
+            Number of empty groups removed.
+
+        """
+        # Find non-empty groups
+        non_empty_groups = [group for group in fetch_groups if group["intervals"]]
+        removed_count = len(fetch_groups) - len(non_empty_groups)
+
+        if removed_count > 0:
+            # Update cache with filtered list
+            self._cache.set_fetch_groups(non_empty_groups)
+            # Rebuild index since group indices changed
+            self._index.rebuild(non_empty_groups)
+
+        return removed_count
+
     def _cleanup_dead_intervals(self, fetch_groups: list[dict[str, Any]]) -> int:
         """
         Remove dead intervals from all fetch groups.
@@ -135,7 +181,7 @@ class TibberPricesIntervalPoolGarbageCollector:
             living_intervals = []
 
             for interval_idx, interval in enumerate(old_intervals):
-                starts_at_normalized = interval["startsAt"][:19]
+                starts_at_normalized = _normalize_starts_at(interval["startsAt"])
                 index_entry = self._index.get(starts_at_normalized)
 
                 if index_entry is not None:

custom_components/tibber_prices/interval_pool/index.py

@@ -93,6 +93,28 @@ class TibberPricesIntervalPoolTimestampIndex:
         starts_at_normalized = self._normalize_timestamp(timestamp)
         self._index.pop(starts_at_normalized, None)
 
+    def update_batch(
+        self,
+        updates: list[tuple[str, int, int]],
+    ) -> None:
+        """
+        Update multiple index entries efficiently in a single operation.
+
+        More efficient than calling remove() + add() for each entry,
+        as it avoids repeated dict operations and normalization.
+
+        Args:
+            updates: List of (timestamp, fetch_group_index, interval_index) tuples.
+                    Timestamps will be normalized automatically.
+
+        """
+        for timestamp, fetch_group_index, interval_index in updates:
+            starts_at_normalized = self._normalize_timestamp(timestamp)
+            self._index[starts_at_normalized] = {
+                "fetch_group_index": fetch_group_index,
+                "interval_index": interval_index,
+            }
+
     def clear(self) -> None:
         """Clear entire index."""
         self._index.clear()

custom_components/tibber_prices/interval_pool/manager.py

@@ -3,21 +3,26 @@
 from __future__ import annotations
 
 import asyncio
+import contextlib
 import logging
 from datetime import datetime, timedelta
 from typing import TYPE_CHECKING, Any
+from zoneinfo import ZoneInfo
 
 from custom_components.tibber_prices.api.exceptions import TibberPricesApiClientError
 from homeassistant.util import dt as dt_utils
 
 from .cache import TibberPricesIntervalPoolFetchGroupCache
 from .fetcher import TibberPricesIntervalPoolFetcher
-from .garbage_collector import TibberPricesIntervalPoolGarbageCollector
+from .garbage_collector import MAX_CACHE_SIZE, TibberPricesIntervalPoolGarbageCollector
 from .index import TibberPricesIntervalPoolTimestampIndex
 from .storage import async_save_pool_state
 
 if TYPE_CHECKING:
     from custom_components.tibber_prices.api.client import TibberPricesApiClient
+    from custom_components.tibber_prices.coordinator.time_service import (
+        TibberPricesTimeService,
+    )
 
 _LOGGER = logging.getLogger(__name__)
 _LOGGER_DETAILS = logging.getLogger(__name__ + ".details")
@@ -30,6 +35,13 @@ INTERVAL_QUARTER_HOURLY = 15
 DEBOUNCE_DELAY_SECONDS = 3.0
 
 
+def _normalize_starts_at(starts_at: datetime | str) -> str:
+    """Normalize startsAt to consistent format (YYYY-MM-DDTHH:MM:SS)."""
+    if isinstance(starts_at, datetime):
+        return starts_at.strftime("%Y-%m-%dT%H:%M:%S")
+    return starts_at[:19]
+
+
 class TibberPricesIntervalPool:
     """
     High-performance interval cache manager for a single Tibber home.
@@ -70,6 +82,7 @@ class TibberPricesIntervalPool:
         api: TibberPricesApiClient,
         hass: Any | None = None,
         entry_id: str | None = None,
+        time_service: TibberPricesTimeService | None = None,
     ) -> None:
         """
         Initialize interval pool manager.
@@ -79,12 +92,15 @@ class TibberPricesIntervalPool:
             api: API client for fetching intervals.
             hass: HomeAssistant instance for auto-save (optional).
             entry_id: Config entry ID for auto-save (optional).
+            time_service: TimeService for time-travel support (optional).
+                         If None, uses real time (dt_utils.now()).
 
         """
         self._home_id = home_id
+        self._time_service = time_service
 
         # Initialize components with dependency injection
-        self._cache = TibberPricesIntervalPoolFetchGroupCache()
+        self._cache = TibberPricesIntervalPoolFetchGroupCache(time_service=time_service)
         self._index = TibberPricesIntervalPoolTimestampIndex()
         self._gc = TibberPricesIntervalPoolGarbageCollector(self._cache, self._index, home_id)
         self._fetcher = TibberPricesIntervalPoolFetcher(api, self._cache, self._index, home_id)
@@ -102,7 +118,7 @@ class TibberPricesIntervalPool:
         user_data: dict[str, Any],
         start_time: datetime,
         end_time: datetime,
-    ) -> list[dict[str, Any]]:
+    ) -> tuple[list[dict[str, Any]], bool]:
         """
         Get price intervals for time range (cached + fetch missing).
 
@@ -123,8 +139,10 @@ class TibberPricesIntervalPool:
             end_time: End of range (exclusive, timezone-aware).
 
         Returns:
-            List of price interval dicts, sorted by startsAt.
+            Tuple of (intervals, api_called):
+            - intervals: List of price interval dicts, sorted by startsAt.
                         Contains ALL intervals in requested range (cached + fetched).
+            - api_called: True if API was called to fetch missing data, False if all from cache.
 
         Raises:
             TibberPricesApiClientError: If API calls fail or validation errors.
@@ -153,19 +171,18 @@ class TibberPricesIntervalPool:
         # Get cached intervals using index
         cached_intervals = self._get_cached_intervals(start_time_iso, end_time_iso)
 
-        # Detect missing ranges
-        missing_ranges = self._fetcher.detect_gaps(cached_intervals, start_time_iso, end_time_iso)
+        # Check coverage - find ranges not in cache
+        missing_ranges = self._fetcher.check_coverage(cached_intervals, start_time_iso, end_time_iso)
 
         if missing_ranges:
             _LOGGER_DETAILS.debug(
-                "Detected %d missing range(s) for home %s - will make %d API call(s)",
-                len(missing_ranges),
+                "Coverage check for home %s: %d range(s) missing - will fetch from API",
                 self._home_id,
                 len(missing_ranges),
             )
         else:
             _LOGGER_DETAILS.debug(
-                "All intervals available in cache for home %s - zero API calls needed",
+                "Coverage check for home %s: full coverage in cache - no API calls needed",
                 self._home_id,
             )
 
@@ -185,17 +202,240 @@ class TibberPricesIntervalPool:
         # This ensures we return exactly what user requested, filtering out extra intervals
         final_result = self._get_cached_intervals(start_time_iso, end_time_iso)
 
+        # Track if API was called (True if any missing ranges were fetched)
+        api_called = len(missing_ranges) > 0
+
         _LOGGER_DETAILS.debug(
-            "Interval pool returning %d intervals for home %s "
-            "(initially %d cached, %d API calls made, final %d after re-reading cache)",
+            "Pool returning %d intervals for home %s (from cache: %d, fetched from API: %d ranges, api_called=%s)",
             len(final_result),
             self._home_id,
             len(cached_intervals),
             len(missing_ranges),
-            len(final_result),
+            api_called,
         )
 
-        return final_result
+        return final_result, api_called
+
+    async def get_sensor_data(
+        self,
+        api_client: TibberPricesApiClient,
+        user_data: dict[str, Any],
+        home_timezone: str | None = None,
+        *,
+        include_tomorrow: bool = True,
+    ) -> tuple[list[dict[str, Any]], bool]:
+        """
+        Get price intervals for sensor data (day-before-yesterday to end-of-tomorrow).
+
+        Convenience method for coordinator/sensors that need the standard 4-day window:
+        - Day before yesterday (for trailing 24h averages at midnight)
+        - Yesterday (for trailing 24h averages)
+        - Today (current prices)
+        - Tomorrow (if available in cache)
+
+        IMPORTANT - Two distinct behaviors:
+        1. API FETCH: Controlled by include_tomorrow flag
+           - include_tomorrow=False → Only fetch up to end of today (prevents API spam before 13:00)
+           - include_tomorrow=True → Fetch including tomorrow data
+        2. RETURN DATA: Always returns full protected range (including tomorrow if cached)
+           - This ensures cached tomorrow data is used even if include_tomorrow=False
+
+        The separation prevents the following bug:
+        - If include_tomorrow affected both fetch AND return, cached tomorrow data
+          would be lost when include_tomorrow=False, causing infinite refresh loops.
+
+        Args:
+            api_client: TibberPricesApiClient instance for API calls.
+            user_data: User data dict containing home metadata.
+            home_timezone: Optional timezone string (e.g., "Europe/Berlin").
+            include_tomorrow: If True, fetch tomorrow's data from API. If False,
+                             only fetch up to end of today. Default True.
+                             DOES NOT affect returned data - always returns full range.
+
+        Returns:
+            Tuple of (intervals, api_called):
+            - intervals: List of price interval dicts for the 4-day window (including any cached
+                        tomorrow data), sorted by startsAt.
+            - api_called: True if API was called to fetch missing data, False if all from cache.
+
+        """
+        # Determine timezone
+        tz_str = home_timezone
+        if not tz_str:
+            tz_str = self._extract_timezone_from_user_data(user_data)
+
+        # Calculate range in home's timezone
+        tz = ZoneInfo(tz_str) if tz_str else None
+        now = self._time_service.now() if self._time_service else dt_utils.now()
+        now_local = now.astimezone(tz) if tz else now
+
+        # Day before yesterday 00:00 (start) - same for both fetch and return
+        day_before_yesterday = (now_local - timedelta(days=2)).replace(hour=0, minute=0, second=0, microsecond=0)
+
+        # End of tomorrow (full protected range) - used for RETURN data
+        end_of_tomorrow = (now_local + timedelta(days=2)).replace(hour=0, minute=0, second=0, microsecond=0)
+
+        # API fetch range depends on include_tomorrow flag
+        if include_tomorrow:
+            fetch_end_time = end_of_tomorrow
+            fetch_desc = "end-of-tomorrow"
+        else:
+            # Only fetch up to end of today (prevents API spam before 13:00)
+            fetch_end_time = (now_local + timedelta(days=1)).replace(hour=0, minute=0, second=0, microsecond=0)
+            fetch_desc = "end-of-today"
+
+        _LOGGER.debug(
+            "Sensor data request for home %s: fetch %s to %s (%s), return up to %s",
+            self._home_id,
+            day_before_yesterday.isoformat(),
+            fetch_end_time.isoformat(),
+            fetch_desc,
+            end_of_tomorrow.isoformat(),
+        )
+
+        # Fetch data (may be partial if include_tomorrow=False)
+        _intervals, api_called = await self.get_intervals(
+            api_client=api_client,
+            user_data=user_data,
+            start_time=day_before_yesterday,
+            end_time=fetch_end_time,
+        )
+
+        # Return FULL protected range (including any cached tomorrow data)
+        # This ensures cached tomorrow data is available even when include_tomorrow=False
+        final_intervals = self._get_cached_intervals(
+            day_before_yesterday.isoformat(),
+            end_of_tomorrow.isoformat(),
+        )
+
+        return final_intervals, api_called
+
+    def get_pool_stats(self) -> dict[str, Any]:
+        """
+        Get statistics about the interval pool.
+
+        Returns comprehensive statistics for diagnostic sensors, separated into:
+        - Sensor intervals (protected range: day-before-yesterday to tomorrow)
+        - Cache statistics (entire pool including service-requested data)
+
+        Protected Range:
+            The protected range covers 4 days at 15-min resolution = 384 intervals.
+            These intervals are never evicted by garbage collection.
+
+        Cache Fill Level:
+            Shows how full the cache is relative to MAX_CACHE_SIZE (960).
+            100% is not bad - just means we're using the available space.
+            GC will evict oldest non-protected intervals when limit is reached.
+
+        Returns:
+            Dict with sensor intervals, cache stats, and timestamps.
+
+        """
+        fetch_groups = self._cache.get_fetch_groups()
+
+        # === Sensor Intervals (Protected Range) ===
+        sensor_stats = self._get_sensor_interval_stats()
+
+        # === Cache Statistics (Entire Pool) ===
+        cache_total = self._index.count()
+        cache_limit = MAX_CACHE_SIZE
+        cache_fill_percent = round((cache_total / cache_limit) * 100, 1) if cache_limit > 0 else 0
+        cache_extra = max(0, cache_total - sensor_stats["count"])  # Intervals outside protected range
+
+        # === Timestamps ===
+        # Last sensor fetch (for protected range data)
+        last_sensor_fetch: str | None = None
+        oldest_interval: str | None = None
+        newest_interval: str | None = None
+
+        if fetch_groups:
+            # Find newest fetch group (most recent API call)
+            newest_group = max(fetch_groups, key=lambda g: g["fetched_at"])
+            last_sensor_fetch = newest_group["fetched_at"].isoformat()
+
+            # Find oldest and newest intervals across all fetch groups
+            all_timestamps = list(self._index.get_raw_index().keys())
+            if all_timestamps:
+                oldest_interval = min(all_timestamps)
+                newest_interval = max(all_timestamps)
+
+        return {
+            # Sensor intervals (protected range)
+            "sensor_intervals_count": sensor_stats["count"],
+            "sensor_intervals_expected": sensor_stats["expected"],
+            "sensor_intervals_has_gaps": sensor_stats["has_gaps"],
+            # Cache statistics
+            "cache_intervals_total": cache_total,
+            "cache_intervals_limit": cache_limit,
+            "cache_fill_percent": cache_fill_percent,
+            "cache_intervals_extra": cache_extra,
+            # Timestamps
+            "last_sensor_fetch": last_sensor_fetch,
+            "cache_oldest_interval": oldest_interval,
+            "cache_newest_interval": newest_interval,
+            # Fetch groups (API calls)
+            "fetch_groups_count": len(fetch_groups),
+        }
+
+    def _get_sensor_interval_stats(self) -> dict[str, Any]:
+        """
+        Get statistics for sensor intervals (protected range).
+
+        Protected range: day-before-yesterday 00:00 to day-after-tomorrow 00:00.
+        Expected: 4 days * 24 hours * 4 intervals = 384 intervals.
+
+        Returns:
+            Dict with count, expected, and has_gaps.
+
+        """
+        start_iso, end_iso = self._cache.get_protected_range()
+        start_dt = datetime.fromisoformat(start_iso)
+        end_dt = datetime.fromisoformat(end_iso)
+
+        # Count expected intervals (15-min resolution)
+        expected_count = int((end_dt - start_dt).total_seconds() / (15 * 60))
+
+        # Count actual intervals in range
+        actual_count = 0
+        current_dt = start_dt
+
+        while current_dt < end_dt:
+            current_key = current_dt.isoformat()[:19]
+            if self._index.contains(current_key):
+                actual_count += 1
+            current_dt += timedelta(minutes=15)
+
+        return {
+            "count": actual_count,
+            "expected": expected_count,
+            "has_gaps": actual_count < expected_count,
+        }
+
+    def _has_gaps_in_protected_range(self) -> bool:
+        """
+        Check if there are gaps in the protected date range.
+
+        Delegates to _get_sensor_interval_stats() for consistency.
+
+        Returns:
+            True if any gaps exist, False if protected range is complete.
+
+        """
+        return self._get_sensor_interval_stats()["has_gaps"]
+
+    def _extract_timezone_from_user_data(self, user_data: dict[str, Any]) -> str | None:
+        """Extract timezone for this home from user_data."""
+        if not user_data:
+            return None
+
+        viewer = user_data.get("viewer", {})
+        homes = viewer.get("homes", [])
+
+        for home in homes:
+            if home.get("id") == self._home_id:
+                return home.get("timeZone")
+
+        return None
 
     def _get_cached_intervals(
         self,
@@ -207,30 +447,47 @@ class TibberPricesIntervalPool:
 
         Uses timestamp_index for O(1) lookups per timestamp.
 
+        IMPORTANT: Returns shallow copies of interval dicts to prevent external
+        mutations (e.g., by parse_all_timestamps()) from affecting cached data.
+        The Pool cache must remain immutable to ensure consistent behavior.
+
         Args:
             start_time_iso: ISO timestamp string (inclusive).
             end_time_iso: ISO timestamp string (exclusive).
 
         Returns:
             List of cached interval dicts in time range (may be empty or incomplete).
-            Sorted by startsAt timestamp.
+            Sorted by startsAt timestamp. Each dict is a shallow copy.
 
         """
         # Parse query range once
         start_time_dt = datetime.fromisoformat(start_time_iso)
         end_time_dt = datetime.fromisoformat(end_time_iso)
 
+        # CRITICAL: Use NAIVE local timestamps for iteration.
+        #
+        # Index keys are naive local timestamps (timezone stripped via [:19]).
+        # When start and end span a DST transition, they have different UTC offsets
+        # (e.g., start=+01:00 CET, end=+02:00 CEST). Using fixed-offset datetimes
+        # from fromisoformat() causes the loop to compare UTC values for the end
+        # boundary, ending 1 hour early on spring-forward days (or 1 hour late on
+        # fall-back days).
+        #
+        # By iterating in naive local time, we match the index key format exactly
+        # and the end boundary comparison works correctly regardless of DST.
+        current_naive = start_time_dt.replace(tzinfo=None)
+        end_naive = end_time_dt.replace(tzinfo=None)
+
         # Use index to find intervals: iterate through expected timestamps
         result = []
-        current_dt = start_time_dt
 
         # Determine interval step (15 min post-2025-10-01, 60 min pre)
-        resolution_change_dt = datetime(2025, 10, 1, tzinfo=start_time_dt.tzinfo)
-        interval_minutes = INTERVAL_QUARTER_HOURLY if current_dt >= resolution_change_dt else INTERVAL_HOURLY
+        resolution_change_naive = datetime(2025, 10, 1)  # noqa: DTZ001
+        interval_minutes = INTERVAL_QUARTER_HOURLY if current_naive >= resolution_change_naive else INTERVAL_HOURLY
 
-        while current_dt < end_time_dt:
+        while current_naive < end_naive:
             # Check if this timestamp exists in index (O(1) lookup)
-            current_dt_key = current_dt.isoformat()[:19]
+            current_dt_key = current_naive.isoformat()[:19]
             location = self._index.get(current_dt_key)
 
             if location is not None:
@@ -238,19 +495,21 @@ class TibberPricesIntervalPool:
                 fetch_groups = self._cache.get_fetch_groups()
                 fetch_group = fetch_groups[location["fetch_group_index"]]
                 interval = fetch_group["intervals"][location["interval_index"]]
-                result.append(interval)
+                # CRITICAL: Return shallow copy to prevent external mutations
+                # (e.g., parse_all_timestamps() converts startsAt to datetime in-place)
+                result.append(dict(interval))
 
             # Move to next expected interval
-            current_dt += timedelta(minutes=interval_minutes)
+            current_naive += timedelta(minutes=interval_minutes)
 
             # Handle resolution change boundary
-            if interval_minutes == INTERVAL_HOURLY and current_dt >= resolution_change_dt:
+            if interval_minutes == INTERVAL_HOURLY and current_naive >= resolution_change_naive:
                 interval_minutes = INTERVAL_QUARTER_HOURLY
 
         _LOGGER_DETAILS.debug(
-            "Cache lookup for home %s: found %d intervals in range %s to %s",
-            self._home_id,
+            "Retrieved %d intervals from cache for home %s (range %s to %s)",
             len(result),
+            self._home_id,
             start_time_iso,
             end_time_iso,
         )
@@ -288,7 +547,7 @@ class TibberPricesIntervalPool:
         intervals_to_touch = []
 
         for interval in intervals:
-            starts_at_normalized = interval["startsAt"][:19]
+            starts_at_normalized = _normalize_starts_at(interval["startsAt"])
             if not self._index.contains(starts_at_normalized):
                 new_intervals.append(interval)
             else:
@@ -320,7 +579,7 @@ class TibberPricesIntervalPool:
 
         # Update timestamp index for all new intervals
         for interval_index, interval in enumerate(new_intervals):
-            starts_at_normalized = interval["startsAt"][:19]
+            starts_at_normalized = _normalize_starts_at(interval["startsAt"])
             self._index.add(interval, fetch_group_index, interval_index)
 
         _LOGGER_DETAILS.debug(
@@ -372,13 +631,13 @@ class TibberPricesIntervalPool:
         # Add touch group to cache
         touch_group_index = self._cache.add_fetch_group(touch_intervals, fetch_time_dt)
 
-        # Update index to point to new fetch group
-        for interval_index, (starts_at_normalized, _) in enumerate(intervals_to_touch):
-            # Remove old index entry
-            self._index.remove(starts_at_normalized)
-            # Add new index entry pointing to touch group
-            interval = touch_intervals[interval_index]
-            self._index.add(interval, touch_group_index, interval_index)
+        # Update index to point to new fetch group using batch operation
+        # This is more efficient than individual remove+add calls
+        index_updates = [
+            (starts_at_normalized, touch_group_index, interval_index)
+            for interval_index, (starts_at_normalized, _) in enumerate(intervals_to_touch)
+        ]
+        self._index.update_batch(index_updates)
 
         _LOGGER.debug(
             "Touched %d cached intervals for home %s (moved to fetch group %d, fetched at %s)",
@@ -419,6 +678,36 @@ class TibberPricesIntervalPool:
             _LOGGER.debug("Auto-save timer cancelled (expected - new changes arrived)")
             raise
 
+    async def async_shutdown(self) -> None:
+        """
+        Clean shutdown - cancel pending background tasks.
+
+        Should be called when the config entry is unloaded to prevent
+        orphaned tasks and ensure clean resource cleanup.
+
+        """
+        _LOGGER.debug("Shutting down interval pool for home %s", self._home_id)
+
+        # Cancel debounce task if running
+        if self._save_debounce_task is not None and not self._save_debounce_task.done():
+            self._save_debounce_task.cancel()
+            with contextlib.suppress(asyncio.CancelledError):
+                await self._save_debounce_task
+            _LOGGER.debug("Cancelled pending auto-save task")
+
+        # Cancel any other background tasks
+        if self._background_tasks:
+            for task in list(self._background_tasks):
+                if not task.done():
+                    task.cancel()
+            # Wait for all tasks to complete cancellation
+            if self._background_tasks:
+                await asyncio.gather(*self._background_tasks, return_exceptions=True)
+            _LOGGER.debug("Cancelled %d background tasks", len(self._background_tasks))
+            self._background_tasks.clear()
+
+        _LOGGER.debug("Interval pool shutdown complete for home %s", self._home_id)
+
     async def _auto_save_pool_state(self) -> None:
         """Auto-save pool state to storage with lock protection."""
         if self._hass is None or self._entry_id is None:
@@ -451,7 +740,7 @@ class TibberPricesIntervalPool:
             living_intervals = []
 
             for interval_idx, interval in enumerate(fetch_group["intervals"]):
-                starts_at_normalized = interval["startsAt"][:19]
+                starts_at_normalized = _normalize_starts_at(interval["startsAt"])
 
                 # Check if interval is still referenced in index
                 location = self._index.get(starts_at_normalized)
@@ -486,6 +775,7 @@ class TibberPricesIntervalPool:
         api: TibberPricesApiClient,
         hass: Any | None = None,
         entry_id: str | None = None,
+        time_service: TibberPricesTimeService | None = None,
     ) -> TibberPricesIntervalPool | None:
         """
         Restore interval pool manager from storage.
@@ -498,6 +788,7 @@ class TibberPricesIntervalPool:
             api: API client for fetching intervals.
             hass: HomeAssistant instance for auto-save (optional).
             entry_id: Config entry ID for auto-save (optional).
+            time_service: TimeService for time-travel support (optional).
 
         Returns:
             Restored TibberPricesIntervalPool instance, or None if format unknown/corrupted.
@@ -517,7 +808,7 @@ class TibberPricesIntervalPool:
         home_id = data["home_id"]
 
         # Create manager with home_id from storage
-        manager = cls(home_id=home_id, api=api, hass=hass, entry_id=entry_id)
+        manager = cls(home_id=home_id, api=api, hass=hass, entry_id=entry_id, time_service=time_service)
 
         # Restore fetch groups to cache
         for serialized_group in data.get("fetch_groups", []):

custom_components/tibber_prices/manifest.json

@@ -11,5 +11,5 @@
   "requirements": [
     "aiofiles>=23.2.1"
   ],
-  "version": "0.22.0"
+  "version": "0.27.0"
 }

custom_components/tibber_prices/number/__init__.py

@@ -0,0 +1,39 @@
+"""
+Number platform for Tibber Prices integration.
+
+Provides configurable number entities for runtime overrides of Best Price
+and Peak Price period calculation settings. These entities allow automation
+of configuration parameters without using the options flow.
+
+When enabled, these entities take precedence over the options flow settings.
+When disabled (default), the options flow settings are used.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from .core import TibberPricesConfigNumber
+from .definitions import NUMBER_ENTITY_DESCRIPTIONS
+
+if TYPE_CHECKING:
+    from custom_components.tibber_prices.data import TibberPricesConfigEntry
+    from homeassistant.core import HomeAssistant
+    from homeassistant.helpers.entity_platform import AddEntitiesCallback
+
+
+async def async_setup_entry(
+    _hass: HomeAssistant,
+    entry: TibberPricesConfigEntry,
+    async_add_entities: AddEntitiesCallback,
+) -> None:
+    """Set up Tibber Prices number entities based on a config entry."""
+    coordinator = entry.runtime_data.coordinator
+
+    async_add_entities(
+        TibberPricesConfigNumber(
+            coordinator=coordinator,
+            entity_description=entity_description,
+        )
+        for entity_description in NUMBER_ENTITY_DESCRIPTIONS
+    )

custom_components/tibber_prices/number/core.py

@@ -0,0 +1,242 @@
+"""
+Number entity implementation for Tibber Prices configuration overrides.
+
+These entities allow runtime configuration of period calculation settings.
+When a config entity is enabled, its value takes precedence over the
+options flow setting for period calculations.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any
+
+from custom_components.tibber_prices.const import (
+    DOMAIN,
+    get_home_type_translation,
+    get_translation,
+)
+from homeassistant.components.number import NumberEntity, RestoreNumber
+from homeassistant.core import callback
+from homeassistant.helpers.device_registry import DeviceEntryType, DeviceInfo
+
+if TYPE_CHECKING:
+    from custom_components.tibber_prices.coordinator import (
+        TibberPricesDataUpdateCoordinator,
+    )
+
+    from .definitions import TibberPricesNumberEntityDescription
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class TibberPricesConfigNumber(RestoreNumber, NumberEntity):
+    """
+    A number entity for configuring period calculation settings at runtime.
+
+    When this entity is enabled, its value overrides the corresponding
+    options flow setting. When disabled (default), the options flow
+    setting is used for period calculations.
+
+    The entity restores its value after Home Assistant restart.
+    """
+
+    _attr_has_entity_name = True
+    entity_description: TibberPricesNumberEntityDescription
+
+    # Exclude all attributes from recorder history - config entities don't need history
+    _unrecorded_attributes = frozenset(
+        {
+            "description",
+            "long_description",
+            "usage_tips",
+            "friendly_name",
+            "icon",
+            "unit_of_measurement",
+            "mode",
+            "min",
+            "max",
+            "step",
+        }
+    )
+
+    def __init__(
+        self,
+        coordinator: TibberPricesDataUpdateCoordinator,
+        entity_description: TibberPricesNumberEntityDescription,
+    ) -> None:
+        """Initialize the config number entity."""
+        self.coordinator = coordinator
+        self.entity_description = entity_description
+
+        # Set unique ID
+        self._attr_unique_id = (
+            f"{coordinator.config_entry.unique_id or coordinator.config_entry.entry_id}_{entity_description.key}"
+        )
+
+        # Initialize with None - will be set in async_added_to_hass
+        self._attr_native_value: float | None = None
+
+        # Setup device info
+        self._setup_device_info()
+
+    def _setup_device_info(self) -> None:
+        """Set up device information."""
+        home_name, home_id, home_type = self._get_device_info()
+        language = self.coordinator.hass.config.language or "en"
+        translated_model = get_home_type_translation(home_type, language) if home_type else "Unknown"
+
+        self._attr_device_info = DeviceInfo(
+            entry_type=DeviceEntryType.SERVICE,
+            identifiers={
+                (
+                    DOMAIN,
+                    self.coordinator.config_entry.unique_id or self.coordinator.config_entry.entry_id,
+                )
+            },
+            name=home_name,
+            manufacturer="Tibber",
+            model=translated_model,
+            serial_number=home_id if home_id else None,
+            configuration_url="https://developer.tibber.com/explorer",
+        )
+
+    def _get_device_info(self) -> tuple[str, str | None, str | None]:
+        """Get device name, ID and type."""
+        user_profile = self.coordinator.get_user_profile()
+        is_subentry = bool(self.coordinator.config_entry.data.get("home_id"))
+        home_id = self.coordinator.config_entry.unique_id
+        home_type = None
+
+        if is_subentry:
+            home_data = self.coordinator.config_entry.data.get("home_data", {})
+            home_id = self.coordinator.config_entry.data.get("home_id")
+            address = home_data.get("address", {})
+            address1 = address.get("address1", "")
+            city = address.get("city", "")
+            app_nickname = home_data.get("appNickname", "")
+            home_type = home_data.get("type", "")
+
+            if app_nickname and app_nickname.strip():
+                home_name = app_nickname.strip()
+            elif address1:
+                home_name = address1
+                if city:
+                    home_name = f"{home_name}, {city}"
+            else:
+                home_name = f"Tibber Home {home_id[:8]}" if home_id else "Tibber Home"
+        elif user_profile:
+            home_name = user_profile.get("name") or "Tibber Home"
+        else:
+            home_name = "Tibber Home"
+
+        return home_name, home_id, home_type
+
+    async def async_added_to_hass(self) -> None:
+        """Handle entity which was added to Home Assistant."""
+        await super().async_added_to_hass()
+
+        # Try to restore previous state
+        last_number_data = await self.async_get_last_number_data()
+        if last_number_data is not None and last_number_data.native_value is not None:
+            self._attr_native_value = last_number_data.native_value
+            _LOGGER.debug(
+                "Restored %s value: %s",
+                self.entity_description.key,
+                self._attr_native_value,
+            )
+        else:
+            # Initialize with value from options flow (or default)
+            self._attr_native_value = self._get_value_from_options()
+            _LOGGER.debug(
+                "Initialized %s from options: %s",
+                self.entity_description.key,
+                self._attr_native_value,
+            )
+
+        # Register override with coordinator if entity is enabled
+        # This happens during add, so check entity registry
+        await self._sync_override_state()
+
+    async def async_will_remove_from_hass(self) -> None:
+        """Handle entity removal from Home Assistant."""
+        # Remove override when entity is removed
+        self.coordinator.remove_config_override(
+            self.entity_description.config_key,
+            self.entity_description.config_section,
+        )
+        await super().async_will_remove_from_hass()
+
+    def _get_value_from_options(self) -> float:
+        """Get the current value from options flow or default."""
+        options = self.coordinator.config_entry.options
+        section = options.get(self.entity_description.config_section, {})
+        value = section.get(
+            self.entity_description.config_key,
+            self.entity_description.default_value,
+        )
+        return float(value)
+
+    async def _sync_override_state(self) -> None:
+        """Sync the override state with the coordinator based on entity enabled state."""
+        # Check if entity is enabled in registry
+        if self.registry_entry is not None and not self.registry_entry.disabled:
+            # Entity is enabled - register the override
+            if self._attr_native_value is not None:
+                self.coordinator.set_config_override(
+                    self.entity_description.config_key,
+                    self.entity_description.config_section,
+                    self._attr_native_value,
+                )
+        else:
+            # Entity is disabled - remove override
+            self.coordinator.remove_config_override(
+                self.entity_description.config_key,
+                self.entity_description.config_section,
+            )
+
+    async def async_set_native_value(self, value: float) -> None:
+        """Update the current value and trigger recalculation."""
+        self._attr_native_value = value
+
+        # Update the coordinator's runtime override
+        self.coordinator.set_config_override(
+            self.entity_description.config_key,
+            self.entity_description.config_section,
+            value,
+        )
+
+        # Trigger period recalculation (same path as options update)
+        await self.coordinator.async_handle_config_override_update()
+
+        _LOGGER.debug(
+            "Updated %s to %s, triggered period recalculation",
+            self.entity_description.key,
+            value,
+        )
+
+    @property
+    def extra_state_attributes(self) -> dict[str, Any] | None:
+        """Return entity state attributes with description."""
+        language = self.coordinator.hass.config.language or "en"
+
+        # Try to get description from custom translations
+        # Custom translations use direct path: number.{key}.description
+        translation_path = [
+            "number",
+            self.entity_description.translation_key or self.entity_description.key,
+            "description",
+        ]
+        description = get_translation(translation_path, language)
+
+        attrs: dict[str, Any] = {}
+        if description:
+            attrs["description"] = description
+
+        return attrs if attrs else None
+
+    @callback
+    def async_registry_entry_updated(self) -> None:
+        """Handle entity registry update (enabled/disabled state change)."""
+        # This is called when the entity is enabled/disabled in the UI
+        self.hass.async_create_task(self._sync_override_state())

custom_components/tibber_prices/number/definitions.py

@@ -0,0 +1,250 @@
+"""
+Number entity definitions for Tibber Prices configuration overrides.
+
+These number entities allow runtime configuration of Best Price and Peak Price
+period calculation settings. They are disabled by default - users can enable
+individual entities to override specific settings at runtime.
+
+When enabled, the entity value takes precedence over the options flow setting.
+When disabled (default), the options flow setting is used.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from homeassistant.components.number import (
+    NumberEntityDescription,
+    NumberMode,
+)
+from homeassistant.const import PERCENTAGE, EntityCategory
+
+
+@dataclass(frozen=True, kw_only=True)
+class TibberPricesNumberEntityDescription(NumberEntityDescription):
+    """Describes a Tibber Prices number entity for config overrides."""
+
+    # The config key this entity overrides (matches CONF_* constants)
+    config_key: str
+    # The section in options where this setting is stored (e.g., "flexibility_settings")
+    config_section: str
+    # Whether this is for best_price (False) or peak_price (True)
+    is_peak_price: bool = False
+    # Default value from const.py
+    default_value: float | int = 0
+
+
+# ============================================================================
+# BEST PRICE PERIOD CONFIGURATION OVERRIDES
+# ============================================================================
+
+BEST_PRICE_NUMBER_ENTITIES = (
+    TibberPricesNumberEntityDescription(
+        key="best_price_flex_override",
+        translation_key="best_price_flex_override",
+        name="Best Price: Flexibility",
+        icon="mdi:arrow-down-bold-circle",
+        entity_category=EntityCategory.CONFIG,
+        entity_registry_enabled_default=False,
+        native_min_value=0,
+        native_max_value=50,
+        native_step=1,
+        native_unit_of_measurement=PERCENTAGE,
+        mode=NumberMode.SLIDER,
+        config_key="best_price_flex",
+        config_section="flexibility_settings",
+        is_peak_price=False,
+        default_value=15,  # DEFAULT_BEST_PRICE_FLEX
+    ),
+    TibberPricesNumberEntityDescription(
+        key="best_price_min_distance_override",
+        translation_key="best_price_min_distance_override",
+        name="Best Price: Minimum Distance",
+        icon="mdi:arrow-down-bold-circle",
+        entity_category=EntityCategory.CONFIG,
+        entity_registry_enabled_default=False,
+        native_min_value=-50,
+        native_max_value=0,
+        native_step=1,
+        native_unit_of_measurement=PERCENTAGE,
+        mode=NumberMode.SLIDER,
+        config_key="best_price_min_distance_from_avg",
+        config_section="flexibility_settings",
+        is_peak_price=False,
+        default_value=-5,  # DEFAULT_BEST_PRICE_MIN_DISTANCE_FROM_AVG
+    ),
+    TibberPricesNumberEntityDescription(
+        key="best_price_min_period_length_override",
+        translation_key="best_price_min_period_length_override",
+        name="Best Price: Minimum Period Length",
+        icon="mdi:arrow-down-bold-circle",
+        entity_category=EntityCategory.CONFIG,
+        entity_registry_enabled_default=False,
+        native_min_value=15,
+        native_max_value=180,
+        native_step=15,
+        native_unit_of_measurement="min",
+        mode=NumberMode.SLIDER,
+        config_key="best_price_min_period_length",
+        config_section="period_settings",
+        is_peak_price=False,
+        default_value=60,  # DEFAULT_BEST_PRICE_MIN_PERIOD_LENGTH
+    ),
+    TibberPricesNumberEntityDescription(
+        key="best_price_min_periods_override",
+        translation_key="best_price_min_periods_override",
+        name="Best Price: Minimum Periods",
+        icon="mdi:arrow-down-bold-circle",
+        entity_category=EntityCategory.CONFIG,
+        entity_registry_enabled_default=False,
+        native_min_value=1,
+        native_max_value=10,
+        native_step=1,
+        mode=NumberMode.SLIDER,
+        config_key="min_periods_best",
+        config_section="relaxation_and_target_periods",
+        is_peak_price=False,
+        default_value=2,  # DEFAULT_MIN_PERIODS_BEST
+    ),
+    TibberPricesNumberEntityDescription(
+        key="best_price_relaxation_attempts_override",
+        translation_key="best_price_relaxation_attempts_override",
+        name="Best Price: Relaxation Attempts",
+        icon="mdi:arrow-down-bold-circle",
+        entity_category=EntityCategory.CONFIG,
+        entity_registry_enabled_default=False,
+        native_min_value=1,
+        native_max_value=12,
+        native_step=1,
+        mode=NumberMode.SLIDER,
+        config_key="relaxation_attempts_best",
+        config_section="relaxation_and_target_periods",
+        is_peak_price=False,
+        default_value=11,  # DEFAULT_RELAXATION_ATTEMPTS_BEST
+    ),
+    TibberPricesNumberEntityDescription(
+        key="best_price_gap_count_override",
+        translation_key="best_price_gap_count_override",
+        name="Best Price: Gap Tolerance",
+        icon="mdi:arrow-down-bold-circle",
+        entity_category=EntityCategory.CONFIG,
+        entity_registry_enabled_default=False,
+        native_min_value=0,
+        native_max_value=8,
+        native_step=1,
+        mode=NumberMode.SLIDER,
+        config_key="best_price_max_level_gap_count",
+        config_section="period_settings",
+        is_peak_price=False,
+        default_value=1,  # DEFAULT_BEST_PRICE_MAX_LEVEL_GAP_COUNT
+    ),
+)
+
+# ============================================================================
+# PEAK PRICE PERIOD CONFIGURATION OVERRIDES
+# ============================================================================
+
+PEAK_PRICE_NUMBER_ENTITIES = (
+    TibberPricesNumberEntityDescription(
+        key="peak_price_flex_override",
+        translation_key="peak_price_flex_override",
+        name="Peak Price: Flexibility",
+        icon="mdi:arrow-up-bold-circle",
+        entity_category=EntityCategory.CONFIG,
+        entity_registry_enabled_default=False,
+        native_min_value=-50,
+        native_max_value=0,
+        native_step=1,
+        native_unit_of_measurement=PERCENTAGE,
+        mode=NumberMode.SLIDER,
+        config_key="peak_price_flex",
+        config_section="flexibility_settings",
+        is_peak_price=True,
+        default_value=-20,  # DEFAULT_PEAK_PRICE_FLEX
+    ),
+    TibberPricesNumberEntityDescription(
+        key="peak_price_min_distance_override",
+        translation_key="peak_price_min_distance_override",
+        name="Peak Price: Minimum Distance",
+        icon="mdi:arrow-up-bold-circle",
+        entity_category=EntityCategory.CONFIG,
+        entity_registry_enabled_default=False,
+        native_min_value=0,
+        native_max_value=50,
+        native_step=1,
+        native_unit_of_measurement=PERCENTAGE,
+        mode=NumberMode.SLIDER,
+        config_key="peak_price_min_distance_from_avg",
+        config_section="flexibility_settings",
+        is_peak_price=True,
+        default_value=5,  # DEFAULT_PEAK_PRICE_MIN_DISTANCE_FROM_AVG
+    ),
+    TibberPricesNumberEntityDescription(
+        key="peak_price_min_period_length_override",
+        translation_key="peak_price_min_period_length_override",
+        name="Peak Price: Minimum Period Length",
+        icon="mdi:arrow-up-bold-circle",
+        entity_category=EntityCategory.CONFIG,
+        entity_registry_enabled_default=False,
+        native_min_value=15,
+        native_max_value=180,
+        native_step=15,
+        native_unit_of_measurement="min",
+        mode=NumberMode.SLIDER,
+        config_key="peak_price_min_period_length",
+        config_section="period_settings",
+        is_peak_price=True,
+        default_value=30,  # DEFAULT_PEAK_PRICE_MIN_PERIOD_LENGTH
+    ),
+    TibberPricesNumberEntityDescription(
+        key="peak_price_min_periods_override",
+        translation_key="peak_price_min_periods_override",
+        name="Peak Price: Minimum Periods",
+        icon="mdi:arrow-up-bold-circle",
+        entity_category=EntityCategory.CONFIG,
+        entity_registry_enabled_default=False,
+        native_min_value=1,
+        native_max_value=10,
+        native_step=1,
+        mode=NumberMode.SLIDER,
+        config_key="min_periods_peak",
+        config_section="relaxation_and_target_periods",
+        is_peak_price=True,
+        default_value=2,  # DEFAULT_MIN_PERIODS_PEAK
+    ),
+    TibberPricesNumberEntityDescription(
+        key="peak_price_relaxation_attempts_override",
+        translation_key="peak_price_relaxation_attempts_override",
+        name="Peak Price: Relaxation Attempts",
+        icon="mdi:arrow-up-bold-circle",
+        entity_category=EntityCategory.CONFIG,
+        entity_registry_enabled_default=False,
+        native_min_value=1,
+        native_max_value=12,
+        native_step=1,
+        mode=NumberMode.SLIDER,
+        config_key="relaxation_attempts_peak",
+        config_section="relaxation_and_target_periods",
+        is_peak_price=True,
+        default_value=11,  # DEFAULT_RELAXATION_ATTEMPTS_PEAK
+    ),
+    TibberPricesNumberEntityDescription(
+        key="peak_price_gap_count_override",
+        translation_key="peak_price_gap_count_override",
+        name="Peak Price: Gap Tolerance",
+        icon="mdi:arrow-up-bold-circle",
+        entity_category=EntityCategory.CONFIG,
+        entity_registry_enabled_default=False,
+        native_min_value=0,
+        native_max_value=8,
+        native_step=1,
+        mode=NumberMode.SLIDER,
+        config_key="peak_price_max_level_gap_count",
+        config_section="period_settings",
+        is_peak_price=True,
+        default_value=1,  # DEFAULT_PEAK_PRICE_MAX_LEVEL_GAP_COUNT
+    ),
+)
+
+# All number entity descriptions combined
+NUMBER_ENTITY_DESCRIPTIONS = BEST_PRICE_NUMBER_ENTITIES + PEAK_PRICE_NUMBER_ENTITIES

custom_components/tibber_prices/sensor/attributes/helpers.py

@@ -4,11 +4,6 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-from custom_components.tibber_prices.const import (
-    CONF_AVERAGE_SENSOR_DISPLAY,
-    DEFAULT_AVERAGE_SENSOR_DISPLAY,
-)
-
 if TYPE_CHECKING:
     from custom_components.tibber_prices.data import TibberPricesConfigEntry
 
@@ -18,35 +13,29 @@ def add_alternate_average_attribute(
     cached_data: dict,
     base_key: str,
     *,
-    config_entry: TibberPricesConfigEntry,
+    config_entry: TibberPricesConfigEntry,  # noqa: ARG001
 ) -> None:
     """
-    Add the alternate average value (mean or median) as attribute.
+    Add both average values (mean and median) as attributes.
 
-    If user selected "median" as state display, adds "price_mean" as attribute.
-    If user selected "mean" as state display, adds "price_median" as attribute.
+    This ensures automations work consistently regardless of which value
+    is displayed in the state. Both values are always available as attributes.
+
+    Note: To avoid duplicate recording, the value used as state should be
+    excluded from recorder via dynamic _unrecorded_attributes in sensor core.
 
     Args:
         attributes: Dictionary to add attribute to
         cached_data: Cached calculation data containing mean/median values
         base_key: Base key for cached values (e.g., "average_price_today", "rolling_hour_0")
-        config_entry: Config entry for user preferences
+        config_entry: Config entry for user preferences (used to determine which value is in state)
 
     """
-    # Get user preference for which value to display in state
-    display_mode = config_entry.options.get(
-        CONF_AVERAGE_SENSOR_DISPLAY,
-        DEFAULT_AVERAGE_SENSOR_DISPLAY,
-    )
-
-    # Add the alternate value as attribute
-    if display_mode == "median":
-        # State shows median → add mean as attribute
+    # Always add both mean and median values as attributes
     mean_value = cached_data.get(f"{base_key}_mean")
     if mean_value is not None:
         attributes["price_mean"] = mean_value
-    else:
-        # State shows mean → add median as attribute
+
     median_value = cached_data.get(f"{base_key}_median")
     if median_value is not None:
         attributes["price_median"] = median_value

custom_components/tibber_prices/sensor/attributes/interval.py

@@ -23,6 +23,72 @@ from .helpers import add_alternate_average_attribute
 from .metadata import get_current_interval_data
 
 
+def _get_interval_data_for_attributes(
+    key: str,
+    coordinator: TibberPricesDataUpdateCoordinator,
+    attributes: dict,
+    *,
+    time: TibberPricesTimeService,
+) -> dict | None:
+    """
+    Get interval data and set timestamp based on sensor type.
+
+    Refactored to reduce branch complexity in main function.
+
+    Args:
+        key: The sensor entity key
+        coordinator: The data update coordinator
+        attributes: Attributes dict to update with timestamp if needed
+        time: TibberPricesTimeService instance
+
+    Returns:
+        Interval data if found, None otherwise
+
+    """
+    now = time.now()
+
+    # Current/next price sensors - override timestamp with interval's startsAt
+    next_sensors = ["next_interval_price", "next_interval_price_level", "next_interval_price_rating"]
+    prev_sensors = ["previous_interval_price", "previous_interval_price_level", "previous_interval_price_rating"]
+    next_hour = ["next_hour_average_price", "next_hour_price_level", "next_hour_price_rating"]
+    curr_interval = ["current_interval_price", "current_interval_price_base"]
+    curr_hour = ["current_hour_average_price", "current_hour_price_level", "current_hour_price_rating"]
+
+    if key in next_sensors:
+        target_time = time.get_next_interval_start()
+        interval_data = find_price_data_for_interval(coordinator.data, target_time, time=time)
+        if interval_data:
+            attributes["timestamp"] = interval_data["startsAt"]
+        return interval_data
+
+    if key in prev_sensors:
+        target_time = time.get_interval_offset_time(-1)
+        interval_data = find_price_data_for_interval(coordinator.data, target_time, time=time)
+        if interval_data:
+            attributes["timestamp"] = interval_data["startsAt"]
+        return interval_data
+
+    if key in next_hour:
+        target_time = now + timedelta(hours=1)
+        interval_data = find_price_data_for_interval(coordinator.data, target_time, time=time)
+        if interval_data:
+            attributes["timestamp"] = interval_data["startsAt"]
+        return interval_data
+
+    # Current interval sensors (both variants)
+    if key in curr_interval:
+        interval_data = get_current_interval_data(coordinator, time=time)
+        if interval_data and "startsAt" in interval_data:
+            attributes["timestamp"] = interval_data["startsAt"]
+        return interval_data
+
+    # Current hour sensors - keep default timestamp
+    if key in curr_hour:
+        return get_current_interval_data(coordinator, time=time)
+
+    return None
+
+
 def add_current_interval_price_attributes(  # noqa: PLR0913
     attributes: dict,
     key: str,
@@ -46,62 +112,16 @@ def add_current_interval_price_attributes(  # noqa: PLR0913
         config_entry: Config entry for user preferences
 
     """
-    now = time.now()
-
-    # Determine which interval to use based on sensor type
-    next_interval_sensors = [
-        "next_interval_price",
-        "next_interval_price_level",
-        "next_interval_price_rating",
-    ]
-    previous_interval_sensors = [
-        "previous_interval_price",
-        "previous_interval_price_level",
-        "previous_interval_price_rating",
-    ]
-    next_hour_sensors = [
-        "next_hour_average_price",
-        "next_hour_price_level",
-        "next_hour_price_rating",
-    ]
-    current_hour_sensors = [
-        "current_hour_average_price",
-        "current_hour_price_level",
-        "current_hour_price_rating",
-    ]
-
-    # Set interval data based on sensor type
-    # For sensors showing data from OTHER intervals (next/previous), override timestamp with that interval's startsAt
-    # For current interval sensors, keep the default platform timestamp (calculation time)
-    interval_data = None
-    if key in next_interval_sensors:
-        target_time = time.get_next_interval_start()
-        interval_data = find_price_data_for_interval(coordinator.data, target_time, time=time)
-        # Override timestamp with the NEXT interval's startsAt (when that interval starts)
-        if interval_data:
-            attributes["timestamp"] = interval_data["startsAt"]
-    elif key in previous_interval_sensors:
-        target_time = time.get_interval_offset_time(-1)
-        interval_data = find_price_data_for_interval(coordinator.data, target_time, time=time)
-        # Override timestamp with the PREVIOUS interval's startsAt
-        if interval_data:
-            attributes["timestamp"] = interval_data["startsAt"]
-    elif key in next_hour_sensors:
-        target_time = now + timedelta(hours=1)
-        interval_data = find_price_data_for_interval(coordinator.data, target_time, time=time)
-        # Override timestamp with the center of the next rolling hour window
-        if interval_data:
-            attributes["timestamp"] = interval_data["startsAt"]
-    elif key in current_hour_sensors:
-        current_interval_data = get_current_interval_data(coordinator, time=time)
-        # Keep default timestamp (when calculation was made) for current hour sensors
-    else:
-        current_interval_data = get_current_interval_data(coordinator, time=time)
-        interval_data = current_interval_data  # Use current_interval_data as interval_data for current_interval_price
-        # Keep default timestamp (current calculation time) for current interval sensors
+    # Get interval data and handle timestamp overrides
+    interval_data = _get_interval_data_for_attributes(key, coordinator, attributes, time=time)
 
     # Add icon_color for price sensors (based on their price level)
-    if key in ["current_interval_price", "next_interval_price", "previous_interval_price"]:
+    if key in [
+        "current_interval_price",
+        "current_interval_price_base",
+        "next_interval_price",
+        "previous_interval_price",
+    ]:
         # For interval-based price sensors, get level from interval_data
         if interval_data and "level" in interval_data:
             level = interval_data["level"]

custom_components/tibber_prices/sensor/attributes/lifecycle.py

@@ -1,4 +1,24 @@
-"""Attribute builders for lifecycle diagnostic sensor."""
+"""
+Attribute builders for lifecycle diagnostic sensor.
+
+This sensor uses event-based updates with state-change filtering to minimize
+recorder entries. Only attributes that are relevant to the lifecycle STATE
+are included here - attributes that change independently of state belong
+in a separate sensor or diagnostics.
+
+Included attributes (update only on state change):
+- tomorrow_available: Whether tomorrow's price data is available
+- next_api_poll: When the next API poll will occur (builds user trust)
+- updates_today: Number of API calls made today
+- last_turnover: When the last midnight turnover occurred
+- last_error: Details of the last error (if any)
+
+Pool statistics (sensor_intervals_count, cache_fill_percent, etc.) are
+intentionally NOT included here because they change independently of
+the lifecycle state. With state-change filtering, these would become
+stale. Pool statistics are available via diagnostics or could be
+exposed as a separate sensor if needed.
+"""
 
 from __future__ import annotations
 
@@ -13,11 +33,6 @@ if TYPE_CHECKING:
     )
 
 
-# Constants for cache age formatting
-MINUTES_PER_HOUR = 60
-MINUTES_PER_DAY = 1440  # 24 * 60
-
-
 def build_lifecycle_attributes(
     coordinator: TibberPricesDataUpdateCoordinator,
     lifecycle_calculator: TibberPricesLifecycleCalculator,
@@ -25,7 +40,11 @@ def build_lifecycle_attributes(
     """
     Build attributes for data_lifecycle_status sensor.
 
-    Shows comprehensive cache status, data availability, and update timing.
+    Event-based updates with state-change filtering - attributes only update
+    when the lifecycle STATE changes (fresh→cached, cached→turnover_pending, etc.).
+
+    Only includes attributes that are directly relevant to the lifecycle state.
+    Pool statistics are intentionally excluded to avoid stale data.
 
     Returns:
         Dict with lifecycle attributes
@@ -33,57 +52,31 @@ def build_lifecycle_attributes(
     """
     attributes: dict[str, Any] = {}
 
-    # Cache Status (formatted for readability)
-    cache_age = lifecycle_calculator.get_cache_age_minutes()
-    if cache_age is not None:
-        # Format cache age with units for better readability
-        if cache_age < MINUTES_PER_HOUR:
-            attributes["cache_age"] = f"{cache_age} min"
-        elif cache_age < MINUTES_PER_DAY:  # Less than 24 hours
-            hours = cache_age // MINUTES_PER_HOUR
-            minutes = cache_age % MINUTES_PER_HOUR
-            attributes["cache_age"] = f"{hours}h {minutes}min" if minutes > 0 else f"{hours}h"
-        else:  # 24+ hours
-            days = cache_age // MINUTES_PER_DAY
-            hours = (cache_age % MINUTES_PER_DAY) // MINUTES_PER_HOUR
-            attributes["cache_age"] = f"{days}d {hours}h" if hours > 0 else f"{days}d"
+    # === Tomorrow Data Status ===
+    # Critical for understanding lifecycle state transitions
+    attributes["tomorrow_available"] = lifecycle_calculator.has_tomorrow_data()
 
-        # Keep raw value for automations
-        attributes["cache_age_minutes"] = cache_age
-
-    cache_validity = lifecycle_calculator.get_cache_validity_status()
-    attributes["cache_validity"] = cache_validity
-
-    # Use single "last_update" field instead of duplicating as "last_api_fetch" and "last_cache_update"
-    if coordinator._last_price_update:  # noqa: SLF001 - Internal state access for diagnostic display
-        attributes["last_update"] = coordinator._last_price_update.isoformat()  # noqa: SLF001
-
-    # Data Availability & Completeness
-    data_completeness = lifecycle_calculator.get_data_completeness_status()
-    attributes["data_completeness"] = data_completeness
-
-    attributes["yesterday_available"] = lifecycle_calculator.is_data_available(-1)
-    attributes["today_available"] = lifecycle_calculator.is_data_available(0)
-    attributes["tomorrow_available"] = lifecycle_calculator.is_data_available(1)
-    attributes["tomorrow_expected_after"] = "13:00"
-
-    # Next Actions (only show if meaningful)
+    # === Next API Poll Time ===
+    # Builds user trust: shows when the integration will check for tomorrow data
+    # - Before 13:00: Shows today 13:00 (when tomorrow-search begins)
+    # - After 13:00 without tomorrow data: Shows next Timer #1 execution (active polling)
+    # - After 13:00 with tomorrow data: Shows tomorrow 13:00 (predictive)
     next_poll = lifecycle_calculator.get_next_api_poll_time()
-    if next_poll:  # None means data is complete, no more polls needed
+    if next_poll:
         attributes["next_api_poll"] = next_poll.isoformat()
 
-    next_midnight = lifecycle_calculator.get_next_midnight_turnover_time()
-    attributes["next_midnight_turnover"] = next_midnight.isoformat()
-
-    # Update Statistics
+    # === Update Statistics ===
+    # Shows API activity - resets at midnight with turnover
     api_calls = lifecycle_calculator.get_api_calls_today()
     attributes["updates_today"] = api_calls
 
-    # Last Turnover Time (from midnight handler)
-    if coordinator._midnight_handler.last_turnover_time:  # noqa: SLF001 - Internal state access for diagnostic display
+    # === Midnight Turnover Info ===
+    # When was the last successful data rotation
+    if coordinator._midnight_handler.last_turnover_time:  # noqa: SLF001
         attributes["last_turnover"] = coordinator._midnight_handler.last_turnover_time.isoformat()  # noqa: SLF001
 
-    # Last Error (if any)
+    # === Error Status ===
+    # Present only when there's an active error
     if coordinator.last_exception:
         attributes["last_error"] = str(coordinator.last_exception)
 

custom_components/tibber_prices/sensor/attributes/timing.py

@@ -13,6 +13,17 @@ if TYPE_CHECKING:
 TIMER_30_SEC_BOUNDARY = 30
 
 
+def _hours_to_minutes(state_value: Any) -> int | None:
+    """Convert hour-based state back to rounded minutes for attributes."""
+    if state_value is None:
+        return None
+
+    try:
+        return round(float(state_value) * 60)
+    except (TypeError, ValueError):
+        return None
+
+
 def _is_timing_or_volatility_sensor(key: str) -> bool:
     """Check if sensor is a timing or volatility sensor."""
     return key.endswith("_volatility") or (
@@ -69,5 +80,16 @@ def add_period_timing_attributes(
 
     attributes["timestamp"] = timestamp
 
+    # Add minute-precision attributes for hour-based states to keep automation-friendly values
+    minute_value = _hours_to_minutes(state_value)
+
+    if minute_value is not None:
+        if key.endswith("period_duration"):
+            attributes["period_duration_minutes"] = minute_value
+        elif key.endswith("remaining_minutes"):
+            attributes["remaining_minutes"] = minute_value
+        elif key.endswith("next_in_minutes"):
+            attributes["next_in_minutes"] = minute_value
+
     # Add icon_color for dynamic styling
     add_icon_color_attribute(attributes, key=key, state_value=state_value)

custom_components/tibber_prices/sensor/calculators/lifecycle.py

@@ -2,11 +2,7 @@
 
 from __future__ import annotations
 
-from datetime import timedelta
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from datetime import datetime
+from datetime import datetime, timedelta
 
 from custom_components.tibber_prices.coordinator.constants import UPDATE_INTERVAL
 
@@ -17,10 +13,6 @@ FRESH_DATA_THRESHOLD_MINUTES = 5  # Data is "fresh" within 5 minutes of API fetc
 TOMORROW_CHECK_HOUR = 13  # After 13:00, we actively check for tomorrow data
 TURNOVER_WARNING_SECONDS = 900  # Warn 15 minutes before midnight (last quarter-hour: 23:45-00:00)
 
-# Constants for 15-minute update boundaries (Timer #1)
-QUARTER_HOUR_BOUNDARIES = [0, 15, 30, 45]  # Minutes when Timer #1 can trigger
-LAST_HOUR_OF_DAY = 23
-
 
 class TibberPricesLifecycleCalculator(TibberPricesBaseCalculator):
     """Calculate data lifecycle status and metadata."""
@@ -82,15 +74,6 @@ class TibberPricesLifecycleCalculator(TibberPricesBaseCalculator):
         # Priority 6: Default - using cached data
         return "cached"
 
-    def get_cache_age_minutes(self) -> int | None:
-        """Calculate how many minutes old the cached data is."""
-        coordinator = self.coordinator
-        if not coordinator._last_price_update:  # noqa: SLF001 - Internal state access for lifecycle tracking
-            return None
-
-        age = coordinator.time.now() - coordinator._last_price_update  # noqa: SLF001
-        return int(age.total_seconds() / 60)
-
     def get_next_api_poll_time(self) -> datetime | None:
         """
         Calculate when the next API poll attempt will occur.
@@ -179,117 +162,6 @@ class TibberPricesLifecycleCalculator(TibberPricesBaseCalculator):
         # Fallback: If we don't know timer offset yet, assume 13:00:00
         return tomorrow_13
 
-    def get_next_midnight_turnover_time(self) -> datetime:
-        """Calculate when the next midnight turnover will occur."""
-        coordinator = self.coordinator
-        current_time = coordinator.time.now()
-        now_local = coordinator.time.as_local(current_time)
-
-        # Next midnight
-        return now_local.replace(hour=0, minute=0, second=0, microsecond=0) + timedelta(days=1)
-
-    def is_data_available(self, day_offset: int) -> bool:
-        """
-        Check if data is available for a specific day.
-
-        Args:
-            day_offset: Day offset (-1=yesterday, 0=today, 1=tomorrow)
-
-        Returns:
-            True if data exists and is not empty
-
-        """
-        if not self.has_data():
-            return False
-
-        day_data = self.get_intervals(day_offset)
-        return bool(day_data)
-
-    def get_data_completeness_status(self) -> str:
-        """
-        Get human-readable data completeness status.
-
-        Returns:
-            'complete': All data (yesterday/today/tomorrow) available
-            'missing_tomorrow': Only yesterday and today available
-            'missing_yesterday': Only today and tomorrow available
-            'partial': Only today or some other partial combination
-            'no_data': No data available at all
-
-        """
-        yesterday_available = self.is_data_available(-1)
-        today_available = self.is_data_available(0)
-        tomorrow_available = self.is_data_available(1)
-
-        if yesterday_available and today_available and tomorrow_available:
-            return "complete"
-        if yesterday_available and today_available and not tomorrow_available:
-            return "missing_tomorrow"
-        if not yesterday_available and today_available and tomorrow_available:
-            return "missing_yesterday"
-        if today_available:
-            return "partial"
-        return "no_data"
-
-    def get_cache_validity_status(self) -> str:
-        """
-        Get cache validity status.
-
-        Returns:
-            "valid": Cache is current and matches today's date
-            "stale": Cache exists but is outdated
-            "date_mismatch": Cache is from a different day
-            "empty": No cache data
-
-        """
-        coordinator = self.coordinator
-        # Check if coordinator has data (transformed, ready for entities)
-        if not self.has_data():
-            return "empty"
-
-        # Check if we have price update timestamp
-        if not coordinator._last_price_update:  # noqa: SLF001 - Internal state access for lifecycle tracking
-            return "empty"
-
-        current_time = coordinator.time.now()
-        current_local_date = coordinator.time.as_local(current_time).date()
-        last_update_local_date = coordinator.time.as_local(coordinator._last_price_update).date()  # noqa: SLF001
-
-        if current_local_date != last_update_local_date:
-            return "date_mismatch"
-
-        # Check if cache is stale (older than expected)
-        # CRITICAL: After midnight turnover, _last_price_update is set to 00:00
-        # without new API data. The data is still valid (rotated yesterday→today).
-        #
-        # Cache is considered "valid" if EITHER:
-        # 1. Within normal update interval expectations (age ≤ 2 hours), OR
-        # 2. Coordinator update cycle ran recently (within last 30 minutes)
-        #
-        # Why check _last_coordinator_update?
-        # - After midnight turnover, _last_price_update stays at 00:00
-        # - But coordinator polls every 15 minutes and validates cache
-        # - If coordinator ran recently, cache was checked and deemed valid
-        # - This prevents false "stale" status when using rotated data
-
-        age = current_time - coordinator._last_price_update  # noqa: SLF001
-
-        # If cache age is within normal expectations (≤2 hours), it's valid
-        if age <= timedelta(hours=2):
-            return "valid"
-
-        # Cache is older than 2 hours - check if coordinator validated it recently
-        # If coordinator ran within last 30 minutes, cache is considered current
-        # (even if _last_price_update is older, e.g., from midnight turnover)
-        if coordinator._last_coordinator_update:  # noqa: SLF001 - Internal state access
-            time_since_coordinator_check = current_time - coordinator._last_coordinator_update  # noqa: SLF001
-            if time_since_coordinator_check <= timedelta(minutes=30):
-                # Coordinator validated cache recently - it's current
-                return "valid"
-
-        # Cache is old AND coordinator hasn't validated recently - stale
-        return "stale"
-
     def get_api_calls_today(self) -> int:
         """Get the number of API calls made today."""
         coordinator = self.coordinator
@@ -300,3 +172,13 @@ class TibberPricesLifecycleCalculator(TibberPricesBaseCalculator):
             return 0
 
         return coordinator._api_calls_today  # noqa: SLF001
+
+    def has_tomorrow_data(self) -> bool:
+        """
+        Check if tomorrow's price data is available.
+
+        Returns:
+            True if tomorrow data exists in the pool.
+
+        """
+        return not self.coordinator._needs_tomorrow_data()  # noqa: SLF001

custom_components/tibber_prices/sensor/calculators/rolling_hour.py

@@ -11,8 +11,8 @@ from custom_components.tibber_prices.const import (
 from custom_components.tibber_prices.coordinator.helpers import get_intervals_for_day_offsets
 from custom_components.tibber_prices.entity_utils import find_rolling_hour_center_index
 from custom_components.tibber_prices.sensor.helpers import (
+    aggregate_average_data,
     aggregate_level_data,
-    aggregate_price_data,
     aggregate_rating_data,
 )
 
@@ -108,7 +108,7 @@ class TibberPricesRollingHourCalculator(TibberPricesBaseCalculator):
 
         # Handle price aggregation - return tuple directly
         if value_type == "price":
-            return aggregate_price_data(window_data, self.config_entry)
+            return aggregate_average_data(window_data, self.config_entry)
 
         # Map other value types to aggregation functions
         aggregators = {

custom_components/tibber_prices/sensor/calculators/trend.py

@@ -17,7 +17,7 @@ from typing import TYPE_CHECKING, Any
 
 from custom_components.tibber_prices.const import get_display_unit_factor
 from custom_components.tibber_prices.coordinator.helpers import get_intervals_for_day_offsets
-from custom_components.tibber_prices.utils.average import calculate_next_n_hours_avg
+from custom_components.tibber_prices.utils.average import calculate_mean, calculate_next_n_hours_mean
 from custom_components.tibber_prices.utils.price import (
     calculate_price_trend,
     find_price_data_for_interval,
@@ -97,14 +97,16 @@ class TibberPricesTrendCalculator(TibberPricesBaseCalculator):
         # Get next interval timestamp (basis for calculation)
         next_interval_start = time.get_next_interval_start()
 
-        # Get future average price
-        future_avg, _ = calculate_next_n_hours_avg(self.coordinator.data, hours, time=self.coordinator.time)
-        if future_avg is None:
+        # Get future mean price (ignore median for trend calculation)
+        future_mean, _ = calculate_next_n_hours_mean(self.coordinator.data, hours, time=self.coordinator.time)
+        if future_mean is None:
             return None
 
         # Get configured thresholds from options
         threshold_rising = self.config.get("price_trend_threshold_rising", 5.0)
         threshold_falling = self.config.get("price_trend_threshold_falling", -5.0)
+        threshold_strongly_rising = self.config.get("price_trend_threshold_strongly_rising", 6.0)
+        threshold_strongly_falling = self.config.get("price_trend_threshold_strongly_falling", -6.0)
         volatility_threshold_moderate = self.config.get("volatility_threshold_moderate", 15.0)
         volatility_threshold_high = self.config.get("volatility_threshold_high", 30.0)
 
@@ -115,11 +117,13 @@ class TibberPricesTrendCalculator(TibberPricesBaseCalculator):
         lookahead_intervals = self.coordinator.time.minutes_to_intervals(hours * 60)
 
         # Calculate trend with volatility-adaptive thresholds
-        trend_state, diff_pct = calculate_price_trend(
+        trend_state, diff_pct, trend_value = calculate_price_trend(
             current_interval_price,
-            future_avg,
+            future_mean,
             threshold_rising=threshold_rising,
             threshold_falling=threshold_falling,
+            threshold_strongly_rising=threshold_strongly_rising,
+            threshold_strongly_falling=threshold_strongly_falling,
             volatility_adjustment=True,  # Always enabled
             lookahead_intervals=lookahead_intervals,
             all_intervals=all_intervals,
@@ -127,11 +131,14 @@ class TibberPricesTrendCalculator(TibberPricesBaseCalculator):
             volatility_threshold_high=volatility_threshold_high,
         )
 
-        # Determine icon color based on trend state
+        # Determine icon color based on trend state (5-level scale)
+        # Strongly rising/falling uses more intense colors
         icon_color = {
-            "rising": "var(--error-color)",  # Red/Orange for rising prices (expensive)
-            "falling": "var(--success-color)",  # Green for falling prices (cheaper)
+            "strongly_rising": "var(--error-color)",  # Red for strongly rising (very expensive)
+            "rising": "var(--warning-color)",  # Orange/Yellow for rising prices
             "stable": "var(--state-icon-color)",  # Default gray for stable prices
+            "falling": "var(--success-color)",  # Green for falling prices (cheaper)
+            "strongly_falling": "var(--success-color)",  # Green for strongly falling (great deal)
         }.get(trend_state, "var(--state-icon-color)")
 
         # Convert prices to display currency unit based on configuration
@@ -140,8 +147,9 @@ class TibberPricesTrendCalculator(TibberPricesBaseCalculator):
         # Store attributes in sensor-specific dictionary AND cache the trend value
         self._trend_attributes = {
             "timestamp": next_interval_start,
+            "trend_value": trend_value,
             f"trend_{hours}h_%": round(diff_pct, 1),
-            f"next_{hours}h_avg": round(future_avg * factor, 2),
+            f"next_{hours}h_avg": round(future_mean * factor, 2),
             "interval_count": lookahead_intervals,
             "threshold_rising": threshold_rising,
             "threshold_falling": threshold_falling,
@@ -282,7 +290,7 @@ class TibberPricesTrendCalculator(TibberPricesBaseCalculator):
                     later_prices.append(float(price))
 
         if later_prices:
-            return sum(later_prices) / len(later_prices)
+            return calculate_mean(later_prices)
 
         return None
 
@@ -349,11 +357,11 @@ class TibberPricesTrendCalculator(TibberPricesBaseCalculator):
 
         # Combine momentum + future outlook to get ACTUAL current trend
         if len(future_intervals) >= min_intervals_for_trend and future_prices:
-            future_avg = sum(future_prices) / len(future_prices)
+            future_mean = calculate_mean(future_prices)
             current_trend_state = self._combine_momentum_with_future(
                 current_momentum=current_momentum,
                 current_price=current_price,
-                future_avg=future_avg,
+                future_mean=future_mean,
                 context={
                     "all_intervals": all_intervals,
                     "current_index": current_index,
@@ -414,6 +422,8 @@ class TibberPricesTrendCalculator(TibberPricesBaseCalculator):
         return {
             "rising": self.config.get("price_trend_threshold_rising", 5.0),
             "falling": self.config.get("price_trend_threshold_falling", -5.0),
+            "strongly_rising": self.config.get("price_trend_threshold_strongly_rising", 6.0),
+            "strongly_falling": self.config.get("price_trend_threshold_strongly_falling", -6.0),
             "moderate": self.config.get("volatility_threshold_moderate", 15.0),
             "high": self.config.get("volatility_threshold_high", 30.0),
         }
@@ -428,7 +438,7 @@ class TibberPricesTrendCalculator(TibberPricesBaseCalculator):
             current_index: Index of current interval
 
         Returns:
-            Momentum direction: "rising", "falling", or "stable"
+            Momentum direction: "strongly_rising", "rising", "stable", "falling", or "strongly_falling"
 
         """
         # Look back 1 hour (4 intervals) for quick reaction
@@ -451,64 +461,91 @@ class TibberPricesTrendCalculator(TibberPricesBaseCalculator):
         weighted_sum = sum(price * weight for price, weight in zip(trailing_prices, weights, strict=True))
         weighted_avg = weighted_sum / sum(weights)
 
-        # Calculate momentum with 3% threshold
+        # Calculate momentum with thresholds
+        # Using same logic as 5-level trend: 3% for normal, 6% (2x) for strong
         momentum_threshold = 0.03
-        diff = (current_price - weighted_avg) / weighted_avg
+        strong_momentum_threshold = 0.06
+        diff = (current_price - weighted_avg) / abs(weighted_avg) if weighted_avg != 0 else 0
 
-        if diff > momentum_threshold:
-            return "rising"
-        if diff < -momentum_threshold:
-            return "falling"
-        return "stable"
+        # Determine momentum level based on thresholds
+        if diff >= strong_momentum_threshold:
+            momentum = "strongly_rising"
+        elif diff > momentum_threshold:
+            momentum = "rising"
+        elif diff <= -strong_momentum_threshold:
+            momentum = "strongly_falling"
+        elif diff < -momentum_threshold:
+            momentum = "falling"
+        else:
+            momentum = "stable"
+
+        return momentum
 
     def _combine_momentum_with_future(
         self,
         *,
         current_momentum: str,
         current_price: float,
-        future_avg: float,
+        future_mean: float,
         context: dict,
     ) -> str:
         """
         Combine momentum analysis with future outlook to determine final trend.
 
+        Uses 5-level scale: strongly_rising, rising, stable, falling, strongly_falling.
+        Momentum intensity is preserved when future confirms the trend direction.
+
         Args:
-            current_momentum: Current momentum direction (rising/falling/stable)
+            current_momentum: Current momentum direction (5-level scale)
             current_price: Current interval price
-            future_avg: Average price in future window
+            future_mean: Average price in future window
             context: Dict with all_intervals, current_index, lookahead_intervals, thresholds
 
         Returns:
-            Final trend direction: "rising", "falling", or "stable"
+            Final trend direction (5-level scale)
 
         """
-        if current_momentum == "rising":
-            # We're in uptrend - does it continue?
-            return "rising" if future_avg >= current_price * 0.98 else "falling"
-
-        if current_momentum == "falling":
-            # We're in downtrend - does it continue?
-            return "falling" if future_avg <= current_price * 1.02 else "rising"
-
-        # current_momentum == "stable" - what's coming?
+        # Use calculate_price_trend for consistency with 5-level logic
         all_intervals = context["all_intervals"]
         current_index = context["current_index"]
         lookahead_intervals = context["lookahead_intervals"]
         thresholds = context["thresholds"]
 
         lookahead_for_volatility = all_intervals[current_index : current_index + lookahead_intervals]
-        trend_state, _ = calculate_price_trend(
+        future_trend, _, _ = calculate_price_trend(
             current_price,
-            future_avg,
+            future_mean,
             threshold_rising=thresholds["rising"],
             threshold_falling=thresholds["falling"],
+            threshold_strongly_rising=thresholds["strongly_rising"],
+            threshold_strongly_falling=thresholds["strongly_falling"],
             volatility_adjustment=True,
             lookahead_intervals=lookahead_intervals,
             all_intervals=lookahead_for_volatility,
             volatility_threshold_moderate=thresholds["moderate"],
             volatility_threshold_high=thresholds["high"],
         )
-        return trend_state
+
+        # Check if momentum and future trend are aligned (same direction)
+        momentum_rising = current_momentum in ("rising", "strongly_rising")
+        momentum_falling = current_momentum in ("falling", "strongly_falling")
+        future_rising = future_trend in ("rising", "strongly_rising")
+        future_falling = future_trend in ("falling", "strongly_falling")
+
+        if momentum_rising and future_rising:
+            # Both indicate rising - use the stronger signal
+            if current_momentum == "strongly_rising" or future_trend == "strongly_rising":
+                return "strongly_rising"
+            return "rising"
+
+        if momentum_falling and future_falling:
+            # Both indicate falling - use the stronger signal
+            if current_momentum == "strongly_falling" or future_trend == "strongly_falling":
+                return "strongly_falling"
+            return "falling"
+
+        # Conflicting signals or stable momentum - trust future trend calculation
+        return future_trend
 
     def _calculate_standard_trend(
         self,
@@ -530,15 +567,17 @@ class TibberPricesTrendCalculator(TibberPricesBaseCalculator):
         if not standard_future_prices:
             return "stable"
 
-        standard_future_avg = sum(standard_future_prices) / len(standard_future_prices)
+        standard_future_mean = calculate_mean(standard_future_prices)
         current_price = float(current_interval["total"])
 
         standard_lookahead_volatility = all_intervals[current_index : current_index + standard_lookahead]
-        current_trend_3h, _ = calculate_price_trend(
+        current_trend_3h, _, _ = calculate_price_trend(
             current_price,
-            standard_future_avg,
+            standard_future_mean,
             threshold_rising=thresholds["rising"],
             threshold_falling=thresholds["falling"],
+            threshold_strongly_rising=thresholds["strongly_rising"],
+            threshold_strongly_falling=thresholds["strongly_falling"],
             volatility_adjustment=True,
             lookahead_intervals=standard_lookahead,
             all_intervals=standard_lookahead_volatility,
@@ -601,16 +640,18 @@ class TibberPricesTrendCalculator(TibberPricesBaseCalculator):
             if not future_prices:
                 continue
 
-            future_avg = sum(future_prices) / len(future_prices)
+            future_mean = calculate_mean(future_prices)
             price = float(interval["total"])
 
             # Calculate trend at this past point
             lookahead_for_volatility = all_intervals[i : i + intervals_in_3h]
-            trend_state, _ = calculate_price_trend(
+            trend_state, _, _ = calculate_price_trend(
                 price,
-                future_avg,
+                future_mean,
                 threshold_rising=thresholds["rising"],
                 threshold_falling=thresholds["falling"],
+                threshold_strongly_rising=thresholds["strongly_rising"],
+                threshold_strongly_falling=thresholds["strongly_falling"],
                 volatility_adjustment=True,
                 lookahead_intervals=intervals_in_3h,
                 all_intervals=lookahead_for_volatility,
@@ -673,16 +714,18 @@ class TibberPricesTrendCalculator(TibberPricesBaseCalculator):
             if not future_prices:
                 continue
 
-            future_avg = sum(future_prices) / len(future_prices)
+            future_mean = calculate_mean(future_prices)
             current_price = float(interval["total"])
 
             # Calculate trend at this future point
             lookahead_for_volatility = all_intervals[i : i + intervals_in_3h]
-            trend_state, _ = calculate_price_trend(
+            trend_state, _, _ = calculate_price_trend(
                 current_price,
-                future_avg,
+                future_mean,
                 threshold_rising=thresholds["rising"],
                 threshold_falling=thresholds["falling"],
+                threshold_strongly_rising=thresholds["strongly_rising"],
+                threshold_strongly_falling=thresholds["strongly_falling"],
                 volatility_adjustment=True,
                 lookahead_intervals=intervals_in_3h,
                 all_intervals=lookahead_for_volatility,
@@ -706,8 +749,8 @@ class TibberPricesTrendCalculator(TibberPricesBaseCalculator):
                     "minutes_until_change": minutes_until,
                     "current_price_now": round(float(current_interval["total"]) * factor, 2),
                     "price_at_change": round(current_price * factor, 2),
-                    "avg_after_change": round(future_avg * factor, 2),
-                    "trend_diff_%": round((future_avg - current_price) / current_price * 100, 1),
+                    "avg_after_change": round(future_mean * factor, 2),
+                    "trend_diff_%": round((future_mean - current_price) / current_price * 100, 1),
                 }
                 return interval_start
 

custom_components/tibber_prices/sensor/calculators/volatility.py

@@ -4,13 +4,22 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-from custom_components.tibber_prices.const import get_display_unit_factor
+from custom_components.tibber_prices.const import (
+    CONF_VOLATILITY_THRESHOLD_HIGH,
+    CONF_VOLATILITY_THRESHOLD_MODERATE,
+    CONF_VOLATILITY_THRESHOLD_VERY_HIGH,
+    DEFAULT_VOLATILITY_THRESHOLD_HIGH,
+    DEFAULT_VOLATILITY_THRESHOLD_MODERATE,
+    DEFAULT_VOLATILITY_THRESHOLD_VERY_HIGH,
+    get_display_unit_factor,
+)
 from custom_components.tibber_prices.entity_utils import add_icon_color_attribute
 from custom_components.tibber_prices.sensor.attributes import (
     add_volatility_type_attributes,
     get_prices_for_volatility,
 )
-from custom_components.tibber_prices.utils.price import calculate_volatility_level
+from custom_components.tibber_prices.utils.average import calculate_mean
+from custom_components.tibber_prices.utils.price import calculate_volatility_with_cv
 
 from .base import TibberPricesBaseCalculator
 
@@ -57,14 +66,22 @@ class TibberPricesVolatilityCalculator(TibberPricesBaseCalculator):
 
         # Get volatility thresholds from config
         thresholds = {
-            "threshold_moderate": self.config.get("volatility_threshold_moderate", 5.0),
-            "threshold_high": self.config.get("volatility_threshold_high", 15.0),
-            "threshold_very_high": self.config.get("volatility_threshold_very_high", 30.0),
+            "threshold_moderate": self.config.get(
+                CONF_VOLATILITY_THRESHOLD_MODERATE,
+                DEFAULT_VOLATILITY_THRESHOLD_MODERATE,
+            ),
+            "threshold_high": self.config.get(CONF_VOLATILITY_THRESHOLD_HIGH, DEFAULT_VOLATILITY_THRESHOLD_HIGH),
+            "threshold_very_high": self.config.get(
+                CONF_VOLATILITY_THRESHOLD_VERY_HIGH,
+                DEFAULT_VOLATILITY_THRESHOLD_VERY_HIGH,
+            ),
         }
 
         # Get prices based on volatility type
         prices_to_analyze = get_prices_for_volatility(
-            volatility_type, self.coordinator.data, time=self.coordinator.time
+            volatility_type,
+            self.coordinator.data,
+            time=self.coordinator.time,
         )
 
         if not prices_to_analyze:
@@ -75,22 +92,23 @@ class TibberPricesVolatilityCalculator(TibberPricesBaseCalculator):
         price_max = max(prices_to_analyze)
         spread = price_max - price_min
         # Use arithmetic mean for volatility calculation (required for coefficient of variation)
-        price_mean = sum(prices_to_analyze) / len(prices_to_analyze)
+        price_mean = calculate_mean(prices_to_analyze)
 
         # Convert to display currency unit based on configuration
         factor = get_display_unit_factor(self.config_entry)
         spread_display = spread * factor
 
-        # Calculate volatility level with custom thresholds (pass price list, not spread)
-        volatility = calculate_volatility_level(prices_to_analyze, **thresholds)
+        # Calculate volatility level AND coefficient of variation
+        volatility, cv = calculate_volatility_with_cv(prices_to_analyze, **thresholds)
 
         # Store attributes for this sensor
         self._last_volatility_attributes = {
             "price_spread": round(spread_display, 2),
-            "price_volatility": volatility,
+            "price_coefficient_variation_%": round(cv, 2) if cv is not None else None,
+            "price_volatility": volatility.lower(),
             "price_min": round(price_min * factor, 2),
             "price_max": round(price_max * factor, 2),
-            "price_mean": round(price_mean * factor, 2),  # Mean used for volatility calculation
+            "price_mean": round(price_mean * factor, 2),
             "interval_count": len(prices_to_analyze),
         }
 

custom_components/tibber_prices/sensor/calculators/window_24h.py

@@ -33,11 +33,11 @@ class TibberPricesWindow24hCalculator(TibberPricesBaseCalculator):
         - "leading": Next 24 hours (96 intervals after current)
 
         Args:
-            stat_func: Function from average_utils (e.g., calculate_current_trailing_avg).
+            stat_func: Function from average_utils (e.g., calculate_current_trailing_mean).
 
         Returns:
             Price value in subunit currency units (cents/øre), or None if unavailable.
-            For average functions: tuple of (avg, median) where median may be None.
+            For mean functions: tuple of (mean, median) where median may be None.
             For min/max functions: single float value.
 
         """
@@ -46,19 +46,19 @@ class TibberPricesWindow24hCalculator(TibberPricesBaseCalculator):
 
         result = stat_func(self.coordinator_data, time=self.coordinator.time)
 
-        # Check if result is a tuple (avg, median) from average functions
+        # Check if result is a tuple (mean, median) from mean functions
         if isinstance(result, tuple):
             value, median = result
             if value is None:
                 return None
             # Convert to display currency units based on config
-            avg_result = round(get_price_value(value, config_entry=self.coordinator.config_entry), 2)
+            mean_result = round(get_price_value(value, config_entry=self.coordinator.config_entry), 2)
             median_result = (
                 round(get_price_value(median, config_entry=self.coordinator.config_entry), 2)
                 if median is not None
                 else None
             )
-            return avg_result, median_result
+            return mean_result, median_result
 
         # Single value result (min/max functions)
         value = result

custom_components/tibber_prices/sensor/core.py

@@ -40,7 +40,7 @@ from custom_components.tibber_prices.entity_utils.icons import (
     get_dynamic_icon,
 )
 from custom_components.tibber_prices.utils.average import (
-    calculate_next_n_hours_avg,
+    calculate_next_n_hours_mean,
 )
 from custom_components.tibber_prices.utils.price import (
     calculate_volatility_level,
@@ -100,7 +100,7 @@ MIN_HOURS_FOR_LATER_HALF = 3  # Minimum hours needed to calculate later half ave
 class TibberPricesSensor(TibberPricesEntity, RestoreSensor):
     """tibber_prices Sensor class with state restoration."""
 
-    # Attributes excluded from recorder history
+    # Base attributes excluded from recorder history (shared across all sensors)
     # See: https://developers.home-assistant.io/docs/core/entity/#excluding-state-attributes-from-recorder-history
     _unrecorded_attributes = frozenset(
         {
@@ -177,6 +177,9 @@ class TibberPricesSensor(TibberPricesEntity, RestoreSensor):
         self._value_getter: Callable | None = self._get_value_getter()
         self._time_sensitive_remove_listener: Callable | None = None
         self._minute_update_remove_listener: Callable | None = None
+        # Lifecycle sensor state change detection (for recorder optimization)
+        # Store as Any because native_value can be str/float/datetime depending on sensor type
+        self._last_lifecycle_state: Any = None
         # Chart data export (for chart_data_export sensor) - from binary_sensor
         self._chart_data_last_update = None  # Track last service call timestamp
         self._chart_data_error = None  # Track last service call error
@@ -190,7 +193,48 @@ class TibberPricesSensor(TibberPricesEntity, RestoreSensor):
         """When entity is added to hass."""
         await super().async_added_to_hass()
 
+        # Configure dynamic attribute exclusion for average sensors
+        self._configure_average_sensor_exclusions()
+
         # Restore last state if available
+        await self._restore_last_state()
+
+        # Register listeners for time-sensitive updates
+        self._register_update_listeners()
+
+        # Trigger initial chart data loads as background tasks
+        self._trigger_chart_data_loads()
+
+    def _configure_average_sensor_exclusions(self) -> None:
+        """Configure dynamic attribute exclusions for average sensors."""
+        # Dynamically exclude average attribute that matches state value
+        # (to avoid recording the same value twice: once as state, once as attribute)
+        key = self.entity_description.key
+        if key in (
+            "average_price_today",
+            "average_price_tomorrow",
+            "trailing_price_average",
+            "leading_price_average",
+            "current_hour_average_price",
+            "next_hour_average_price",
+        ) or key.startswith("next_avg_"):  # Future average sensors
+            display_mode = self.coordinator.config_entry.options.get(
+                CONF_AVERAGE_SENSOR_DISPLAY,
+                DEFAULT_AVERAGE_SENSOR_DISPLAY,
+            )
+            # Modify _state_info to add dynamic exclusion
+            if self._state_info is None:
+                self._state_info = {"unrecorded_attributes": frozenset()}
+            current_unrecorded = self._state_info.get("unrecorded_attributes", frozenset())
+            # State shows median → exclude price_median from attributes
+            # State shows mean → exclude price_mean from attributes
+            if display_mode == "median":
+                self._state_info["unrecorded_attributes"] = current_unrecorded | {"price_median"}
+            else:
+                self._state_info["unrecorded_attributes"] = current_unrecorded | {"price_mean"}
+
+    async def _restore_last_state(self) -> None:
+        """Restore last state if available."""
         if (
             (last_state := await self.async_get_last_state()) is not None
             and last_state.state not in (None, "unknown", "unavailable", "")
@@ -213,6 +257,8 @@ class TibberPricesSensor(TibberPricesEntity, RestoreSensor):
                     self._chart_metadata_response = metadata_attrs
                 self._chart_metadata_last_update = last_state.attributes.get("last_update")
 
+    def _register_update_listeners(self) -> None:
+        """Register listeners for time-sensitive updates."""
         # Register with coordinator for time-sensitive updates if applicable
         if self.entity_description.key in TIME_SENSITIVE_ENTITY_KEYS:
             self._time_sensitive_remove_listener = self.coordinator.async_add_time_sensitive_listener(
@@ -225,6 +271,8 @@ class TibberPricesSensor(TibberPricesEntity, RestoreSensor):
                 self._handle_minute_update
             )
 
+    def _trigger_chart_data_loads(self) -> None:
+        """Trigger initial chart data loads as background tasks."""
         # For chart_data_export, trigger initial service call as background task
         # (non-blocking to avoid delaying entity setup)
         if self.entity_description.key == "chart_data_export":
@@ -267,6 +315,17 @@ class TibberPricesSensor(TibberPricesEntity, RestoreSensor):
         # Clear trend calculation cache for trend sensors
         elif self.entity_description.key in ("current_price_trend", "next_price_trend_change"):
             self._trend_calculator.clear_calculation_cache()
+
+        # For lifecycle sensor: Only write state if it actually changed (state-change filter)
+        # This enables precise detection at quarter-hour boundaries (23:45 turnover_pending,
+        # 13:00 searching_tomorrow, 00:00 turnover complete) without recorder spam
+        if self.entity_description.key == "data_lifecycle_status":
+            current_state = self.native_value
+            if current_state != self._last_lifecycle_state:
+                self._last_lifecycle_state = current_state
+                self.async_write_ha_state()
+            # If state didn't change, skip write to recorder
+        else:
             self.async_write_ha_state()
 
     @callback
@@ -289,6 +348,8 @@ class TibberPricesSensor(TibberPricesEntity, RestoreSensor):
         # Clear cached trend values when coordinator data changes
         if self.entity_description.key.startswith("price_trend_"):
             self._trend_calculator.clear_trend_cache()
+            # Also clear calculation cache (e.g., when threshold config changes)
+            self._trend_calculator.clear_calculation_cache()
 
         # Refresh chart data when coordinator updates (new price data or user data)
         if self.entity_description.key == "chart_data_export":
@@ -300,6 +361,15 @@ class TibberPricesSensor(TibberPricesEntity, RestoreSensor):
             # Schedule async refresh as a task (we're in a callback)
             self.hass.async_create_task(self._refresh_chart_metadata())
 
+        # For lifecycle sensor: Only write state if it actually changed (event-based filter)
+        # Prevents excessive recorder entries while keeping quarter-hour update capability
+        if self.entity_description.key == "data_lifecycle_status":
+            current_state = self.native_value
+            if current_state != self._last_lifecycle_state:
+                self._last_lifecycle_state = current_state
+                super()._handle_coordinator_update()
+            # If state didn't change, skip write to recorder
+        else:
             super()._handle_coordinator_update()
 
     def _get_value_getter(self) -> Callable | None:
@@ -519,7 +589,7 @@ class TibberPricesSensor(TibberPricesEntity, RestoreSensor):
         - "leading": Next 24 hours (96 intervals after current)
 
         Args:
-            stat_func: Function from average_utils (e.g., calculate_current_trailing_avg)
+            stat_func: Function from average_utils (e.g., calculate_current_trailing_mean)
 
         Returns:
             Price value in subunit currency units (cents/øre), or None if unavailable
@@ -568,28 +638,37 @@ class TibberPricesSensor(TibberPricesEntity, RestoreSensor):
 
     def _get_next_avg_n_hours_value(self, hours: int) -> float | None:
         """
-        Get average price for next N hours starting from next interval.
+        Get mean price for next N hours starting from next interval.
 
         Args:
             hours: Number of hours to look ahead (1, 2, 3, 4, 5, 6, 8, 12)
 
         Returns:
-            Average price in subunit currency units (e.g., cents), or None if unavailable
+            Mean or median price (based on config) in subunit currency units (e.g., cents),
+            or None if unavailable
 
         """
-        avg_price, median_price = calculate_next_n_hours_avg(self.coordinator.data, hours, time=self.coordinator.time)
-        if avg_price is None:
+        mean_price, median_price = calculate_next_n_hours_mean(self.coordinator.data, hours, time=self.coordinator.time)
+        if mean_price is None:
             return None
 
         # Get display unit factor (100 for minor, 1 for major)
         factor = get_display_unit_factor(self.coordinator.config_entry)
 
-        # Store median for attributes
+        # Get user preference for display (mean or median)
+        display_pref = self.coordinator.config_entry.options.get(
+            CONF_AVERAGE_SENSOR_DISPLAY, DEFAULT_AVERAGE_SENSOR_DISPLAY
+        )
+
+        # Store both values for attributes
+        self.cached_data[f"next_avg_{hours}h_mean"] = round(mean_price * factor, 2)
         if median_price is not None:
             self.cached_data[f"next_avg_{hours}h_median"] = round(median_price * factor, 2)
 
-        # Convert from major to display currency units
-        return round(avg_price * factor, 2)
+        # Return the value chosen for state display
+        if display_pref == "median" and median_price is not None:
+            return round(median_price * factor, 2)
+        return round(mean_price * factor, 2)  # "mean"
 
     def _get_data_timestamp(self) -> datetime | None:
         """
@@ -908,11 +987,13 @@ class TibberPricesSensor(TibberPricesEntity, RestoreSensor):
         key = self.entity_description.key
         value = self.native_value
 
-        # Icon mapping for trend directions
+        # Icon mapping for trend directions (5-level scale)
         trend_icons = {
+            "strongly_rising": "mdi:chevron-double-up",
             "rising": "mdi:trending-up",
-            "falling": "mdi:trending-down",
             "stable": "mdi:trending-neutral",
+            "falling": "mdi:trending-down",
+            "strongly_falling": "mdi:chevron-double-down",
         }
 
         # Special handling for next_price_trend_change: Icon based on direction attribute

custom_components/tibber_prices/sensor/definitions.py

@@ -454,7 +454,7 @@ WINDOW_24H_SENSORS = (
 # ----------------------------------------------------------------------------
 # Calculate averages and trends for upcoming time windows
 
-FUTURE_AVG_SENSORS = (
+FUTURE_MEAN_SENSORS = (
     # Default enabled: 1h-5h
     SensorEntityDescription(
         key="next_avg_1h",
@@ -548,7 +548,7 @@ FUTURE_TREND_SENSORS = (
         icon="mdi:trending-up",  # Dynamic: trending-up/trending-down/trending-neutral based on current trend
         device_class=SensorDeviceClass.ENUM,
         state_class=None,  # Enum values: no statistics
-        options=["rising", "falling", "stable"],
+        options=["strongly_falling", "falling", "stable", "rising", "strongly_rising"],
         entity_registry_enabled_default=True,
     ),
     # Next trend change sensor (when will trend change?)
@@ -570,7 +570,7 @@ FUTURE_TREND_SENSORS = (
         icon="mdi:trending-up",  # Dynamic: shows trending-up/trending-down/trending-neutral based on trend value
         device_class=SensorDeviceClass.ENUM,
         state_class=None,  # Enum values: no statistics
-        options=["rising", "falling", "stable"],
+        options=["strongly_falling", "falling", "stable", "rising", "strongly_rising"],
         entity_registry_enabled_default=True,
     ),
     SensorEntityDescription(
@@ -580,7 +580,7 @@ FUTURE_TREND_SENSORS = (
         icon="mdi:trending-up",  # Dynamic: shows trending-up/trending-down/trending-neutral based on trend value
         device_class=SensorDeviceClass.ENUM,
         state_class=None,  # Enum values: no statistics
-        options=["rising", "falling", "stable"],
+        options=["strongly_falling", "falling", "stable", "rising", "strongly_rising"],
         entity_registry_enabled_default=True,
     ),
     SensorEntityDescription(
@@ -590,7 +590,7 @@ FUTURE_TREND_SENSORS = (
         icon="mdi:trending-up",  # Dynamic: shows trending-up/trending-down/trending-neutral based on trend value
         device_class=SensorDeviceClass.ENUM,
         state_class=None,  # Enum values: no statistics
-        options=["rising", "falling", "stable"],
+        options=["strongly_falling", "falling", "stable", "rising", "strongly_rising"],
         entity_registry_enabled_default=True,
     ),
     SensorEntityDescription(
@@ -600,7 +600,7 @@ FUTURE_TREND_SENSORS = (
         icon="mdi:trending-up",  # Dynamic: shows trending-up/trending-down/trending-neutral based on trend value
         device_class=SensorDeviceClass.ENUM,
         state_class=None,  # Enum values: no statistics
-        options=["rising", "falling", "stable"],
+        options=["strongly_falling", "falling", "stable", "rising", "strongly_rising"],
         entity_registry_enabled_default=True,
     ),
     SensorEntityDescription(
@@ -610,7 +610,7 @@ FUTURE_TREND_SENSORS = (
         icon="mdi:trending-up",  # Dynamic: shows trending-up/trending-down/trending-neutral based on trend value
         device_class=SensorDeviceClass.ENUM,
         state_class=None,  # Enum values: no statistics
-        options=["rising", "falling", "stable"],
+        options=["strongly_falling", "falling", "stable", "rising", "strongly_rising"],
         entity_registry_enabled_default=True,
     ),
     # Disabled by default: 6h, 8h, 12h
@@ -621,7 +621,7 @@ FUTURE_TREND_SENSORS = (
         icon="mdi:trending-up",  # Dynamic: shows trending-up/trending-down/trending-neutral based on trend value
         device_class=SensorDeviceClass.ENUM,
         state_class=None,  # Enum values: no statistics
-        options=["rising", "falling", "stable"],
+        options=["strongly_falling", "falling", "stable", "rising", "strongly_rising"],
         entity_registry_enabled_default=False,
     ),
     SensorEntityDescription(
@@ -631,7 +631,7 @@ FUTURE_TREND_SENSORS = (
         icon="mdi:trending-up",  # Dynamic: shows trending-up/trending-down/trending-neutral based on trend value
         device_class=SensorDeviceClass.ENUM,
         state_class=None,  # Enum values: no statistics
-        options=["rising", "falling", "stable"],
+        options=["strongly_falling", "falling", "stable", "rising", "strongly_rising"],
         entity_registry_enabled_default=False,
     ),
     SensorEntityDescription(
@@ -641,7 +641,7 @@ FUTURE_TREND_SENSORS = (
         icon="mdi:trending-up",  # Dynamic: shows trending-up/trending-down/trending-neutral based on trend value
         device_class=SensorDeviceClass.ENUM,
         state_class=None,  # Enum values: no statistics
-        options=["rising", "falling", "stable"],
+        options=["strongly_falling", "falling", "stable", "rising", "strongly_rising"],
         entity_registry_enabled_default=False,
     ),
 )
@@ -731,9 +731,9 @@ BEST_PRICE_TIMING_SENSORS = (
         name="Best Price Period Duration",
         icon="mdi:timer",
         device_class=SensorDeviceClass.DURATION,
-        native_unit_of_measurement=UnitOfTime.MINUTES,
-        state_class=None,  # Changes with each period: no statistics
-        suggested_display_precision=0,
+        native_unit_of_measurement=UnitOfTime.HOURS,
+        state_class=None,  # Duration not needed in long-term statistics
+        suggested_display_precision=2,
         entity_registry_enabled_default=False,
     ),
     SensorEntityDescription(
@@ -741,9 +741,10 @@ BEST_PRICE_TIMING_SENSORS = (
         translation_key="best_price_remaining_minutes",
         name="Best Price Remaining Time",
         icon="mdi:timer-sand",
-        native_unit_of_measurement=UnitOfTime.MINUTES,
-        state_class=None,  # Countdown timer: no statistics
-        suggested_display_precision=0,
+        device_class=SensorDeviceClass.DURATION,
+        native_unit_of_measurement=UnitOfTime.HOURS,
+        state_class=None,  # Countdown timers excluded from statistics
+        suggested_display_precision=2,
     ),
     SensorEntityDescription(
         key="best_price_progress",
@@ -767,9 +768,10 @@ BEST_PRICE_TIMING_SENSORS = (
         translation_key="best_price_next_in_minutes",
         name="Best Price Starts In",
         icon="mdi:timer-outline",
-        native_unit_of_measurement=UnitOfTime.MINUTES,
-        state_class=None,  # Countdown timer: no statistics
-        suggested_display_precision=0,
+        device_class=SensorDeviceClass.DURATION,
+        native_unit_of_measurement=UnitOfTime.HOURS,
+        state_class=None,  # Next-start timers excluded from statistics
+        suggested_display_precision=2,
     ),
 )
 
@@ -788,9 +790,9 @@ PEAK_PRICE_TIMING_SENSORS = (
         name="Peak Price Period Duration",
         icon="mdi:timer",
         device_class=SensorDeviceClass.DURATION,
-        native_unit_of_measurement=UnitOfTime.MINUTES,
-        state_class=None,  # Changes with each period: no statistics
-        suggested_display_precision=0,
+        native_unit_of_measurement=UnitOfTime.HOURS,
+        state_class=None,  # Duration not needed in long-term statistics
+        suggested_display_precision=2,
         entity_registry_enabled_default=False,
     ),
     SensorEntityDescription(
@@ -798,9 +800,10 @@ PEAK_PRICE_TIMING_SENSORS = (
         translation_key="peak_price_remaining_minutes",
         name="Peak Price Remaining Time",
         icon="mdi:timer-sand",
-        native_unit_of_measurement=UnitOfTime.MINUTES,
-        state_class=None,  # Countdown timer: no statistics
-        suggested_display_precision=0,
+        device_class=SensorDeviceClass.DURATION,
+        native_unit_of_measurement=UnitOfTime.HOURS,
+        state_class=None,  # Countdown timers excluded from statistics
+        suggested_display_precision=2,
     ),
     SensorEntityDescription(
         key="peak_price_progress",
@@ -824,9 +827,10 @@ PEAK_PRICE_TIMING_SENSORS = (
         translation_key="peak_price_next_in_minutes",
         name="Peak Price Starts In",
         icon="mdi:timer-outline",
-        native_unit_of_measurement=UnitOfTime.MINUTES,
-        state_class=None,  # Countdown timer: no statistics
-        suggested_display_precision=0,
+        device_class=SensorDeviceClass.DURATION,
+        native_unit_of_measurement=UnitOfTime.HOURS,
+        state_class=None,  # Next-start timers excluded from statistics
+        suggested_display_precision=2,
     ),
 )
 
@@ -1031,7 +1035,7 @@ ENTITY_DESCRIPTIONS = (
     *DAILY_LEVEL_SENSORS,
     *DAILY_RATING_SENSORS,
     *WINDOW_24H_SENSORS,
-    *FUTURE_AVG_SENSORS,
+    *FUTURE_MEAN_SENSORS,
     *FUTURE_TREND_SENSORS,
     *VOLATILITY_SENSORS,
     *BEST_PRICE_TIMING_SENSORS,

custom_components/tibber_prices/sensor/helpers.py

@@ -28,7 +28,7 @@ if TYPE_CHECKING:
 from custom_components.tibber_prices.const import get_display_unit_factor
 from custom_components.tibber_prices.coordinator.helpers import get_intervals_for_day_offsets
 from custom_components.tibber_prices.entity_utils.helpers import get_price_value
-from custom_components.tibber_prices.utils.average import calculate_median
+from custom_components.tibber_prices.utils.average import calculate_mean, calculate_median
 from custom_components.tibber_prices.utils.price import (
     aggregate_price_levels,
     aggregate_price_rating,
@@ -38,7 +38,7 @@ if TYPE_CHECKING:
     from collections.abc import Callable
 
 
-def aggregate_price_data(
+def aggregate_average_data(
     window_data: list[dict],
     config_entry: ConfigEntry,
 ) -> tuple[float | None, float | None]:
@@ -57,12 +57,12 @@ def aggregate_price_data(
     prices = [float(i["total"]) for i in window_data if "total" in i]
     if not prices:
         return None, None
-    # Calculate both average and median
-    avg = sum(prices) / len(prices)
+    # Calculate both mean and median
+    mean = calculate_mean(prices)
     median = calculate_median(prices)
     # Convert to display currency unit based on configuration
     factor = get_display_unit_factor(config_entry)
-    return round(avg * factor, 2), round(median * factor, 2) if median is not None else None
+    return round(mean * factor, 2), round(median * factor, 2) if median is not None else None
 
 
 def aggregate_level_data(window_data: list[dict]) -> str | None:
@@ -135,7 +135,7 @@ def aggregate_window_data(
     """
     # Map value types to aggregation functions
     aggregators: dict[str, Callable] = {
-        "price": lambda data: aggregate_price_data(data, config_entry)[0],  # Use only average from tuple
+        "price": lambda data: aggregate_average_data(data, config_entry)[0],  # Use only average from tuple
         "level": lambda data: aggregate_level_data(data),
         "rating": lambda data: aggregate_rating_data(data, threshold_low, threshold_high),
     }

custom_components/tibber_prices/sensor/value_getters.py

@@ -2,15 +2,16 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, cast
 
 from custom_components.tibber_prices.utils.average import (
-    calculate_current_leading_avg,
     calculate_current_leading_max,
+    calculate_current_leading_mean,
     calculate_current_leading_min,
-    calculate_current_trailing_avg,
     calculate_current_trailing_max,
+    calculate_current_trailing_mean,
     calculate_current_trailing_min,
+    calculate_mean,
     calculate_median,
 )
 
@@ -69,6 +70,14 @@ def get_value_getter_mapping(  # noqa: PLR0913 - needs all calculators as parame
         Dictionary mapping entity keys to their value getter callables.
 
     """
+
+    def _minutes_to_hours(value: float | None) -> float | None:
+        """Convert minutes to hours for duration-oriented sensors."""
+        if value is None:
+            return None
+
+        return value / 60
+
     return {
         # ================================================================
         # INTERVAL-BASED SENSORS - via IntervalCalculator
@@ -131,14 +140,14 @@ def get_value_getter_mapping(  # noqa: PLR0913 - needs all calculators as parame
         "highest_price_today": lambda: daily_stat_calculator.get_daily_stat_value(day="today", stat_func=max),
         "average_price_today": lambda: daily_stat_calculator.get_daily_stat_value(
             day="today",
-            stat_func=lambda prices: (sum(prices) / len(prices), calculate_median(prices)),
+            stat_func=lambda prices: (calculate_mean(prices), calculate_median(prices)),
         ),
         # Tomorrow statistics sensors
         "lowest_price_tomorrow": lambda: daily_stat_calculator.get_daily_stat_value(day="tomorrow", stat_func=min),
         "highest_price_tomorrow": lambda: daily_stat_calculator.get_daily_stat_value(day="tomorrow", stat_func=max),
         "average_price_tomorrow": lambda: daily_stat_calculator.get_daily_stat_value(
             day="tomorrow",
-            stat_func=lambda prices: (sum(prices) / len(prices), calculate_median(prices)),
+            stat_func=lambda prices: (calculate_mean(prices), calculate_median(prices)),
         ),
         # Daily aggregated level sensors
         "yesterday_price_level": lambda: daily_stat_calculator.get_daily_aggregated_value(
@@ -163,10 +172,10 @@ def get_value_getter_mapping(  # noqa: PLR0913 - needs all calculators as parame
         # ================================================================
         # Trailing and leading average sensors
         "trailing_price_average": lambda: window_24h_calculator.get_24h_window_value(
-            stat_func=calculate_current_trailing_avg,
+            stat_func=calculate_current_trailing_mean,
         ),
         "leading_price_average": lambda: window_24h_calculator.get_24h_window_value(
-            stat_func=calculate_current_leading_avg,
+            stat_func=calculate_current_leading_mean,
         ),
         # Trailing and leading min/max sensors
         "trailing_price_min": lambda: window_24h_calculator.get_24h_window_value(
@@ -242,11 +251,17 @@ def get_value_getter_mapping(  # noqa: PLR0913 - needs all calculators as parame
         "best_price_end_time": lambda: timing_calculator.get_period_timing_value(
             period_type="best_price", value_type="end_time"
         ),
-        "best_price_period_duration": lambda: timing_calculator.get_period_timing_value(
-            period_type="best_price", value_type="period_duration"
+        "best_price_period_duration": lambda: _minutes_to_hours(
+            cast(
+                "float | None",
+                timing_calculator.get_period_timing_value(period_type="best_price", value_type="period_duration"),
+            )
         ),
-        "best_price_remaining_minutes": lambda: timing_calculator.get_period_timing_value(
-            period_type="best_price", value_type="remaining_minutes"
+        "best_price_remaining_minutes": lambda: _minutes_to_hours(
+            cast(
+                "float | None",
+                timing_calculator.get_period_timing_value(period_type="best_price", value_type="remaining_minutes"),
+            )
         ),
         "best_price_progress": lambda: timing_calculator.get_period_timing_value(
             period_type="best_price", value_type="progress"
@@ -254,18 +269,27 @@ def get_value_getter_mapping(  # noqa: PLR0913 - needs all calculators as parame
         "best_price_next_start_time": lambda: timing_calculator.get_period_timing_value(
             period_type="best_price", value_type="next_start_time"
         ),
-        "best_price_next_in_minutes": lambda: timing_calculator.get_period_timing_value(
-            period_type="best_price", value_type="next_in_minutes"
+        "best_price_next_in_minutes": lambda: _minutes_to_hours(
+            cast(
+                "float | None",
+                timing_calculator.get_period_timing_value(period_type="best_price", value_type="next_in_minutes"),
+            )
         ),
         # Peak Price timing sensors
         "peak_price_end_time": lambda: timing_calculator.get_period_timing_value(
             period_type="peak_price", value_type="end_time"
         ),
-        "peak_price_period_duration": lambda: timing_calculator.get_period_timing_value(
-            period_type="peak_price", value_type="period_duration"
+        "peak_price_period_duration": lambda: _minutes_to_hours(
+            cast(
+                "float | None",
+                timing_calculator.get_period_timing_value(period_type="peak_price", value_type="period_duration"),
+            )
         ),
-        "peak_price_remaining_minutes": lambda: timing_calculator.get_period_timing_value(
-            period_type="peak_price", value_type="remaining_minutes"
+        "peak_price_remaining_minutes": lambda: _minutes_to_hours(
+            cast(
+                "float | None",
+                timing_calculator.get_period_timing_value(period_type="peak_price", value_type="remaining_minutes"),
+            )
         ),
         "peak_price_progress": lambda: timing_calculator.get_period_timing_value(
             period_type="peak_price", value_type="progress"
@@ -273,8 +297,11 @@ def get_value_getter_mapping(  # noqa: PLR0913 - needs all calculators as parame
         "peak_price_next_start_time": lambda: timing_calculator.get_period_timing_value(
             period_type="peak_price", value_type="next_start_time"
         ),
-        "peak_price_next_in_minutes": lambda: timing_calculator.get_period_timing_value(
-            period_type="peak_price", value_type="next_in_minutes"
+        "peak_price_next_in_minutes": lambda: _minutes_to_hours(
+            cast(
+                "float | None",
+                timing_calculator.get_period_timing_value(period_type="peak_price", value_type="next_in_minutes"),
+            )
         ),
         # Chart data export sensor
         "chart_data_export": get_chart_data_export_value,

custom_components/tibber_prices/services.yaml

@@ -46,12 +46,28 @@ get_apexcharts_yaml:
             - rating_level
             - level
           translation_key: level_type
+    resolution:
+      required: false
+      default: interval
+      example: interval
+      selector:
+        select:
+          options:
+            - interval
+            - hourly
+          translation_key: resolution
     highlight_best_price:
       required: false
       default: true
       example: true
       selector:
         boolean:
+    highlight_peak_price:
+      required: false
+      default: false
+      example: false
+      selector:
+        boolean:
 get_chartdata:
   fields:
     general:
@@ -245,3 +261,12 @@ refresh_user_data:
       selector:
         config_entry:
           integration: tibber_prices
+
+debug_clear_tomorrow:
+  fields:
+    entry_id:
+      required: false
+      example: "1234567890abcdef"
+      selector:
+        config_entry:
+          integration: tibber_prices

custom_components/tibber_prices/services/__init__.py

@@ -5,6 +5,7 @@ This package provides service endpoints for external integrations and data expor
 - Chart data export (get_chartdata)
 - ApexCharts YAML generation (get_apexcharts_yaml)
 - User data refresh (refresh_user_data)
+- Debug: Clear tomorrow data (debug_clear_tomorrow) - DevContainer only
 
 Architecture:
 - helpers.py: Common utilities (get_entry_and_data)
@@ -12,11 +13,13 @@ Architecture:
 - chartdata.py: Main data export service handler
 - apexcharts.py: ApexCharts card YAML generator
 - refresh_user_data.py: User data refresh handler
+- debug_clear_tomorrow.py: Debug tool for testing tomorrow refresh (dev only)
 
 """
 
 from __future__ import annotations
 
+import os
 from typing import TYPE_CHECKING
 
 from custom_components.tibber_prices.const import DOMAIN
@@ -42,6 +45,9 @@ __all__ = [
     "async_setup_services",
 ]
 
+# Check if running in development mode (DevContainer)
+_IS_DEV_MODE = os.environ.get("TIBBER_PRICES_DEV") == "1"
+
 
 @callback
 def async_setup_services(hass: HomeAssistant) -> None:
@@ -74,3 +80,19 @@ def async_setup_services(hass: HomeAssistant) -> None:
         schema=REFRESH_USER_DATA_SERVICE_SCHEMA,
         supports_response=SupportsResponse.ONLY,
     )
+
+    # Debug services - only available in DevContainer (TIBBER_PRICES_DEV=1)
+    if _IS_DEV_MODE:
+        from .debug_clear_tomorrow import (  # noqa: PLC0415 - Conditional import for dev-only service
+            DEBUG_CLEAR_TOMORROW_SERVICE_NAME,
+            DEBUG_CLEAR_TOMORROW_SERVICE_SCHEMA,
+            handle_debug_clear_tomorrow,
+        )
+
+        hass.services.async_register(
+            DOMAIN,
+            DEBUG_CLEAR_TOMORROW_SERVICE_NAME,
+            handle_debug_clear_tomorrow,
+            schema=DEBUG_CLEAR_TOMORROW_SERVICE_SCHEMA,
+            supports_response=SupportsResponse.ONLY,
+        )

custom_components/tibber_prices/services/debug_clear_tomorrow.py

@@ -0,0 +1,238 @@
+"""
+Debug service to clear tomorrow's data from the interval pool.
+
+This service is intended for testing the tomorrow data refresh cycle without
+having to wait for the next day or restart Home Assistant.
+
+WARNING: This is a debug/development tool. Use with caution in production.
+
+Usage:
+    service: tibber_prices.debug_clear_tomorrow
+    data: {}
+
+After calling this service:
+1. The tomorrow data will be removed from the interval pool
+2. The lifecycle sensor will show "searching_tomorrow" (after 13:00)
+3. The next Timer #1 cycle will fetch tomorrow data from the API
+4. You can observe the full refresh cycle in real-time
+
+"""
+
+from __future__ import annotations
+
+import logging
+from datetime import datetime, timedelta
+from typing import TYPE_CHECKING, Any
+
+import voluptuous as vol
+
+from custom_components.tibber_prices.const import DOMAIN
+
+if TYPE_CHECKING:
+    from custom_components.tibber_prices.coordinator import TibberPricesDataUpdateCoordinator
+    from homeassistant.core import ServiceCall, ServiceResponse
+
+_LOGGER = logging.getLogger(__name__)
+
+DEBUG_CLEAR_TOMORROW_SERVICE_NAME = "debug_clear_tomorrow"
+DEBUG_CLEAR_TOMORROW_SERVICE_SCHEMA = vol.Schema(
+    {
+        vol.Optional("entry_id"): str,
+    }
+)
+
+
+async def handle_debug_clear_tomorrow(call: ServiceCall) -> ServiceResponse:
+    """
+    Handle the debug_clear_tomorrow service call.
+
+    Removes tomorrow's intervals from the interval pool to allow testing
+    of the tomorrow data refresh cycle.
+
+    Returns:
+        Dict with operation results (intervals removed, pool stats before/after).
+
+    """
+    hass = call.hass
+
+    # Get entry_id from call data or use first available
+    entry_id = call.data.get("entry_id")
+
+    if entry_id:
+        entry = next(
+            (e for e in hass.config_entries.async_entries(DOMAIN) if e.entry_id == entry_id),
+            None,
+        )
+    else:
+        # Use first available entry
+        entries = hass.config_entries.async_entries(DOMAIN)
+        entry = entries[0] if entries else None
+
+    if not entry or not hasattr(entry, "runtime_data") or not entry.runtime_data:
+        return {"success": False, "error": "No valid config entry found"}
+
+    coordinator: TibberPricesDataUpdateCoordinator = entry.runtime_data.coordinator
+
+    # Get pool manager from coordinator
+    pool = coordinator._price_data_manager._interval_pool  # noqa: SLF001
+
+    # Get stats before
+    stats_before = pool.get_pool_stats()
+
+    # Calculate tomorrow's date range
+    now = coordinator.time.now()
+    now_local = coordinator.time.as_local(now)
+    tomorrow_start = (now_local + timedelta(days=1)).replace(hour=0, minute=0, second=0, microsecond=0)
+    tomorrow_end = (now_local + timedelta(days=2)).replace(hour=0, minute=0, second=0, microsecond=0)
+
+    _LOGGER.info(
+        "DEBUG: Clearing tomorrow's data from pool (range: %s to %s)",
+        tomorrow_start.isoformat(),
+        tomorrow_end.isoformat(),
+    )
+
+    # Remove tomorrow's intervals from the pool index
+    removed_count = await _clear_intervals_in_range(pool, tomorrow_start.isoformat(), tomorrow_end.isoformat())
+
+    # Also remove tomorrow's intervals from coordinator.data["priceInfo"]
+    # This ensures sensors show "unknown" for tomorrow data
+    removed_from_coordinator = _clear_intervals_from_coordinator(coordinator, tomorrow_start, tomorrow_end)
+
+    # Get stats after
+    stats_after = pool.get_pool_stats()
+
+    # Force coordinator to re-check tomorrow data status and update ALL sensors
+    # This updates the lifecycle sensor and makes tomorrow sensors show "unknown"
+    coordinator.async_update_listeners()
+
+    result: dict[str, Any] = {
+        "success": True,
+        "intervals_removed_from_pool": removed_count,
+        "intervals_removed_from_coordinator": removed_from_coordinator,
+        "tomorrow_range": {
+            "start": tomorrow_start.isoformat(),
+            "end": tomorrow_end.isoformat(),
+        },
+        "pool_stats_before": {
+            "cache_intervals_total": stats_before.get("cache_intervals_total"),
+            "cache_newest_interval": stats_before.get("cache_newest_interval"),
+        },
+        "pool_stats_after": {
+            "cache_intervals_total": stats_after.get("cache_intervals_total"),
+            "cache_newest_interval": stats_after.get("cache_newest_interval"),
+        },
+        "message": f"Removed {removed_count} tomorrow intervals. Next Timer #1 cycle will fetch new data.",
+    }
+
+    _LOGGER.info("DEBUG: Clear tomorrow complete - %s", result)
+
+    return result
+
+
+def _clear_intervals_from_coordinator(
+    coordinator: TibberPricesDataUpdateCoordinator,
+    start_dt: datetime,
+    end_dt: datetime,
+) -> int:
+    """
+    Remove intervals from coordinator.data["priceInfo"] in the given time range.
+
+    This ensures sensors show "unknown" for the removed intervals.
+
+    Args:
+        coordinator: TibberPricesDataUpdateCoordinator instance.
+        start_dt: Start datetime (inclusive).
+        end_dt: End datetime (exclusive).
+
+    Returns:
+        Number of intervals removed.
+
+    """
+    if not coordinator.data or "priceInfo" not in coordinator.data:
+        return 0
+
+    price_info = coordinator.data["priceInfo"]
+    original_count = len(price_info)
+
+    # Filter out intervals in the range
+    # Intervals have startsAt as datetime objects (after parse_all_timestamps)
+    filtered = []
+    for interval in price_info:
+        starts_at = interval.get("startsAt")
+        if starts_at is None:
+            filtered.append(interval)
+            continue
+
+        # Handle both datetime and string formats
+        starts_at_dt = datetime.fromisoformat(starts_at) if isinstance(starts_at, str) else starts_at
+
+        # Keep intervals outside the removal range
+        if starts_at_dt < start_dt or starts_at_dt >= end_dt:
+            filtered.append(interval)
+
+    # Update coordinator.data in place
+    coordinator.data["priceInfo"] = filtered
+
+    removed_count = original_count - len(filtered)
+    _LOGGER.debug(
+        "DEBUG: Removed %d intervals from coordinator.data (had %d, now %d)",
+        removed_count,
+        original_count,
+        len(filtered),
+    )
+
+    return removed_count
+
+
+async def _clear_intervals_in_range(
+    pool: Any,
+    start_iso: str,
+    end_iso: str,
+) -> int:
+    """
+    Remove intervals in the given time range from the pool.
+
+    This manipulates the pool's internal cache to remove specific intervals.
+    Used only for debug/testing purposes.
+
+    Args:
+        pool: IntervalPoolManager instance.
+        start_iso: ISO timestamp string (inclusive).
+        end_iso: ISO timestamp string (exclusive).
+
+    Returns:
+        Number of intervals removed.
+
+    """
+    # Access internal index
+    index = pool._index  # noqa: SLF001
+
+    # Parse range
+    start_dt = datetime.fromisoformat(start_iso)
+    end_dt = datetime.fromisoformat(end_iso)
+
+    # Find all timestamps in range
+    removed_count = 0
+    current_dt = start_dt
+
+    while current_dt < end_dt:
+        current_key = current_dt.isoformat()[:19]
+
+        # Check if this timestamp exists in index
+        location = index.get(current_key)
+        if location is not None:
+            # Remove from index
+            index.remove(current_key)
+            removed_count += 1
+
+        # Move to next 15-min interval
+        current_dt += timedelta(minutes=15)
+
+    # Note: We only remove from the index, not from the fetch_groups.
+    # The intervals will remain in fetch_groups but won't be found via index lookup.
+    # This is simpler and safe - GC will clean up orphaned intervals eventually.
+
+    # Persist the updated pool state via manager's save method
+    await pool._auto_save_pool_state()  # noqa: SLF001
+
+    return removed_count

custom_components/tibber_prices/services/formatters.py

@@ -24,6 +24,8 @@ from datetime import datetime, time
 from typing import Any
 
 from custom_components.tibber_prices.const import (
+    CONF_AVERAGE_SENSOR_DISPLAY,
+    DEFAULT_AVERAGE_SENSOR_DISPLAY,
     DEFAULT_PRICE_RATING_THRESHOLD_HIGH,
     DEFAULT_PRICE_RATING_THRESHOLD_LOW,
     get_translation,
@@ -32,6 +34,7 @@ from custom_components.tibber_prices.coordinator.helpers import (
     get_intervals_for_day_offsets,
 )
 from custom_components.tibber_prices.sensor.helpers import aggregate_level_data, aggregate_rating_data
+from custom_components.tibber_prices.utils.average import calculate_mean, calculate_median
 
 
 def normalize_level_filter(value: list[str] | None) -> list[str] | None:
@@ -48,6 +51,99 @@ def normalize_rating_level_filter(value: list[str] | None) -> list[str] | None:
     return [v.upper() for v in value]
 
 
+def aggregate_to_hourly(  # noqa: PLR0912
+    intervals: list[dict],
+    coordinator: Any,
+    threshold_low: float = DEFAULT_PRICE_RATING_THRESHOLD_LOW,
+    threshold_high: float = DEFAULT_PRICE_RATING_THRESHOLD_HIGH,
+) -> list[dict]:
+    """
+    Aggregate 15-minute intervals to hourly using rolling 5-interval window.
+
+    Preserves original field names (startsAt, total, level, rating_level) so the
+    aggregated data can be processed by the same code path as interval data.
+
+    Uses the same methodology as sensor rolling hour calculations:
+    - 5-interval window: 2 before + center + 2 after (60 minutes total)
+    - Center interval is at :00 of each hour
+    - Respects user's CONF_AVERAGE_SENSOR_DISPLAY setting (mean vs median)
+
+    Example for 10:00 data point:
+    - Window includes: 09:30, 09:45, 10:00, 10:15, 10:30
+
+    Args:
+        intervals: List of 15-minute price intervals with startsAt, total, level, rating_level
+        coordinator: Data update coordinator instance
+        threshold_low: Rating level threshold (low/normal boundary)
+        threshold_high: Rating level threshold (normal/high boundary)
+
+    Returns:
+        List of hourly data points with same structure as input (startsAt, total, level, rating_level)
+
+    """
+    if not intervals:
+        return []
+
+    # Get user's average display preference (mean or median)
+    average_display = coordinator.config_entry.options.get(CONF_AVERAGE_SENSOR_DISPLAY, DEFAULT_AVERAGE_SENSOR_DISPLAY)
+    use_median = average_display == "median"
+
+    hourly_data = []
+
+    # Iterate through all intervals, only process those at :00
+    for i, interval in enumerate(intervals):
+        start_time = interval.get("startsAt")
+
+        if not start_time:
+            continue
+
+        # Check if this is the start of an hour (:00)
+        if start_time.minute != 0:
+            continue
+
+        # Collect 5-interval rolling window: -2, -1, 0, +1, +2
+        window_prices: list[float] = []
+        window_intervals: list[dict] = []
+
+        for offset in range(-2, 3):  # -2, -1, 0, +1, +2
+            target_idx = i + offset
+            if 0 <= target_idx < len(intervals):
+                target_interval = intervals[target_idx]
+                price = target_interval.get("total")
+                if price is not None:
+                    window_prices.append(price)
+                    window_intervals.append(target_interval)
+
+        # Calculate aggregated price based on user preference
+        if window_prices:
+            aggregated_price = calculate_median(window_prices) if use_median else calculate_mean(window_prices)
+
+            if aggregated_price is None:
+                continue
+
+            # Build data point with original field names
+            data_point: dict[str, Any] = {
+                "startsAt": start_time,
+                "total": aggregated_price,
+            }
+
+            # Add aggregated level
+            if window_intervals:
+                aggregated_level = aggregate_level_data(window_intervals)
+                if aggregated_level:
+                    data_point["level"] = aggregated_level.upper()
+
+            # Add aggregated rating_level
+            if window_intervals:
+                aggregated_rating = aggregate_rating_data(window_intervals, threshold_low, threshold_high)
+                if aggregated_rating:
+                    data_point["rating_level"] = aggregated_rating.upper()
+
+            hourly_data.append(data_point)
+
+    return hourly_data
+
+
 def aggregate_hourly_exact(  # noqa: PLR0913, PLR0912, PLR0915
     intervals: list[dict],
     start_time_field: str,

custom_components/tibber_prices/services/get_apexcharts_yaml.py

@@ -63,7 +63,9 @@ APEXCHARTS_SERVICE_SCHEMA = vol.Schema(
         vol.Required(ATTR_ENTRY_ID): cv.string,
         vol.Optional("day"): vol.In(["yesterday", "today", "tomorrow", "rolling_window", "rolling_window_autozoom"]),
         vol.Optional("level_type", default="rating_level"): vol.In(["rating_level", "level"]),
+        vol.Optional("resolution", default="interval"): vol.In(["interval", "hourly"]),
         vol.Optional("highlight_best_price", default=True): cv.boolean,
+        vol.Optional("highlight_peak_price", default=False): cv.boolean,
     }
 )
 
@@ -295,7 +297,9 @@ async def handle_apexcharts_yaml(call: ServiceCall) -> dict[str, Any]:  # noqa:
 
     day = call.data.get("day")  # Can be None (rolling window mode)
     level_type = call.data.get("level_type", "rating_level")
+    resolution = call.data.get("resolution", "interval")
     highlight_best_price = call.data.get("highlight_best_price", True)
+    highlight_peak_price = call.data.get("highlight_peak_price", False)
 
     # Get user's language from hass config
     user_language = hass.config.language or "en"
@@ -310,6 +314,10 @@ async def handle_apexcharts_yaml(call: ServiceCall) -> dict[str, Any]:  # noqa:
     use_subunit = display_mode == DISPLAY_MODE_SUBUNIT
     price_unit = get_display_unit_string(config_entry, currency)
 
+    # Add average symbol suffix for hourly resolution (suffix to avoid confusion with øre/öre)
+    if resolution == "hourly":
+        price_unit = f"{price_unit} (Ø)"
+
     # Get entity registry for mapping
     entity_registry = async_get_entity_registry(hass)
 
@@ -333,8 +341,20 @@ async def handle_apexcharts_yaml(call: ServiceCall) -> dict[str, Any]:  # noqa:
         ]
     series = []
 
-    # Get translated name for best price periods (needed for layer)
-    best_price_name = get_translation(["apexcharts", "best_price_period_name"], user_language) or "Best Price Period"
+    # Get translated names for overlays (best/peak)
+    # Include triangle icons for visual distinction in legend
+    # ▼ (U+25BC) = down/minimum = best price periods
+    # ▲ (U+25B2) = up/maximum = peak price periods
+    best_price_name = "▼ " + (
+        get_translation(["apexcharts", "best_price_period_name"], user_language) or "Best Price Period"
+    )
+    peak_price_name = "▲ " + (
+        get_translation(["apexcharts", "peak_price_period_name"], user_language) or "Peak Price Period"
+    )
+
+    # Track overlays added for tooltip index calculation later
+    best_overlay_added = False
+    peak_overlay_added = False
 
     # Add best price period highlight overlay FIRST (so it renders behind all other series)
     if highlight_best_price and entity_map:
@@ -354,7 +374,7 @@ async def handle_apexcharts_yaml(call: ServiceCall) -> dict[str, Any]:  # noqa:
             f"service: 'get_chartdata', "
             f"return_response: true, "
             f"service_data: {{ entry_id: '{entry_id}', {day_param}"
-            f"period_filter: 'best_price', "
+            f"period_filter: 'best_price', resolution: '{resolution}', "
             f"output_format: 'array_of_arrays', insert_nulls: 'segments', subunit_currency: {subunit_param} }} }}); "
             f"const originalData = response.response.data; "
             f"return originalData.map((point, i) => {{ "
@@ -367,6 +387,11 @@ async def handle_apexcharts_yaml(call: ServiceCall) -> dict[str, Any]:  # noqa:
         # Use first entity from entity_map (reuse existing entity to avoid extra header entries)
         best_price_entity = next(iter(entity_map.values()))
 
+        # Legend toggle logic:
+        # - Only best price selected: no legend (in_legend: False)
+        # - Both selected: show in legend, toggleable (in_legend: True)
+        best_price_in_legend = highlight_peak_price  # Only show in legend if peak is also enabled
+
         series.append(
             {
                 "entity": best_price_entity,
@@ -374,11 +399,56 @@ async def handle_apexcharts_yaml(call: ServiceCall) -> dict[str, Any]:  # noqa:
                 "type": "area",
                 "color": "rgba(46, 204, 113, 0.05)",  # Ultra-subtle green overlay (barely visible)
                 "yaxis_id": "highlight",  # Use separate Y-axis (0-1) for full-height overlay
-                "show": {"legend_value": False, "in_header": False, "in_legend": False},
+                "show": {"legend_value": False, "in_header": False, "in_legend": best_price_in_legend},
                 "data_generator": best_price_generator,
                 "stroke_width": 0,
             }
         )
+        best_overlay_added = True
+
+    # Add peak price period highlight overlay (renders behind series as well)
+    if highlight_peak_price and entity_map:
+        # Conditionally include day parameter (omit for rolling window mode)
+        day_param = "" if day in ("rolling_window", "rolling_window_autozoom", None) else f"day: ['{day}'], "
+        subunit_param = "true" if use_subunit else "false"
+        peak_price_generator = (
+            f"const response = await hass.callWS({{ "
+            f"type: 'call_service', "
+            f"domain: 'tibber_prices', "
+            f"service: 'get_chartdata', "
+            f"return_response: true, "
+            f"service_data: {{ entry_id: '{entry_id}', {day_param}"
+            f"period_filter: 'peak_price', resolution: '{resolution}', "
+            f"output_format: 'array_of_arrays', insert_nulls: 'segments', subunit_currency: {subunit_param} }} }}); "
+            f"const originalData = response.response.data; "
+            f"return originalData.map((point, i) => {{ "
+            f"const result = [point[0], point[1] === null ? null : 1]; "
+            f"result.originalPrice = point[1]; "
+            f"return result; "
+            f"}});"
+        )
+
+        peak_price_entity = next(iter(entity_map.values()))
+
+        # Peak price: always show in legend when enabled (for toggle), start hidden by default
+        series.append(
+            {
+                "entity": peak_price_entity,
+                "name": peak_price_name,
+                "type": "area",
+                "color": "rgba(231, 76, 60, 0.06)",  # Subtle red overlay for peak price
+                "yaxis_id": "highlight",
+                "show": {
+                    "legend_value": False,
+                    "in_header": False,
+                    "in_legend": True,
+                    "hidden_by_default": True,  # Start hidden, user can toggle via legend
+                },
+                "data_generator": peak_price_generator,
+                "stroke_width": 0,
+            }
+        )
+        peak_overlay_added = True
 
     # Only create series for levels that have a matching entity (filter out missing levels)
     for level_key, color in series_levels:
@@ -409,7 +479,7 @@ async def handle_apexcharts_yaml(call: ServiceCall) -> dict[str, Any]:  # noqa:
                 f"domain: 'tibber_prices', "
                 f"service: 'get_chartdata', "
                 f"return_response: true, "
-                f"service_data: {{ entry_id: '{entry_id}', {day_param}{filter_param}, "
+                f"service_data: {{ entry_id: '{entry_id}', {day_param}{filter_param}, resolution: '{resolution}', "
                 f"output_format: 'array_of_arrays', insert_nulls: 'segments', subunit_currency: {subunit_param}, "
                 f"connect_segments: true }} }}); "
                 f"return response.response.data;"
@@ -422,7 +492,7 @@ async def handle_apexcharts_yaml(call: ServiceCall) -> dict[str, Any]:  # noqa:
                 f"domain: 'tibber_prices', "
                 f"service: 'get_chartdata', "
                 f"return_response: true, "
-                f"service_data: {{ entry_id: '{entry_id}', {day_param}{filter_param}, "
+                f"service_data: {{ entry_id: '{entry_id}', {day_param}{filter_param}, resolution: '{resolution}', "
                 f"output_format: 'array_of_arrays', insert_nulls: 'segments', subunit_currency: {subunit_param}, "
                 f"connect_segments: true }} }}); "
                 f"return response.response.data;"
@@ -431,10 +501,13 @@ async def handle_apexcharts_yaml(call: ServiceCall) -> dict[str, Any]:  # noqa:
         # rating_level LOW/HIGH: Show raw state in header (entity state = min/max price of day)
         # rating_level NORMAL: Hide from header (not meaningful as extrema)
         # level (VERY_CHEAP/CHEAP/etc): Hide from header (entity state is aggregated value)
+        # Price level series are hidden from legend only when best/peak overlays are enabled
+        # (to keep legend clean for toggle-only items)
+        hide_from_legend = highlight_best_price or highlight_peak_price
         if level_type == "rating_level" and level_key in (PRICE_RATING_LOW, PRICE_RATING_HIGH):
-            show_config = {"legend_value": False, "in_header": "raw"}
+            show_config = {"legend_value": False, "in_header": "raw", "in_legend": not hide_from_legend}
         else:
-            show_config = {"legend_value": False, "in_header": False}
+            show_config = {"legend_value": False, "in_header": False, "in_legend": not hide_from_legend}
 
         series.append(
             {
@@ -463,6 +536,11 @@ async def handle_apexcharts_yaml(call: ServiceCall) -> dict[str, Any]:  # noqa:
         day_translated = get_translation(["selector", "day", "options", day], user_language) or day.capitalize()
         title = f"{title} - {day_translated}"
 
+    # Add hourly suffix to title when using hourly resolution
+    if resolution == "hourly":
+        hourly_suffix = get_translation(["apexcharts", "hourly_suffix"], user_language) or "(Ø hourly)"
+        title = f"{title} {hourly_suffix}"
+
     # Configure span based on selected day
     # For rolling window modes, use config-template-card for dynamic config
     if day == "yesterday":
@@ -522,10 +600,23 @@ async def handle_apexcharts_yaml(call: ServiceCall) -> dict[str, Any]:  # noqa:
                 },
             },
             "dataLabels": {"enabled": False},
+            # Legend is shown only when peak price is enabled (for toggling visibility)
+            # - Only best price: no legend needed
+            # - Peak price (with or without best): show legend for toggle
             "legend": {
-                "show": False,
+                "show": highlight_peak_price,
                 "position": "bottom",
                 "horizontalAlign": "center",
+                # Custom markers only when overlays are enabled (hide color dots, use text icons)
+                # Without overlays: use default markers so user can enable legend with just show: true
+                **(
+                    {
+                        "markers": {"size": 0},
+                        "itemMargin": {"horizontal": 15},
+                    }
+                    if highlight_peak_price
+                    else {}
+                ),
             },
             "grid": {
                 "show": True,
@@ -546,7 +637,9 @@ async def handle_apexcharts_yaml(call: ServiceCall) -> dict[str, Any]:  # noqa:
             },
             "tooltip": {
                 "enabled": True,
-                "enabledOnSeries": [1, 2, 3, 4, 5],  # Enable for all price level series
+                "shared": True,  # Combine tooltips from all series at same x-value
+                # enabledOnSeries will be set dynamically below based on overlays
+                "enabledOnSeries": [],
                 "marker": {
                     "show": False,
                 },
@@ -566,6 +659,10 @@ async def handle_apexcharts_yaml(call: ServiceCall) -> dict[str, Any]:  # noqa:
                 "max": 1,
                 "show": False,  # Hide this axis (only for highlight overlay)
                 "opposite": True,
+                "apex_config": {
+                    "forceNiceScale": True,
+                    "tickAmount": 4,
+                },
             },
         ],
         "now": (
@@ -579,6 +676,15 @@ async def handle_apexcharts_yaml(call: ServiceCall) -> dict[str, Any]:  # noqa:
         "series": series,
     }
 
+    # Dynamically set tooltip enabledOnSeries to exclude overlay indices
+    overlay_count = (1 if best_overlay_added else 0) + (1 if peak_overlay_added else 0)
+    result["apex_config"]["tooltip"]["enabledOnSeries"] = list(range(overlay_count, len(series)))
+
+    # Enable hidden_by_default experimental feature when peak price is enabled
+    # This allows peak price overlay to start hidden but be toggled via legend click
+    if highlight_peak_price:
+        result["experimental"] = {"hidden_by_default": True}
+
     # For rolling window mode and today_tomorrow, wrap in config-template-card for dynamic config
     if use_template:
         # Find tomorrow_data_available binary sensor
@@ -694,6 +800,8 @@ async def handle_apexcharts_yaml(call: ServiceCall) -> dict[str, Any]:  # noqa:
                             "title": {"text": price_unit},
                             "decimalsInFloat": 0 if use_subunit else 1,
                             "forceNiceScale": True,
+                            "showAlways": True,
+                            "tickAmount": 4,
                         },
                     }
 
@@ -712,6 +820,8 @@ async def handle_apexcharts_yaml(call: ServiceCall) -> dict[str, Any]:  # noqa:
                             "title": {"text": price_unit},
                             "decimalsInFloat": 0 if use_subunit else 1,
                             "forceNiceScale": True,
+                            "showAlways": True,
+                            "tickAmount": 4,
                         },
                     }
 
@@ -742,6 +852,10 @@ async def handle_apexcharts_yaml(call: ServiceCall) -> dict[str, Any]:  # noqa:
                                 "max": 1,
                                 "show": False,
                                 "opposite": True,
+                                "apex_config": {
+                                    "forceNiceScale": True,
+                                    "tickAmount": 4,
+                                },
                             },
                         ],
                         "apex_config": {
@@ -851,6 +965,8 @@ async def handle_apexcharts_yaml(call: ServiceCall) -> dict[str, Any]:  # noqa:
                         "title": {"text": price_unit},
                         "decimalsInFloat": 0 if use_subunit else 1,
                         "forceNiceScale": True,
+                        "showAlways": True,
+                        "tickAmount": 4,
                     },
                 }
 
@@ -869,6 +985,8 @@ async def handle_apexcharts_yaml(call: ServiceCall) -> dict[str, Any]:  # noqa:
                         "title": {"text": price_unit},
                         "decimalsInFloat": 0 if use_subunit else 1,
                         "forceNiceScale": True,
+                        "showAlways": True,
+                        "tickAmount": 4,
                     },
                 }
 
@@ -901,6 +1019,10 @@ async def handle_apexcharts_yaml(call: ServiceCall) -> dict[str, Any]:  # noqa:
                             "max": 1,
                             "show": False,
                             "opposite": True,
+                            "apex_config": {
+                                "forceNiceScale": True,
+                                "tickAmount": 4,
+                            },
                         },
                     ],
                     "apex_config": {

custom_components/tibber_prices/services/get_chartdata.py

@@ -36,11 +36,13 @@ from custom_components.tibber_prices.const import (
     DOMAIN,
     PRICE_LEVEL_CHEAP,
     PRICE_LEVEL_EXPENSIVE,
+    PRICE_LEVEL_MAPPING,
     PRICE_LEVEL_NORMAL,
     PRICE_LEVEL_VERY_CHEAP,
     PRICE_LEVEL_VERY_EXPENSIVE,
     PRICE_RATING_HIGH,
     PRICE_RATING_LOW,
+    PRICE_RATING_MAPPING,
     PRICE_RATING_NORMAL,
     format_price_unit_base,
     format_price_unit_subunit,
@@ -52,13 +54,44 @@ from custom_components.tibber_prices.coordinator.helpers import (
 )
 from homeassistant.exceptions import ServiceValidationError
 
-from .formatters import aggregate_hourly_exact, get_period_data, normalize_level_filter, normalize_rating_level_filter
+from .formatters import (
+    aggregate_to_hourly,
+    get_period_data,
+    normalize_level_filter,
+    normalize_rating_level_filter,
+)
 from .helpers import get_entry_and_data, has_tomorrow_data
 
 if TYPE_CHECKING:
     from homeassistant.core import ServiceCall
 
 
+def _is_transition_to_more_expensive(
+    current_value: str | None,
+    next_value: str | None,
+    *,
+    use_rating: bool = False,
+) -> bool:
+    """
+    Check if transition from current to next level/rating is to a more expensive segment.
+
+    Args:
+        current_value: Current level or rating value
+        next_value: Next level or rating value
+        use_rating: If True, use rating hierarchy; if False, use level hierarchy
+
+    Returns:
+        True if transitioning to a more expensive segment
+
+    """
+    hierarchy = PRICE_RATING_MAPPING if use_rating else PRICE_LEVEL_MAPPING
+
+    current_rank = hierarchy.get(current_value, 0) if current_value else 0
+    next_rank = hierarchy.get(next_value, 0) if next_value else 0
+
+    return next_rank > current_rank
+
+
 def _calculate_metadata(  # noqa: PLR0912, PLR0913, PLR0915
     chart_data: list[dict[str, Any]],
     price_field: str,
@@ -146,12 +179,12 @@ def _calculate_metadata(  # noqa: PLR0912, PLR0913, PLR0915
             return {}
         min_val = min(data)
         max_val = max(data)
-        avg_val = sum(data) / len(data)
+        mean_val = sum(data) / len(data)
         median_val = sorted(data)[len(data) // 2]
 
-        # Calculate avg_position and median_position (0-1 scale)
+        # Calculate mean_position and median_position (0-1 scale)
         price_range = max_val - min_val
-        avg_position = (avg_val - min_val) / price_range if price_range > 0 else 0.5
+        mean_position = (mean_val - min_val) / price_range if price_range > 0 else 0.5
         median_position = (median_val - min_val) / price_range if price_range > 0 else 0.5
 
         # Position precision: 2 decimals for subunit currency, 4 for base currency
@@ -162,8 +195,8 @@ def _calculate_metadata(  # noqa: PLR0912, PLR0913, PLR0915
         return {
             "min": round(min_val, price_decimals),
             "max": round(max_val, price_decimals),
-            "avg": round(avg_val, price_decimals),
-            "avg_position": round(avg_position, position_decimals),
+            "mean": round(mean_val, price_decimals),
+            "mean_position": round(mean_position, position_decimals),
             "median": round(median_val, price_decimals),
             "median_position": round(median_position, position_decimals),
         }
@@ -195,16 +228,29 @@ def _calculate_metadata(  # noqa: PLR0912, PLR0913, PLR0915
     # Determine interval duration in minutes based on resolution
     interval_duration_minutes = 15 if resolution == "interval" else 60
 
-    # Calculate suggested yaxis bounds
-    # For subunit currency (ct, øre): integer values (floor/ceil)
-    # For base currency (€, kr): 2 decimal places precision
+    # Calculate suggested yaxis bounds with proportional padding
+    # Goal: Same visual "airiness" regardless of price range
+    # Strategy: Add padding proportional to data range (min/max spread)
+    if combined_stats:
+        data_range = combined_stats["max"] - combined_stats["min"]
+
+        # Calculate padding: ~8% of data range below min, ~15% above max
+        # These percentages match the visual spacing seen in well-scaled charts
+        padding_below = data_range * 0.08
+        padding_above = data_range * 0.15
+
         if subunit_currency:
-        yaxis_min = math.floor(combined_stats["min"]) - 1 if combined_stats else 0
-        yaxis_max = math.ceil(combined_stats["max"]) + 1 if combined_stats else 100
+            # Subunit (ct, øre): round to 1 decimal for cleaner axis labels
+            yaxis_min = round(combined_stats["min"] - padding_below, 1)
+            yaxis_max = round(combined_stats["max"] + padding_above, 1)
         else:
-        # Base currency: round to 2 decimal places with padding
-        yaxis_min = round(math.floor(combined_stats["min"] * 100) / 100 - 0.01, 2) if combined_stats else 0
-        yaxis_max = round(math.ceil(combined_stats["max"] * 100) / 100 + 0.01, 2) if combined_stats else 1.0
+            # Base currency (€, kr): round to 2 decimals
+            yaxis_min = round(combined_stats["min"] - padding_below, 2)
+            yaxis_max = round(combined_stats["max"] + padding_above, 2)
+    else:
+        # Fallback for empty data
+        yaxis_min = 0
+        yaxis_max = 100 if subunit_currency else 1.0
 
     return {
         "currency": currency_obj,
@@ -455,19 +501,26 @@ async def handle_chartdata(call: ServiceCall) -> dict[str, Any]:  # noqa: PLR091
         all_timestamps = {interval["startsAt"] for interval in day_intervals if interval.get("startsAt")}
         all_timestamps = sorted(all_timestamps)
 
-    # Calculate average if requested
-    day_averages = {}
-    if include_average:
+    # Calculate average if requested (per day for average_field)
+    # Also build a mapping from date -> day_key for later lookup
+    day_averages: dict[str, float] = {}
+    date_to_day_key: dict[Any, str] = {}  # Maps date object to "yesterday"/"today"/"tomorrow"
+
     for day in days:
         # Use helper to get intervals for this day
-            # Build minimal coordinator_data for single day query
         # Map day key to offset: yesterday=-1, today=0, tomorrow=1
         day_offset = {"yesterday": -1, "today": 0, "tomorrow": 1}[day]
         day_intervals = get_intervals_for_day_offsets(coordinator.data, [day_offset])
 
-            # Collect prices from intervals
-            prices = [p["total"] for p in day_intervals if p.get("total") is not None]
+        # Build date -> day_key mapping from actual interval data
+        for interval in day_intervals:
+            start_time = interval.get("startsAt")
+            if start_time and hasattr(start_time, "date"):
+                date_to_day_key[start_time.date()] = day
 
+        # Calculate average if requested
+        if include_average:
+            prices = [p["total"] for p in day_intervals if p.get("total") is not None]
             if prices:
                 avg = sum(prices) / len(prices)
                 # Apply same transformations as to regular prices
@@ -476,20 +529,39 @@ async def handle_chartdata(call: ServiceCall) -> dict[str, Any]:  # noqa: PLR091
                     avg = round(avg, round_decimals)
                 day_averages[day] = avg
 
-    for day in days:
-        # Use helper to get intervals for this day
-        # Map day key to offset: yesterday=-1, today=0, tomorrow=1
-        day_offset = {"yesterday": -1, "today": 0, "tomorrow": 1}[day]
-        day_prices = get_intervals_for_day_offsets(coordinator.data, [day_offset])
+    # Collect ALL intervals for the selected days as one continuous list
+    # This simplifies processing - no special midnight handling needed
+    day_offsets = [{"yesterday": -1, "today": 0, "tomorrow": 1}[day] for day in days]
+    all_prices = get_intervals_for_day_offsets(coordinator.data, day_offsets)
 
-        if resolution == "interval":
-            # Original 15-minute intervals
+    # For hourly resolution, aggregate BEFORE processing
+    # This keeps the same data format (startsAt, total, level, rating_level)
+    # so all subsequent code (filters, insert_nulls, etc.) works unchanged
+    if resolution == "hourly":
+        all_prices = aggregate_to_hourly(
+            all_prices,
+            coordinator=coordinator,
+            threshold_low=threshold_low,
+            threshold_high=threshold_high,
+        )
+        # Also update all_timestamps for insert_nulls='all' mode
+        all_timestamps = sorted({interval["startsAt"] for interval in all_prices if interval.get("startsAt")})
+
+    # Helper to get day key from interval timestamp for average lookup
+    def _get_day_key_for_interval(interval_start: Any) -> str | None:
+        """Determine which day key (yesterday/today/tomorrow) an interval belongs to."""
+        if not interval_start or not hasattr(interval_start, "date"):
+            return None
+        # Use pre-built mapping from actual interval data (TimeService-compatible)
+        return date_to_day_key.get(interval_start.date())
+
+    # Process price data - same logic handles both interval and hourly resolution
+    # (hourly data was already aggregated above, but has the same format)
+    if resolution in ("interval", "hourly"):
         if insert_nulls == "all" and (level_filter or rating_level_filter):
             # Mode 'all': Insert NULL for all timestamps where filter doesn't match
             # Build a map of timestamp -> interval for quick lookup
-                interval_map = {
-                    interval.get("startsAt"): interval for interval in day_prices if interval.get("startsAt")
-                }
+            interval_map = {interval.get("startsAt"): interval for interval in all_prices if interval.get("startsAt")}
 
             # Process all timestamps, filling gaps with NULL
             for start_time in all_timestamps:
@@ -534,19 +606,22 @@ async def handle_chartdata(call: ServiceCall) -> dict[str, Any]:  # noqa: PLR091
                     data_point[rating_level_field] = interval["rating_level"]
 
                 # Add average if requested
-                    if include_average and day in day_averages:
-                        data_point[average_field] = day_averages[day]
+                day_key = _get_day_key_for_interval(start_time)
+                if include_average and day_key and day_key in day_averages:
+                    data_point[average_field] = day_averages[day_key]
 
                 chart_data.append(data_point)
+
         elif insert_nulls == "segments" and (level_filter or rating_level_filter):
             # Mode 'segments': Add NULL points at segment boundaries for clean gaps
-                # Determine which field to check based on filter type
+            # Process ALL intervals as one continuous list - no special midnight handling needed
             filter_field = "rating_level" if rating_level_filter else "level"
             filter_values = rating_level_filter if rating_level_filter else level_filter
+            use_rating = rating_level_filter is not None
 
-                for i in range(len(day_prices) - 1):
-                    interval = day_prices[i]
-                    next_interval = day_prices[i + 1]
+            for i in range(len(all_prices) - 1):
+                interval = all_prices[i]
+                next_interval = all_prices[i + 1]
 
                 start_time = interval.get("startsAt")
                 price = interval.get("total")
@@ -558,6 +633,8 @@ async def handle_chartdata(call: ServiceCall) -> dict[str, Any]:  # noqa: PLR091
 
                 interval_value = interval.get(filter_field)
                 next_value = next_interval.get(filter_field)
+                prev_value = all_prices[i - 1].get(filter_field) if i > 0 else None
+                prev_price = all_prices[i - 1].get("total") if i > 0 else None
 
                 # Check if current interval matches filter
                 if interval_value in filter_values:  # type: ignore[operator]
@@ -566,11 +643,18 @@ async def handle_chartdata(call: ServiceCall) -> dict[str, Any]:  # noqa: PLR091
                     if round_decimals is not None:
                         converted_price = round(converted_price, round_decimals)
 
-                        # Add current point
+                    # Check if this is the START of a new segment (previous interval had different level)
+                    # and the transition was from a CHEAPER level (price increase)
+                    is_segment_start = prev_value != interval_value and prev_value not in filter_values  # type: ignore[operator]
+                    is_from_cheaper = (
+                        _is_transition_to_more_expensive(prev_value, interval_value, use_rating=use_rating)
+                        if prev_value
+                        else False
+                    )
+
+                    # Add current point FIRST (tooltip will show here - at the actual price!)
                     data_point = {
-                            start_time_field: start_time.isoformat()
-                            if hasattr(start_time, "isoformat")
-                            else start_time,
+                        start_time_field: start_time.isoformat() if hasattr(start_time, "isoformat") else start_time,
                         price_field: converted_price,
                     }
 
@@ -578,12 +662,43 @@ async def handle_chartdata(call: ServiceCall) -> dict[str, Any]:  # noqa: PLR091
                         data_point[level_field] = interval["level"]
                     if include_rating_level and "rating_level" in interval:
                         data_point[rating_level_field] = interval["rating_level"]
-                        if include_average and day in day_averages:
-                            data_point[average_field] = day_averages[day]
+
+                    day_key = _get_day_key_for_interval(start_time)
+                    if include_average and day_key and day_key in day_averages:
+                        data_point[average_field] = day_averages[day_key]
 
                     chart_data.append(data_point)
 
-                        # Check if next interval is different level (segment boundary)
+                    # AFTER the real point: Add END-BRIDGE to draw vertical line DOWN to previous price
+                    # This ensures the vertical upward transition line is drawn in THIS (more expensive) color
+                    # but the tooltip shows the actual (higher) price
+                    if connect_segments and is_segment_start and is_from_cheaper and prev_price is not None:
+                        converted_prev_price = round(prev_price * 100, 2) if subunit_currency else round(prev_price, 4)
+                        if round_decimals is not None:
+                            converted_prev_price = round(converted_prev_price, round_decimals)
+
+                        # End-bridge: draws line DOWN to previous (cheaper) price
+                        end_bridge = {
+                            start_time_field: start_time.isoformat()
+                            if hasattr(start_time, "isoformat")
+                            else start_time,
+                            price_field: converted_prev_price,  # Go DOWN to previous (cheaper) price
+                        }
+                        if include_level and "level" in interval:
+                            end_bridge[level_field] = interval["level"]  # Keep THIS level for color
+                        if include_rating_level and "rating_level" in interval:
+                            end_bridge[rating_level_field] = interval["rating_level"]
+                        if include_average and day_key and day_key in day_averages:
+                            end_bridge[average_field] = day_averages[day_key]
+                        chart_data.append(end_bridge)
+
+                        # NULL to stop this "bridge sequence" - prevents line from going to next point
+                        null_point = {start_time_field: data_point[start_time_field], price_field: None}
+                        chart_data.append(null_point)
+
+                    chart_data.append(data_point)
+
+                    # Check if next interval is different level (segment boundary = END of this segment)
                     if next_value != interval_value:
                         next_start_serialized = (
                             next_start_time.isoformat()
@@ -591,19 +706,45 @@ async def handle_chartdata(call: ServiceCall) -> dict[str, Any]:  # noqa: PLR091
                             else next_start_time
                         )
 
-                            if connect_segments and next_price is not None:
-                                # Connect segments visually by adding bridge point + NULL
-                                # Bridge point: extends current series to boundary with next price
-                                # NULL point: stops series so it doesn't continue into next segment
+                        is_to_more_expensive = _is_transition_to_more_expensive(
+                            interval_value, next_value, use_rating=use_rating
+                        )
 
+                        if connect_segments and next_price is not None:
+                            # Connect segments visually at boundaries
+                            # Strategy: The vertical line should be drawn by the MORE EXPENSIVE segment
+                            #
+                            # - Price INCREASE (cheap → expensive): Vertical line belongs to NEXT segment
+                            #   → THIS segment just holds at current price, NEXT segment draws the bridge UP
+                            #   → We add a hold point here, the start-bridge logic handles the NEXT segment
+                            #
+                            # - Price DECREASE (expensive → cheap): Vertical line belongs to THIS segment
+                            #   → THIS segment draws the bridge DOWN to next price
+
+                            if is_to_more_expensive:
+                                # Transition to MORE EXPENSIVE level (price increase)
+                                # Just hold at current price - the NEXT segment will draw the upward line
+                                # via its start-bridge logic
+                                hold_point = {
+                                    start_time_field: next_start_serialized,
+                                    price_field: converted_price,  # Hold at CURRENT price
+                                }
+                                if include_level and "level" in interval:
+                                    hold_point[level_field] = interval["level"]
+                                if include_rating_level and "rating_level" in interval:
+                                    hold_point[rating_level_field] = interval["rating_level"]
+                                if include_average and day_key and day_key in day_averages:
+                                    hold_point[average_field] = day_averages[day_key]
+                                chart_data.append(hold_point)
+                            else:
+                                # Transition to LESS EXPENSIVE or SAME level (price decrease/stable)
+                                # Draw the bridge DOWN to the next price in THIS level's color
                                 converted_next_price = (
                                     round(next_price * 100, 2) if subunit_currency else round(next_price, 4)
                                 )
                                 if round_decimals is not None:
                                     converted_next_price = round(converted_next_price, round_decimals)
 
-                                # 1. Bridge point: boundary with next price, still current level
-                                # This makes the line go up/down to meet the next series
                                 bridge_point = {
                                     start_time_field: next_start_serialized,
                                     price_field: converted_next_price,
@@ -612,12 +753,11 @@ async def handle_chartdata(call: ServiceCall) -> dict[str, Any]:  # noqa: PLR091
                                     bridge_point[level_field] = interval["level"]
                                 if include_rating_level and "rating_level" in interval:
                                     bridge_point[rating_level_field] = interval["rating_level"]
-                                if include_average and day in day_averages:
-                                    bridge_point[average_field] = day_averages[day]
+                                if include_average and day_key and day_key in day_averages:
+                                    bridge_point[average_field] = day_averages[day_key]
                                 chart_data.append(bridge_point)
 
-                                # 2. NULL point: stops the current series
-                                # Without this, ApexCharts continues drawing within the series
+                            # NULL point: stops the current series
                             null_point = {start_time_field: next_start_serialized, price_field: None}
                             chart_data.append(null_point)
                         else:
@@ -630,79 +770,69 @@ async def handle_chartdata(call: ServiceCall) -> dict[str, Any]:  # noqa: PLR091
                                 hold_point[level_field] = interval["level"]
                             if include_rating_level and "rating_level" in interval:
                                 hold_point[rating_level_field] = interval["rating_level"]
-                                if include_average and day in day_averages:
-                                    hold_point[average_field] = day_averages[day]
+                            if include_average and day_key and day_key in day_averages:
+                                hold_point[average_field] = day_averages[day_key]
                             chart_data.append(hold_point)
 
                             # Add NULL point to create gap
                             null_point = {start_time_field: next_start_serialized, price_field: None}
                             chart_data.append(null_point)
 
-                # Handle last interval of the day - extend to midnight
-                if day_prices:
-                    last_interval = day_prices[-1]
+            # Handle LAST interval of the entire selection (not per-day)
+            # The main loop processes up to n-1, so we need to add the last interval
+            if all_prices:
+                last_interval = all_prices[-1]
                 last_start_time = last_interval.get("startsAt")
                 last_price = last_interval.get("total")
                 last_value = last_interval.get(filter_field)
 
                 if last_start_time and last_price is not None and last_value in filter_values:  # type: ignore[operator]
-                        # Timestamp is already datetime in local timezone
-                        last_dt = last_start_time  # Already datetime object
-                        if last_dt:
-                            # Calculate next day at 00:00
-                            next_day = last_dt.replace(hour=0, minute=0, second=0, microsecond=0)
-                            next_day = next_day + timedelta(days=1)
-                            midnight_timestamp = next_day.isoformat()
-
-                            # Try to get real price from tomorrow's first interval
-                            next_day_name = None
-                            if day == "yesterday":
-                                next_day_name = "today"
-                            elif day == "today":
-                                next_day_name = "tomorrow"
-                            # For "tomorrow", we don't have a "day after tomorrow"
-
-                            midnight_price = None
-                            midnight_interval = None
-
-                            if next_day_name:
-                                # Use helper to get first interval of next day
-                                # Map day key to offset: yesterday=-1, today=0, tomorrow=1
-                                next_day_offset = {"yesterday": -1, "today": 0, "tomorrow": 1}[next_day_name]
-                                next_day_intervals = get_intervals_for_day_offsets(coordinator.data, [next_day_offset])
-                                if next_day_intervals:
-                                    first_next = next_day_intervals[0]
-                                    first_next_value = first_next.get(filter_field)
-                                    # Only use tomorrow's price if it matches the same filter
-                                    if first_next_value == last_value:
-                                        midnight_price = first_next.get("total")
-                                        midnight_interval = first_next
-
-                            # Fallback: use last interval's price if no tomorrow data or different level
-                            if midnight_price is None:
-                                midnight_price = last_price
-                                midnight_interval = last_interval
-
-                            # Convert price
-                            converted_price = (
-                                round(midnight_price * 100, 2) if subunit_currency else round(midnight_price, 4)
-                            )
+                    # Add the last interval as a data point
+                    converted_last_price = round(last_price * 100, 2) if subunit_currency else round(last_price, 4)
                     if round_decimals is not None:
-                                converted_price = round(converted_price, round_decimals)
+                        converted_last_price = round(converted_last_price, round_decimals)
 
-                            # Add point at midnight with appropriate price (extends graph to end of day)
-                            end_point = {start_time_field: midnight_timestamp, price_field: converted_price}
-                            if midnight_interval is not None:
-                                if include_level and "level" in midnight_interval:
-                                    end_point[level_field] = midnight_interval["level"]
-                                if include_rating_level and "rating_level" in midnight_interval:
-                                    end_point[rating_level_field] = midnight_interval["rating_level"]
-                            if include_average and day in day_averages:
-                                end_point[average_field] = day_averages[day]
+                    last_data_point = {
+                        start_time_field: last_start_time.isoformat()
+                        if hasattr(last_start_time, "isoformat")
+                        else last_start_time,
+                        price_field: converted_last_price,
+                    }
+                    if include_level and "level" in last_interval:
+                        last_data_point[level_field] = last_interval["level"]
+                    if include_rating_level and "rating_level" in last_interval:
+                        last_data_point[rating_level_field] = last_interval["rating_level"]
+
+                    day_key = _get_day_key_for_interval(last_start_time)
+                    if include_average and day_key and day_key in day_averages:
+                        last_data_point[average_field] = day_averages[day_key]
+                    chart_data.append(last_data_point)
+
+                    # Extend to end of selected time range (midnight after last day)
+                    last_dt = last_start_time
+                    if last_dt:
+                        # Calculate midnight after the last interval
+                        next_midnight = last_dt.replace(hour=0, minute=0, second=0, microsecond=0)
+                        next_midnight = next_midnight + timedelta(days=1)
+                        midnight_timestamp = next_midnight.isoformat()
+
+                        # Add hold point at midnight
+                        end_point = {start_time_field: midnight_timestamp, price_field: converted_last_price}
+                        if include_level and "level" in last_interval:
+                            end_point[level_field] = last_interval["level"]
+                        if include_rating_level and "rating_level" in last_interval:
+                            end_point[rating_level_field] = last_interval["rating_level"]
+                        if include_average and day_key and day_key in day_averages:
+                            end_point[average_field] = day_averages[day_key]
                         chart_data.append(end_point)
+
+                        # Add NULL to end series
+                        null_point = {start_time_field: midnight_timestamp, price_field: None}
+                        chart_data.append(null_point)
+
         else:
             # Mode 'none' (default): Only return matching intervals, no NULL insertion
-                for interval in day_prices:
+            for interval in all_prices:
                 start_time = interval.get("startsAt")
                 price = interval.get("total")
 
@@ -735,9 +865,7 @@ async def handle_chartdata(call: ServiceCall) -> dict[str, Any]:  # noqa: PLR091
                         price = round(price, round_decimals)
 
                     data_point = {
-                            start_time_field: start_time.isoformat()
-                            if hasattr(start_time, "isoformat")
-                            else start_time,
+                        start_time_field: start_time.isoformat() if hasattr(start_time, "isoformat") else start_time,
                         price_field: price,
                     }
 
@@ -750,36 +878,12 @@ async def handle_chartdata(call: ServiceCall) -> dict[str, Any]:  # noqa: PLR091
                         data_point[rating_level_field] = interval["rating_level"]
 
                     # Add average if requested
-                        if include_average and day in day_averages:
-                            data_point[average_field] = day_averages[day]
+                    day_key = _get_day_key_for_interval(start_time)
+                    if include_average and day_key and day_key in day_averages:
+                        data_point[average_field] = day_averages[day_key]
 
                     chart_data.append(data_point)
 
-        elif resolution == "hourly":
-            # Hourly averages (4 intervals per hour: :00, :15, :30, :45)
-            chart_data.extend(
-                aggregate_hourly_exact(
-                    day_prices,
-                    start_time_field,
-                    price_field,
-                    coordinator=coordinator,
-                    use_subunit_currency=subunit_currency,
-                    round_decimals=round_decimals,
-                    include_level=include_level,
-                    include_rating_level=include_rating_level,
-                    level_filter=level_filter,
-                    rating_level_filter=rating_level_filter,
-                    include_average=include_average,
-                    level_field=level_field,
-                    rating_level_field=rating_level_field,
-                    average_field=average_field,
-                    day_average=day_averages.get(day),
-                    threshold_low=threshold_low,
-                    period_timestamps=period_timestamps,
-                    threshold_high=threshold_high,
-                )
-            )
-
     # Remove trailing null values ONLY for insert_nulls='segments' mode.
     # For 'all' mode, trailing nulls are intentional (show no-match until end of day).
     # For 'segments' mode, trailing nulls cause ApexCharts header to show "N/A".

custom_components/tibber_prices/services/get_price.py

@@ -145,12 +145,14 @@ async def handle_get_price(call: ServiceCall) -> ServiceResponse:
 
         # Call the interval pool to get intervals (with intelligent caching)
         # Single-home architecture: pool knows its home_id, no parameter needed
-        price_info = await pool.get_intervals(
+        price_info, _api_called = await pool.get_intervals(
             api_client=api_client,
             user_data=user_data,
             start_time=start_time,
             end_time=end_time,
         )
+        # Note: We ignore api_called flag here - service always returns requested data
+        # regardless of whether it came from cache or was fetched fresh from API
 
     except Exception as error:
         _LOGGER.exception("Error fetching price data")

custom_components/tibber_prices/switch/__init__.py

@@ -0,0 +1,38 @@
+"""
+Switch platform for Tibber Prices integration.
+
+Provides configurable switch entities for runtime overrides of Best Price
+and Peak Price period calculation boolean settings (enable_min_periods).
+
+When enabled, these entities take precedence over the options flow settings.
+When disabled (default), the options flow settings are used.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from .core import TibberPricesConfigSwitch
+from .definitions import SWITCH_ENTITY_DESCRIPTIONS
+
+if TYPE_CHECKING:
+    from custom_components.tibber_prices.data import TibberPricesConfigEntry
+    from homeassistant.core import HomeAssistant
+    from homeassistant.helpers.entity_platform import AddEntitiesCallback
+
+
+async def async_setup_entry(
+    _hass: HomeAssistant,
+    entry: TibberPricesConfigEntry,
+    async_add_entities: AddEntitiesCallback,
+) -> None:
+    """Set up Tibber Prices switch entities based on a config entry."""
+    coordinator = entry.runtime_data.coordinator
+
+    async_add_entities(
+        TibberPricesConfigSwitch(
+            coordinator=coordinator,
+            entity_description=entity_description,
+        )
+        for entity_description in SWITCH_ENTITY_DESCRIPTIONS
+    )

custom_components/tibber_prices/switch/core.py

@@ -0,0 +1,245 @@
+"""
+Switch entity implementation for Tibber Prices configuration overrides.
+
+These entities allow runtime configuration of boolean period calculation settings.
+When a config entity is enabled, its value takes precedence over the
+options flow setting for period calculations.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any
+
+from custom_components.tibber_prices.const import (
+    DOMAIN,
+    get_home_type_translation,
+    get_translation,
+)
+from homeassistant.components.switch import SwitchEntity
+from homeassistant.core import callback
+from homeassistant.helpers.device_registry import DeviceEntryType, DeviceInfo
+from homeassistant.helpers.restore_state import RestoreEntity
+
+if TYPE_CHECKING:
+    from custom_components.tibber_prices.coordinator import (
+        TibberPricesDataUpdateCoordinator,
+    )
+
+    from .definitions import TibberPricesSwitchEntityDescription
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class TibberPricesConfigSwitch(RestoreEntity, SwitchEntity):
+    """
+    A switch entity for configuring boolean period calculation settings at runtime.
+
+    When this entity is enabled, its value overrides the corresponding
+    options flow setting. When disabled (default), the options flow
+    setting is used for period calculations.
+
+    The entity restores its value after Home Assistant restart.
+    """
+
+    _attr_has_entity_name = True
+    entity_description: TibberPricesSwitchEntityDescription
+
+    # Exclude all attributes from recorder history - config entities don't need history
+    _unrecorded_attributes = frozenset(
+        {
+            "description",
+            "long_description",
+            "usage_tips",
+            "friendly_name",
+            "icon",
+        }
+    )
+
+    def __init__(
+        self,
+        coordinator: TibberPricesDataUpdateCoordinator,
+        entity_description: TibberPricesSwitchEntityDescription,
+    ) -> None:
+        """Initialize the config switch entity."""
+        self.coordinator = coordinator
+        self.entity_description = entity_description
+
+        # Set unique ID
+        self._attr_unique_id = (
+            f"{coordinator.config_entry.unique_id or coordinator.config_entry.entry_id}_{entity_description.key}"
+        )
+
+        # Initialize with None - will be set in async_added_to_hass
+        self._attr_is_on: bool | None = None
+
+        # Setup device info
+        self._setup_device_info()
+
+    def _setup_device_info(self) -> None:
+        """Set up device information."""
+        home_name, home_id, home_type = self._get_device_info()
+        language = self.coordinator.hass.config.language or "en"
+        translated_model = get_home_type_translation(home_type, language) if home_type else "Unknown"
+
+        self._attr_device_info = DeviceInfo(
+            entry_type=DeviceEntryType.SERVICE,
+            identifiers={
+                (
+                    DOMAIN,
+                    self.coordinator.config_entry.unique_id or self.coordinator.config_entry.entry_id,
+                )
+            },
+            name=home_name,
+            manufacturer="Tibber",
+            model=translated_model,
+            serial_number=home_id if home_id else None,
+            configuration_url="https://developer.tibber.com/explorer",
+        )
+
+    def _get_device_info(self) -> tuple[str, str | None, str | None]:
+        """Get device name, ID and type."""
+        user_profile = self.coordinator.get_user_profile()
+        is_subentry = bool(self.coordinator.config_entry.data.get("home_id"))
+        home_id = self.coordinator.config_entry.unique_id
+        home_type = None
+
+        if is_subentry:
+            home_data = self.coordinator.config_entry.data.get("home_data", {})
+            home_id = self.coordinator.config_entry.data.get("home_id")
+            address = home_data.get("address", {})
+            address1 = address.get("address1", "")
+            city = address.get("city", "")
+            app_nickname = home_data.get("appNickname", "")
+            home_type = home_data.get("type", "")
+
+            if app_nickname and app_nickname.strip():
+                home_name = app_nickname.strip()
+            elif address1:
+                home_name = address1
+                if city:
+                    home_name = f"{home_name}, {city}"
+            else:
+                home_name = f"Tibber Home {home_id[:8]}" if home_id else "Tibber Home"
+        elif user_profile:
+            home_name = user_profile.get("name") or "Tibber Home"
+        else:
+            home_name = "Tibber Home"
+
+        return home_name, home_id, home_type
+
+    async def async_added_to_hass(self) -> None:
+        """Handle entity which was added to Home Assistant."""
+        await super().async_added_to_hass()
+
+        # Try to restore previous state
+        last_state = await self.async_get_last_state()
+        if last_state is not None and last_state.state in ("on", "off"):
+            self._attr_is_on = last_state.state == "on"
+            _LOGGER.debug(
+                "Restored %s value: %s",
+                self.entity_description.key,
+                self._attr_is_on,
+            )
+        else:
+            # Initialize with value from options flow (or default)
+            self._attr_is_on = self._get_value_from_options()
+            _LOGGER.debug(
+                "Initialized %s from options: %s",
+                self.entity_description.key,
+                self._attr_is_on,
+            )
+
+        # Register override with coordinator if entity is enabled
+        await self._sync_override_state()
+
+    async def async_will_remove_from_hass(self) -> None:
+        """Handle entity removal from Home Assistant."""
+        # Remove override when entity is removed
+        self.coordinator.remove_config_override(
+            self.entity_description.config_key,
+            self.entity_description.config_section,
+        )
+        await super().async_will_remove_from_hass()
+
+    def _get_value_from_options(self) -> bool:
+        """Get the current value from options flow or default."""
+        options = self.coordinator.config_entry.options
+        section = options.get(self.entity_description.config_section, {})
+        value = section.get(
+            self.entity_description.config_key,
+            self.entity_description.default_value,
+        )
+        return bool(value)
+
+    async def _sync_override_state(self) -> None:
+        """Sync the override state with the coordinator based on entity enabled state."""
+        # Check if entity is enabled in registry
+        if self.registry_entry is not None and not self.registry_entry.disabled:
+            # Entity is enabled - register the override
+            if self._attr_is_on is not None:
+                self.coordinator.set_config_override(
+                    self.entity_description.config_key,
+                    self.entity_description.config_section,
+                    self._attr_is_on,
+                )
+        else:
+            # Entity is disabled - remove override
+            self.coordinator.remove_config_override(
+                self.entity_description.config_key,
+                self.entity_description.config_section,
+            )
+
+    async def async_turn_on(self, **_kwargs: Any) -> None:
+        """Turn the switch on."""
+        await self._set_value(is_on=True)
+
+    async def async_turn_off(self, **_kwargs: Any) -> None:
+        """Turn the switch off."""
+        await self._set_value(is_on=False)
+
+    async def _set_value(self, *, is_on: bool) -> None:
+        """Update the current value and trigger recalculation."""
+        self._attr_is_on = is_on
+
+        # Update the coordinator's runtime override
+        self.coordinator.set_config_override(
+            self.entity_description.config_key,
+            self.entity_description.config_section,
+            is_on,
+        )
+
+        # Trigger period recalculation (same path as options update)
+        await self.coordinator.async_handle_config_override_update()
+
+        _LOGGER.debug(
+            "Updated %s to %s, triggered period recalculation",
+            self.entity_description.key,
+            is_on,
+        )
+
+    @property
+    def extra_state_attributes(self) -> dict[str, Any] | None:
+        """Return entity state attributes with description."""
+        language = self.coordinator.hass.config.language or "en"
+
+        # Try to get description from custom translations
+        # Custom translations use direct path: switch.{key}.description
+        translation_path = [
+            "switch",
+            self.entity_description.translation_key or self.entity_description.key,
+            "description",
+        ]
+        description = get_translation(translation_path, language)
+
+        attrs: dict[str, Any] = {}
+        if description:
+            attrs["description"] = description
+
+        return attrs if attrs else None
+
+    @callback
+    def async_registry_entry_updated(self) -> None:
+        """Handle entity registry update (enabled/disabled state change)."""
+        # This is called when the entity is enabled/disabled in the UI
+        self.hass.async_create_task(self._sync_override_state())

custom_components/tibber_prices/switch/definitions.py

@@ -0,0 +1,84 @@
+"""
+Switch entity definitions for Tibber Prices configuration overrides.
+
+These switch entities allow runtime configuration of boolean settings
+for Best Price and Peak Price period calculations.
+
+When enabled, the entity value takes precedence over the options flow setting.
+When disabled (default), the options flow setting is used.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from homeassistant.components.switch import SwitchEntityDescription
+from homeassistant.const import EntityCategory
+
+
+@dataclass(frozen=True, kw_only=True)
+class TibberPricesSwitchEntityDescription(SwitchEntityDescription):
+    """Describes a Tibber Prices switch entity for config overrides."""
+
+    # The config key this entity overrides (matches CONF_* constants)
+    config_key: str
+    # The section in options where this setting is stored
+    config_section: str
+    # Whether this is for best_price (False) or peak_price (True)
+    is_peak_price: bool = False
+    # Default value from const.py
+    default_value: bool = True
+
+
+# ============================================================================
+# BEST PRICE PERIOD CONFIGURATION OVERRIDES (Boolean)
+# ============================================================================
+
+BEST_PRICE_SWITCH_ENTITIES = (
+    SwitchEntityDescription(
+        key="best_price_enable_relaxation_override",
+        translation_key="best_price_enable_relaxation_override",
+        name="Best Price: Achieve Minimum Count",
+        icon="mdi:arrow-down-bold-circle",
+        entity_category=EntityCategory.CONFIG,
+        entity_registry_enabled_default=False,
+    ),
+)
+
+# Custom descriptions with extra fields
+BEST_PRICE_SWITCH_ENTITY_DESCRIPTIONS = (
+    TibberPricesSwitchEntityDescription(
+        key="best_price_enable_relaxation_override",
+        translation_key="best_price_enable_relaxation_override",
+        name="Best Price: Achieve Minimum Count",
+        icon="mdi:arrow-down-bold-circle",
+        entity_category=EntityCategory.CONFIG,
+        entity_registry_enabled_default=False,
+        config_key="enable_min_periods_best",
+        config_section="relaxation_and_target_periods",
+        is_peak_price=False,
+        default_value=True,  # DEFAULT_ENABLE_MIN_PERIODS_BEST
+    ),
+)
+
+# ============================================================================
+# PEAK PRICE PERIOD CONFIGURATION OVERRIDES (Boolean)
+# ============================================================================
+
+PEAK_PRICE_SWITCH_ENTITY_DESCRIPTIONS = (
+    TibberPricesSwitchEntityDescription(
+        key="peak_price_enable_relaxation_override",
+        translation_key="peak_price_enable_relaxation_override",
+        name="Peak Price: Achieve Minimum Count",
+        icon="mdi:arrow-up-bold-circle",
+        entity_category=EntityCategory.CONFIG,
+        entity_registry_enabled_default=False,
+        config_key="enable_min_periods_peak",
+        config_section="relaxation_and_target_periods",
+        is_peak_price=True,
+        default_value=True,  # DEFAULT_ENABLE_MIN_PERIODS_PEAK
+    ),
+)
+
+# All switch entity descriptions combined
+SWITCH_ENTITY_DESCRIPTIONS = BEST_PRICE_SWITCH_ENTITY_DESCRIPTIONS + PEAK_PRICE_SWITCH_ENTITY_DESCRIPTIONS

custom_components/tibber_prices/translations/de.json

@@ -11,14 +11,14 @@
             },
             "new_token": {
                 "title": "API-Token eingeben",
-                "description": "Richte Tibber Preisinformationen & Bewertungen ein.\n\nUm einen API-Zugriffstoken zu generieren, besuche https://developer.tibber.com.",
+                "description": "Richte Tibber Preisinformationen & Bewertungen ein.\n\nUm einen API-Zugriffstoken zu generieren, besuche [{tibber_url}]({tibber_url}).",
                 "data": {
                     "access_token": "API-Zugriffstoken"
                 },
                 "submit": "Token validieren"
             },
             "user": {
-                "description": "Richte Tibber Preisinformationen & Bewertungen ein.\n\nUm einen API-Zugriffstoken zu generieren, besuche https://developer.tibber.com.",
+                "description": "Richte Tibber Preisinformationen & Bewertungen ein.\n\nUm einen API-Zugriffstoken zu generieren, besuche [{tibber_url}]({tibber_url}).",
                 "data": {
                     "access_token": "API-Zugriffstoken"
                 },
@@ -42,7 +42,7 @@
             },
             "reauth_confirm": {
                 "title": "Tibber Preis-Integration erneut authentifizieren",
-                "description": "Der Zugriffstoken für Tibber ist nicht mehr gültig. Bitte gib einen neuen API-Zugriffstoken ein, um diese Integration weiter zu nutzen.\n\nUm einen neuen API-Zugriffstoken zu generieren, besuche https://developer.tibber.com.",
+                "description": "Der Zugriffstoken für Tibber ist nicht mehr gültig. Bitte gib einen neuen API-Zugriffstoken ein, um diese Integration weiter zu nutzen.\n\nUm einen neuen API-Zugriffstoken zu generieren, besuche [{tibber_url}]({tibber_url}).",
                 "data": {
                     "access_token": "API-Zugriffstoken"
                 },
@@ -77,7 +77,23 @@
         }
     },
     "common": {
-        "step_progress": "{step_num} / {total_steps}"
+        "step_progress": "{step_num} / {total_steps}",
+        "override_warning_template": "⚠️ {fields} wird durch Konfigurations-Entität gesteuert",
+        "override_warning_and": "und",
+        "override_field_label_best_price_min_period_length": "Mindestperiodenlänge",
+        "override_field_label_best_price_max_level_gap_count": "Lückentoleranz",
+        "override_field_label_best_price_flex": "Flexibilität",
+        "override_field_label_best_price_min_distance_from_avg": "Mindestabstand",
+        "override_field_label_enable_min_periods_best": "Mindestzahl erreichen",
+        "override_field_label_min_periods_best": "Mindestperioden",
+        "override_field_label_relaxation_attempts_best": "Lockerungsversuche",
+        "override_field_label_peak_price_min_period_length": "Mindestperiodenlänge",
+        "override_field_label_peak_price_max_level_gap_count": "Lückentoleranz",
+        "override_field_label_peak_price_flex": "Flexibilität",
+        "override_field_label_peak_price_min_distance_from_avg": "Mindestabstand",
+        "override_field_label_enable_min_periods_peak": "Mindestzahl erreichen",
+        "override_field_label_min_periods_peak": "Mindestperioden",
+        "override_field_label_relaxation_attempts_peak": "Lockerungsversuche"
     },
     "config_subentries": {
         "home": {
@@ -132,53 +148,64 @@
     "options": {
         "step": {
             "init": {
+                "menu_options": {
+                    "general_settings": "⚙️ Allgemeine Einstellungen",
+                    "display_settings": "💱 Währungsanzeige",
+                    "current_interval_price_rating": "📊 Preisbewertung",
+                    "price_level": "🏷️ Preisniveau",
+                    "volatility": "💨 Preis-Volatilität",
+                    "best_price": "💚 Bestpreis",
+                    "peak_price": "🔴 Spitzenpreis",
+                    "price_trend": "📈 Preistrend",
+                    "chart_data_export": "📊 Diagrammdaten-Export",
+                    "reset_to_defaults": "🔄 Auf Werkseinstellungen zurücksetzen",
+                    "finish": "⬅️ Zurück"
+                }
+            },
+            "general_settings": {
                 "title": "⚙️ Allgemeine Einstellungen",
-                "description": "_{step_progress}_\n\n**Konfiguriere allgemeine Einstellungen für Tibber-Preisinformationen und -bewertungen.**\n\n---\n\n**Benutzer:** {user_login}",
+                "description": "**Konfiguriere allgemeine Einstellungen für Tibber-Preisinformationen und -bewertungen.**\n\n---\n\n**Benutzer:** {user_login}",
                 "data": {
                     "extended_descriptions": "Erweiterte Beschreibungen",
                     "average_sensor_display": "Durchschnittsensor-Anzeige"
                 },
                 "data_description": {
                     "extended_descriptions": "Steuert, ob Entitätsattribute ausführliche Erklärungen und Nutzungstipps enthalten.\n\n• Deaktiviert (Standard): Nur kurze Beschreibung\n• Aktiviert: Ausführliche Erklärung + praktische Nutzungsbeispiele\n\nBeispiel:\nDeaktiviert = 1 Attribut\nAktiviert = 2 zusätzliche Attribute",
-                    "average_sensor_display": "Wähle aus, welcher statistische Wert im Sensorstatus für Durchschnitts-Preissensoren angezeigt wird. Der andere Wert wird als Attribut angezeigt. Der Median ist resistenter gegen Extremwerte, während das arithmetische Mittel dem traditionellen Durchschnitt entspricht. Standard: Median"
+                    "average_sensor_display": "Wähle aus, welcher statistische Wert im Sensorstatus für Durchschnitts-Preissensoren angezeigt wird. Der andere Wert wird als Attribut angezeigt.\n\n• **Median (Standard)**: Zeigt den 'typischen' Preis, resistent gegen Extremwerte - ideal für Anzeige und menschliche Interpretation\n• **Arithmetisches Mittel**: Zeigt den echten mathematischen Durchschnitt inkl. aller Preise - ideal für exakte Kostenberechnungen\n\nFür Automatisierungen nutze das Attribut `price_mean` oder `price_median`, um unabhängig von dieser Einstellung auf beide Werte zuzugreifen."
                 },
-                "submit": "Weiter →"
+                "submit": "↩ Speichern & Zurück"
             },
             "display_settings": {
                 "title": "💱 Währungsanzeige-Einstellungen",
-                "description": "_{step_progress}_\n\n**Konfiguriere, wie Strompreise angezeigt werden - in Basiswährung (€, kr) oder Unterwährungseinheit (ct, øre).**\n\n---",
+                "description": "**Konfiguriere, wie Strompreise angezeigt werden - in Basiswährung (€, kr) oder Unterwährungseinheit (ct, øre).**\n\n---",
                 "data": {
                     "currency_display_mode": "Anzeigemodus"
                 },
                 "data_description": {
                     "currency_display_mode": "Wähle, wie Preise angezeigt werden:\n\n• **Basiswährung** (€/kWh, kr/kWh): Dezimalwerte (z.B. 0,25 €/kWh) - Unterschiede sichtbar ab 3.-4. Nachkommastelle\n• **Unterwährungseinheit** (ct/kWh, øre/kWh): Größere Werte (z.B. 25,00 ct/kWh) - Unterschiede bereits ab 1. Nachkommastelle sichtbar\n\nStandard abhängig von deiner Währung:\n• EUR → Unterwährungseinheit (Cent) - deutsche/niederländische Präferenz\n• NOK/SEK/DKK → Basiswährung (Kronen) - skandinavische Präferenz\n• USD/GBP → Basiswährung\n\n**💡 Tipp:** Bei Auswahl von Unterwährungseinheit kannst du den zusätzlichen Sensor \"Aktueller Strompreis (Energie-Dashboard)\" aktivieren (standardmäßig deaktiviert)."
                 },
-                "submit": "Weiter →"
+                "submit": "↩ Speichern & Zurück"
             },
             "current_interval_price_rating": {
-                "title": "📊 Preisbewertungs-Schwellenwerte",
-                "description": "_{step_progress}_\n\n**Konfiguriere Schwellenwerte für Preisbewertungsstufen (niedrig/normal/hoch) basierend auf dem Vergleich mit dem nachlaufenden 24-Stunden-Durchschnitt.**\n\n---",
-                "sections": {
-                    "price_rating_thresholds": {
-                        "name": "Preisbewertungs-Schwellenwerte",
-                        "description": "Definiere die Einstufungen für die Preisbewertung.",
+                "title": "📊 Preisbewertungs-Einstellungen",
+                "description": "**Konfiguriere Schwellenwerte und Stabilisierung für Preisbewertungsstufen (niedrig/normal/hoch) basierend auf dem Vergleich mit dem nachlaufenden 24-Stunden-Durchschnitt.**{entity_warning}",
                 "data": {
                     "price_rating_threshold_low": "Niedrig-Schwelle",
                     "price_rating_threshold_high": "Hoch-Schwelle",
-                            "average_sensor_display": "Durchschnitts-Sensor Anzeige"
+                    "price_rating_hysteresis": "Hysterese",
+                    "price_rating_gap_tolerance": "Lücken-Toleranz"
                 },
                 "data_description": {
-                            "price_rating_threshold_low": "Prozentwert, um wie viel der aktuelle Preis unter dem nachlaufenden 24-Stunden-Durchschnitt liegen muss, damit er als 'niedrig' bewertet wird. Beispiel: 5 bedeutet mindestens 5% unter Durchschnitt. Sensoren mit dieser Bewertung zeigen günstige Zeitfenster an. Standard: 5%",
+                    "price_rating_threshold_low": "Prozentwert, um wie viel der aktuelle Preis unter dem nachlaufenden 24-Stunden-Durchschnitt liegen muss, damit er als 'niedrig' bewertet wird. Beispiel: -10 bedeutet mindestens 10% unter Durchschnitt. Sensoren mit dieser Bewertung zeigen günstige Zeitfenster an. Standard: -10%",
                     "price_rating_threshold_high": "Prozentwert, um wie viel der aktuelle Preis über dem nachlaufenden 24-Stunden-Durchschnitt liegen muss, damit er als 'hoch' bewertet wird. Beispiel: 10 bedeutet mindestens 10% über Durchschnitt. Sensoren mit dieser Bewertung warnen vor teuren Zeitfenstern. Standard: 10%",
-                            "average_sensor_display": "Wähle, welches statistische Maß im Sensor-Status für Durchschnittspreissensoren angezeigt werden soll. Der andere Wert wird als Attribut angezeigt. Der Median ist widerstandsfähiger gegen Extremwerte, während das arithmetische Mittel den traditionellen Durchschnitt darstellt. Standard: Median"
-                        }
-                    }
+                    "price_rating_hysteresis": "Prozentband um die Schwellenwerte zur Vermeidung schneller Zustandswechsel. Wenn die Bewertung bereits NIEDRIG ist, muss der Preis über (Schwelle + Hysterese) steigen, um zu NORMAL zu wechseln. Ebenso muss bei HOCH der Preis unter (Schwelle - Hysterese) fallen, um den Zustand zu verlassen. Dies sorgt für Stabilität bei Automationen, die auf Bewertungsänderungen reagieren. Auf 0 setzen zum Deaktivieren. Standard: 2%",
+                    "price_rating_gap_tolerance": "Maximale Anzahl aufeinanderfolgender Intervalle, die 'geglättet' werden können, wenn sie sich von den umgebenden Bewertungen unterscheiden. Kleine isolierte Bewertungsänderungen werden in den dominanten Nachbarblock integriert. Dies sorgt für Stabilität bei Automationen, indem kurze Bewertungsspitzen keine unnötigen Aktionen auslösen. Beispiel: 1 bedeutet, dass ein einzelnes 'normal'-Intervall umgeben von 'hoch'-Intervallen zu 'hoch' korrigiert wird. Auf 0 setzen zum Deaktivieren. Standard: 1"
                 },
-                "submit": "Weiter →"
+                "submit": "↩ Speichern & Zurück"
             },
             "best_price": {
                 "title": "💚 Bestpreis-Zeitraum Einstellungen",
-                "description": "_{step_progress}_\n\n**Konfiguration für den Bestpreis-Zeitraum mit den niedrigsten Strompreisen.**\n\n---",
+                "description": "**Konfiguration für den Bestpreis-Zeitraum mit den niedrigsten Strompreisen.**{entity_warning}{override_warning}\n\n---",
                 "sections": {
                     "period_settings": {
                         "name": "Zeitraumdauer & Preisniveaus",
@@ -221,11 +248,11 @@
                         }
                     }
                 },
-                "submit": "Weiter →"
+                "submit": "↩ Speichern & Zurück"
             },
             "peak_price": {
                 "title": "🔴 Spitzenpreis-Zeitraum Einstellungen",
-                "description": "_{step_progress}_\n\n**Konfiguration für den Spitzenpreis-Zeitraum mit den höchsten Strompreisen.**\n\n---",
+                "description": "**Konfiguration für den Spitzenpreis-Zeitraum mit den höchsten Strompreisen.**{entity_warning}{override_warning}\n\n---",
                 "sections": {
                     "period_settings": {
                         "name": "Zeitraum-Einstellungen",
@@ -268,34 +295,28 @@
                         }
                     }
                 },
-                "submit": "Weiter →"
+                "submit": "↩ Speichern & Zurück"
             },
             "price_trend": {
                 "title": "📈 Preistrend-Schwellenwerte",
-                "description": "_{step_progress}_\n\n**Konfiguriere Schwellenwerte für Preistrend-Sensoren. Diese Sensoren vergleichen den aktuellen Preis mit dem Durchschnitt der nächsten N Stunden, um festzustellen, ob die Preise steigen, fallen oder stabil sind.**\n\n---",
-                "sections": {
-                    "price_trend_thresholds": {
-                        "name": "Preistrend-Schwellenwerte",
-                        "description": "Definiere die Einstufungen für den Preistrend.",
+                "description": "**Konfiguriere Schwellenwerte für Preistrend-Sensoren.** Diese Sensoren vergleichen den aktuellen Preis mit dem Durchschnitt der nächsten N Stunden, um festzustellen, ob die Preise steigen, fallen oder stabil sind.\n\n**5-Stufen-Skala:** Nutzt stark_fallend (-2), fallend (-1), stabil (0), steigend (+1), stark_steigend (+2) für Automations-Vergleiche über das trend_value Attribut.{entity_warning}",
                 "data": {
                     "price_trend_threshold_rising": "Steigend-Schwelle",
-                            "price_trend_threshold_falling": "Fallend-Schwelle"
+                    "price_trend_threshold_strongly_rising": "Stark steigend-Schwelle",
+                    "price_trend_threshold_falling": "Fallend-Schwelle",
+                    "price_trend_threshold_strongly_falling": "Stark fallend-Schwelle"
                 },
                 "data_description": {
-                            "price_trend_threshold_rising": "Prozentwert, um wie viel der Durchschnitt der nächsten N Stunden über dem aktuellen Preis liegen muss, damit der Trend als 'steigend' gilt. Beispiel: 5 bedeutet Durchschnitt ist mindestens 5% höher → Preise werden steigen. Typische Werte: 5-15%. Standard: 5%",
-                            "price_trend_threshold_falling": "Prozentwert (negativ), um wie viel der Durchschnitt der nächsten N Stunden unter dem aktuellen Preis liegen muss, damit der Trend als 'fallend' gilt. Beispiel: -5 bedeutet Durchschnitt ist mindestens 5% niedriger → Preise werden fallen. Typische Werte: -5 bis -15%. Standard: -5%"
-                        }
-                    }
+                    "price_trend_threshold_rising": "Prozentwert, um wie viel der Durchschnitt der nächsten N Stunden über dem aktuellen Preis liegen muss, damit der Trend als 'steigend' gilt. Beispiel: 3 bedeutet Durchschnitt ist mindestens 3% höher → Preise werden steigen. Typische Werte: 3-10%. Standard: 3%",
+                    "price_trend_threshold_strongly_rising": "Prozentwert für 'stark steigend'-Trend. Muss höher sein als die steigend-Schwelle. Beispiel: 6 bedeutet Durchschnitt ist mindestens 6% höher → Preise werden deutlich steigen. Typische Werte: 6-15%. Standard: 6%",
+                    "price_trend_threshold_falling": "Prozentwert (negativ), um wie viel der Durchschnitt der nächsten N Stunden unter dem aktuellen Preis liegen muss, damit der Trend als 'fallend' gilt. Beispiel: -3 bedeutet Durchschnitt ist mindestens 3% niedriger → Preise werden fallen. Typische Werte: -3 bis -10%. Standard: -3%",
+                    "price_trend_threshold_strongly_falling": "Prozentwert (negativ) für 'stark fallend'-Trend. Muss niedriger (negativer) sein als die fallend-Schwelle. Beispiel: -6 bedeutet Durchschnitt ist mindestens 6% niedriger → Preise werden deutlich fallen. Typische Werte: -6 bis -15%. Standard: -6%"
                 },
-                "submit": "Weiter →"
+                "submit": "↩ Speichern & Zurück"
             },
             "volatility": {
                 "title": "💨 Volatilität Schwellenwerte",
-                "description": "_{step_progress}_\n\n**Konfiguriere Schwellenwerte für die Volatilitätsklassifizierung.** Volatilität misst relative Preisschwankungen anhand des Variationskoeffizienten (VK = Standardabweichung / Durchschnitt × 100%). Diese Schwellenwerte sind Prozentwerte, die für alle Preisniveaus funktionieren.\n\nVerwendet von:\n• Volatilitätssensoren (Klassifizierung)\n• Trend-Sensoren (adaptive Schwellenanpassung: <moderat = empfindlicher, ≥hoch = weniger empfindlich)\n\n---",
-                "sections": {
-                    "volatility_thresholds": {
-                        "name": "Volatilitätsschwellen",
-                        "description": "Definiere Volatilitäts-Klassifizierungsstufen.",
+                "description": "**Konfiguriere Schwellenwerte für die Volatilitätsklassifizierung.** Volatilität misst relative Preisschwankungen anhand des Variationskoeffizienten (VK = Standardabweichung / Durchschnitt × 100%). Diese Schwellenwerte sind Prozentwerte, die für alle Preisniveaus funktionieren.\n\nVerwendet von:\n• Volatilitätssensoren (Klassifizierung)\n• Trend-Sensoren (adaptive Schwellenanpassung: <moderat = empfindlicher, ≥hoch = weniger empfindlich){entity_warning}",
                 "data": {
                     "volatility_threshold_moderate": "Moderat-Schwelle",
                     "volatility_threshold_high": "Hoch-Schwelle",
@@ -305,15 +326,32 @@
                     "volatility_threshold_moderate": "Variationskoeffizient (VK) ab dem Preise als 'moderat volatil' gelten. VK = (Standardabweichung / Durchschnitt) × 100%. Beispiel: 15 bedeutet Preisschwankungen von ±15% um den Durchschnitt. Sensoren zeigen diese Klassifizierung an, Trend-Sensoren werden empfindlicher. Standard: 15%",
                     "volatility_threshold_high": "Variationskoeffizient (VK) ab dem Preise als 'hoch volatil' gelten. Beispiel: 30 bedeutet Preisschwankungen von ±30% um den Durchschnitt. Größere Preissprünge erwartet, Trend-Sensoren werden weniger empfindlich. Standard: 30%",
                     "volatility_threshold_very_high": "Variationskoeffizient (VK) ab dem Preise als 'sehr hoch volatil' gelten. Beispiel: 50 bedeutet extreme Preisschwankungen von ±50% um den Durchschnitt. An solchen Tagen sind starke Preisspitzen wahrscheinlich. Standard: 50%"
-                        }
-                    }
                 },
-                "submit": "Weiter →"
+                "submit": "↩ Speichern & Zurück"
             },
             "chart_data_export": {
                 "title": "📊 Chart Data Export Sensor",
-                "description": "_{step_progress}_\n\nDer Chart Data Export Sensor stellt Preisdaten als Sensor-Attribute zur Verfügung.\n\n⚠️ **Hinweis:** Dieser Sensor ist ein Legacy-Feature für Kompatibilität mit älteren Tools.\n\n**Für neue Setups empfohlen:** Nutze den `tibber_prices.get_chartdata` **Service direkt** - er ist flexibler, effizienter und der moderne Home Assistant-Ansatz.\n\n**Wann dieser Sensor sinnvoll ist:**\n\n✅ Dein Dashboard-Tool kann **nur** Attribute lesen (keine Service-Aufrufe)\n✅ Du brauchst statische Daten, die automatisch aktualisiert werden\n❌ **Nicht für Automationen:** Nutze dort direkt `tibber_prices.get_chartdata` - flexibler und effizienter!\n\n---\n\n**Sensor aktivieren:**\n\n1. Öffne **Einstellungen → Geräte & Dienste → Tibber Prices**\n2. Wähle dein Home → Finde **'Chart Data Export'** (Diagnose-Bereich)\n3. **Aktiviere den Sensor** (standardmäßig deaktiviert)\n\n**Konfiguration (optional):**\n\nStandardeinstellung funktioniert sofort (heute+morgen, 15-Minuten-Intervalle, reine Preise).\n\nFür Anpassungen füge in **`configuration.yaml`** ein:\n\n```yaml\ntibber_prices:\n  chart_export:\n    day:\n      - today\n      - tomorrow\n    include_level: true\n    include_rating_level: true\n```\n\n**Alle Parameter:** Siehe `tibber_prices.get_chartdata` Service-Dokumentation",
-                "submit": "Abschließen ✓"
+                "description": "Der Chart Data Export Sensor stellt Preisdaten als Sensor-Attribute zur Verfügung.\n\n⚠️ **Hinweis:** Dieser Sensor ist ein Legacy-Feature für Kompatibilität mit älteren Tools.\n\n**Für neue Setups empfohlen:** Nutze den `tibber_prices.get_chartdata` **Service direkt** - er ist flexibler, effizienter und der moderne Home Assistant-Ansatz.\n\n**Wann dieser Sensor sinnvoll ist:**\n\n✅ Dein Dashboard-Tool kann **nur** Attribute lesen (keine Service-Aufrufe)\n✅ Du brauchst statische Daten, die automatisch aktualisiert werden\n❌ **Nicht für Automationen:** Nutze dort direkt `tibber_prices.get_chartdata` - flexibler und effizienter!\n\n---\n\n{sensor_status_info}",
+                "submit": "↩ Ok & Zurück"
+            },
+            "reset_to_defaults": {
+                "title": "🔄 Auf Werkseinstellungen zurücksetzen",
+                "description": "⚠️ **Warnung:** Dies setzt **ALLE** Einstellungen auf Werkseinstellungen zurück.\n\n**Was wird zurückgesetzt:**\n• Alle Preisbewertungs-Schwellwerte\n• Alle Volatilitäts-Schwellwerte\n• Alle Preistrend-Schwellwerte\n• Alle Einstellungen für Best-Price-Perioden\n• Alle Einstellungen für Peak-Price-Perioden\n• Anzeigeeinstellungen\n• Allgemeine Einstellungen\n\n**Was wird NICHT zurückgesetzt:**\n• Dein Tibber API-Token\n• Ausgewähltes Zuhause\n• Währung\n\n**💡 Tipp:** Nützlich, wenn du nach dem Experimentieren mit Einstellungen neu beginnen möchtest.",
+                "data": {
+                    "confirm_reset": "Ja, alles auf Werkseinstellungen zurücksetzen"
+                },
+                "submit": "Jetzt zurücksetzen"
+            },
+            "price_level": {
+                "title": "🏷️ Preisniveau-Einstellungen (von Tibber API)",
+                "description": "**Konfiguriere die Stabilisierung für Tibbers Preisniveau-Klassifizierung (sehr günstig/günstig/normal/teuer/sehr teuer).**\n\nTibbers API liefert ein Preisniveau-Feld für jedes Intervall. Diese Einstellung glättet kurze Schwankungen, um Instabilität in Automatisierungen zu verhindern.{entity_warning}",
+                "data": {
+                    "price_level_gap_tolerance": "Gap-Toleranz"
+                },
+                "data_description": {
+                    "price_level_gap_tolerance": "Maximale Anzahl aufeinanderfolgender Intervalle, die 'geglättet' werden können, wenn sie von umgebenden Preisniveaus abweichen. Kleine isolierte Niveauänderungen werden mit dem dominanten Nachbarblock zusammengeführt. Beispiel: 1 bedeutet, dass ein einzelnes 'normal'-Intervall, umgeben von 'günstig'-Intervallen, zu 'günstig' korrigiert wird. Auf 0 setzen zum Deaktivieren. Standard: 1"
+                },
+                "submit": "↩ Speichern & Zurück"
             }
         },
         "error": {
@@ -338,10 +376,17 @@
             "invalid_volatility_threshold_very_high": "Sehr hohe Volatilitätsschwelle muss zwischen 35% und 80% liegen",
             "invalid_volatility_thresholds": "Schwellenwerte müssen aufsteigend sein: moderat < hoch < sehr hoch",
             "invalid_price_trend_rising": "Steigender Trendschwellenwert muss zwischen 1% und 50% liegen",
-            "invalid_price_trend_falling": "Fallender Trendschwellenwert muss zwischen -50% und -1% liegen"
+            "invalid_price_trend_falling": "Fallender Trendschwellenwert muss zwischen -50% und -1% liegen",
+            "invalid_price_trend_strongly_rising": "Stark steigender Trendschwellenwert muss zwischen 2% und 100% liegen",
+            "invalid_price_trend_strongly_falling": "Stark fallender Trendschwellenwert muss zwischen -100% und -2% liegen",
+            "invalid_trend_strongly_rising_less_than_rising": "Stark steigend-Schwelle muss größer als steigend-Schwelle sein",
+            "invalid_trend_strongly_falling_greater_than_falling": "Stark fallend-Schwelle muss kleiner (negativer) als fallend-Schwelle sein"
         },
         "abort": {
-            "entry_not_found": "Tibber Konfigurationseintrag nicht gefunden."
+            "entry_not_found": "Tibber Konfigurationseintrag nicht gefunden.",
+            "reset_cancelled": "Zurücksetzen abgebrochen. Es wurden keine Änderungen an deiner Konfiguration vorgenommen.",
+            "reset_successful": "✅ Alle Einstellungen wurden auf Werkseinstellungen zurückgesetzt. Deine Konfiguration ist jetzt wie bei einer frischen Installation.",
+            "finished": "Konfiguration abgeschlossen."
         }
     },
     "entity": {
@@ -571,73 +616,91 @@
             "price_trend_1h": {
                 "name": "Preistrend (1h)",
                 "state": {
+                    "strongly_rising": "Stark steigend",
                     "rising": "Steigend",
+                    "stable": "Stabil",
                     "falling": "Fallend",
-                    "stable": "Stabil"
+                    "strongly_falling": "Stark fallend"
                 }
             },
             "price_trend_2h": {
                 "name": "Preistrend (2h)",
                 "state": {
+                    "strongly_rising": "Stark steigend",
                     "rising": "Steigend",
+                    "stable": "Stabil",
                     "falling": "Fallend",
-                    "stable": "Stabil"
+                    "strongly_falling": "Stark fallend"
                 }
             },
             "price_trend_3h": {
                 "name": "Preistrend (3h)",
                 "state": {
+                    "strongly_rising": "Stark steigend",
                     "rising": "Steigend",
+                    "stable": "Stabil",
                     "falling": "Fallend",
-                    "stable": "Stabil"
+                    "strongly_falling": "Stark fallend"
                 }
             },
             "price_trend_4h": {
                 "name": "Preistrend (4h)",
                 "state": {
+                    "strongly_rising": "Stark steigend",
                     "rising": "Steigend",
+                    "stable": "Stabil",
                     "falling": "Fallend",
-                    "stable": "Stabil"
+                    "strongly_falling": "Stark fallend"
                 }
             },
             "price_trend_5h": {
                 "name": "Preistrend (5h)",
                 "state": {
+                    "strongly_rising": "Stark steigend",
                     "rising": "Steigend",
+                    "stable": "Stabil",
                     "falling": "Fallend",
-                    "stable": "Stabil"
+                    "strongly_falling": "Stark fallend"
                 }
             },
             "price_trend_6h": {
                 "name": "Preistrend (6h)",
                 "state": {
+                    "strongly_rising": "Stark steigend",
                     "rising": "Steigend",
+                    "stable": "Stabil",
                     "falling": "Fallend",
-                    "stable": "Stabil"
+                    "strongly_falling": "Stark fallend"
                 }
             },
             "price_trend_8h": {
                 "name": "Preistrend (8h)",
                 "state": {
+                    "strongly_rising": "Stark steigend",
                     "rising": "Steigend",
+                    "stable": "Stabil",
                     "falling": "Fallend",
-                    "stable": "Stabil"
+                    "strongly_falling": "Stark fallend"
                 }
             },
             "price_trend_12h": {
                 "name": "Preistrend (12h)",
                 "state": {
+                    "strongly_rising": "Stark steigend",
                     "rising": "Steigend",
+                    "stable": "Stabil",
                     "falling": "Fallend",
-                    "stable": "Stabil"
+                    "strongly_falling": "Stark fallend"
                 }
             },
             "current_price_trend": {
                 "name": "Aktueller Preistrend",
                 "state": {
+                    "strongly_rising": "Stark steigend",
                     "rising": "Steigend",
+                    "stable": "Stabil",
                     "falling": "Fallend",
-                    "stable": "Stabil"
+                    "strongly_falling": "Stark fallend"
                 }
             },
             "next_price_trend_change": {
@@ -839,6 +902,52 @@
             "realtime_consumption_enabled": {
                 "name": "Echtzeitverbrauch aktiviert"
             }
+        },
+        "number": {
+            "best_price_flex_override": {
+                "name": "Bestpreis: Flexibilität"
+            },
+            "best_price_min_distance_override": {
+                "name": "Bestpreis: Mindestabstand"
+            },
+            "best_price_min_period_length_override": {
+                "name": "Bestpreis: Mindestperiodenlänge"
+            },
+            "best_price_min_periods_override": {
+                "name": "Bestpreis: Mindestperioden"
+            },
+            "best_price_relaxation_attempts_override": {
+                "name": "Bestpreis: Lockerungsversuche"
+            },
+            "best_price_gap_count_override": {
+                "name": "Bestpreis: Lückentoleranz"
+            },
+            "peak_price_flex_override": {
+                "name": "Spitzenpreis: Flexibilität"
+            },
+            "peak_price_min_distance_override": {
+                "name": "Spitzenpreis: Mindestabstand"
+            },
+            "peak_price_min_period_length_override": {
+                "name": "Spitzenpreis: Mindestperiodenlänge"
+            },
+            "peak_price_min_periods_override": {
+                "name": "Spitzenpreis: Mindestperioden"
+            },
+            "peak_price_relaxation_attempts_override": {
+                "name": "Spitzenpreis: Lockerungsversuche"
+            },
+            "peak_price_gap_count_override": {
+                "name": "Spitzenpreis: Lückentoleranz"
+            }
+        },
+        "switch": {
+            "best_price_enable_relaxation_override": {
+                "name": "Bestpreis: Mindestanzahl erreichen"
+            },
+            "peak_price_enable_relaxation_override": {
+                "name": "Spitzenpreis: Mindestanzahl erreichen"
+            }
         }
     },
     "issues": {
@@ -901,6 +1010,14 @@
                 "highlight_best_price": {
                     "name": "Bestpreis-Zeiträume hervorheben",
                     "description": "Füge eine halbtransparente grüne Überlagerung hinzu, um die Bestpreis-Zeiträume im Diagramm hervorzuheben. Dies erleichtert die visuelle Identifizierung der optimalen Zeiten für den Energieverbrauch."
+                },
+                "highlight_peak_price": {
+                    "name": "Spitzenpreis-Zeiträume hervorheben",
+                    "description": "Füge eine halbtransparente rote Überlagerung hinzu, um die Spitzenpreis-Zeiträume im Diagramm hervorzuheben. Dies erleichtert die visuelle Identifizierung der Zeiten, in denen Energie am teuersten ist."
+                },
+                "resolution": {
+                    "name": "Auflösung",
+                    "description": "Zeitauflösung für die Diagrammdaten. 'interval' (Standard): Originale 15-Minuten-Intervalle (96 Punkte pro Tag). 'hourly': Aggregierte Stundenwerte mit einem rollierenden 60-Minuten-Fenster (24 Punkte pro Tag) für ein übersichtlicheres Diagramm."
                 }
             }
         },

custom_components/tibber_prices/translations/en.json

@@ -11,14 +11,14 @@
             },
             "new_token": {
                 "title": "Enter API Token",
-                "description": "Set up Tibber Price Information & Ratings.\n\nTo generate an API access token, visit https://developer.tibber.com.",
+                "description": "Set up Tibber Price Information & Ratings.\n\nTo generate an API access token, visit [{tibber_url}]({tibber_url}).",
                 "data": {
                     "access_token": "API access token"
                 },
                 "submit": "Validate Token"
             },
             "user": {
-                "description": "Set up Tibber Price Information & Ratings.\n\nTo generate an API access token, visit https://developer.tibber.com.",
+                "description": "Set up Tibber Price Information & Ratings.\n\nTo generate an API access token, visit [{tibber_url}]({tibber_url}).",
                 "data": {
                     "access_token": "API access token"
                 },
@@ -42,7 +42,7 @@
             },
             "reauth_confirm": {
                 "title": "Reauthenticate Tibber Price Integration",
-                "description": "The access token for Tibber is no longer valid. Please enter a new API access token to continue using this integration.\n\nTo generate a new API access token, visit https://developer.tibber.com.",
+                "description": "The access token for Tibber is no longer valid. Please enter a new API access token to continue using this integration.\n\nTo generate a new API access token, visit [{tibber_url}]({tibber_url}).",
                 "data": {
                     "access_token": "API access token"
                 },
@@ -77,7 +77,23 @@
         }
     },
     "common": {
-        "step_progress": "{step_num} / {total_steps}"
+        "step_progress": "{step_num} / {total_steps}",
+        "override_warning_template": "⚠️ {fields} controlled by config entity",
+        "override_warning_and": "and",
+        "override_field_label_best_price_min_period_length": "Minimum Period Length",
+        "override_field_label_best_price_max_level_gap_count": "Gap Tolerance",
+        "override_field_label_best_price_flex": "Flexibility",
+        "override_field_label_best_price_min_distance_from_avg": "Minimum Distance",
+        "override_field_label_enable_min_periods_best": "Achieve Minimum Count",
+        "override_field_label_min_periods_best": "Minimum Periods",
+        "override_field_label_relaxation_attempts_best": "Relaxation Attempts",
+        "override_field_label_peak_price_min_period_length": "Minimum Period Length",
+        "override_field_label_peak_price_max_level_gap_count": "Gap Tolerance",
+        "override_field_label_peak_price_flex": "Flexibility",
+        "override_field_label_peak_price_min_distance_from_avg": "Minimum Distance",
+        "override_field_label_enable_min_periods_peak": "Achieve Minimum Count",
+        "override_field_label_min_periods_peak": "Minimum Periods",
+        "override_field_label_relaxation_attempts_peak": "Relaxation Attempts"
     },
     "config_subentries": {
         "home": {
@@ -132,51 +148,75 @@
     "options": {
         "step": {
             "init": {
+                "menu_options": {
+                    "general_settings": "⚙️ General Settings",
+                    "display_settings": "💱 Currency Display",
+                    "current_interval_price_rating": "📊 Price Rating",
+                    "price_level": "🏷️ Price Level",
+                    "volatility": "💨 Price Volatility",
+                    "best_price": "💚 Best Price Period",
+                    "peak_price": "🔴 Peak Price Period",
+                    "price_trend": "📈 Price Trend",
+                    "chart_data_export": "📊 Chart Data Export Sensor",
+                    "reset_to_defaults": "🔄 Reset to Defaults",
+                    "finish": "⬅️ Back"
+                }
+            },
+            "general_settings": {
                 "title": "⚙️ General Settings",
-                "description": "_{step_progress}_\n\n**Configure general settings for Tibber Price Information & Ratings.**\n\n---\n\n**User:** {user_login}",
+                "description": "**Configure general settings for Tibber Price Information & Ratings.**\n\n---\n\n**User:** {user_login}",
                 "data": {
                     "extended_descriptions": "Extended Descriptions",
                     "average_sensor_display": "Average Sensor Display"
                 },
                 "data_description": {
                     "extended_descriptions": "Controls whether entity attributes include detailed explanations and usage tips.\n\n• Disabled (default): Brief description only\n• Enabled: Detailed explanation + practical usage examples\n\nExample:\nDisabled = 1 attribute\nEnabled = 2 additional attributes",
-                    "average_sensor_display": "Choose which statistical measure to display in the sensor state for average price sensors. The other value will be shown as an attribute. Median is more resistant to extreme values, while arithmetic mean represents the traditional average. Default: Median"
+                    "average_sensor_display": "Choose which statistical measure to display in the sensor state for average price sensors. The other value will be shown as an attribute.\n\n• **Median (default)**: Shows the 'typical' price, resistant to extreme spikes - best for display and human interpretation\n• **Arithmetic Mean**: Shows the true mathematical average including all prices - best when you need exact cost calculations\n\nFor automations, use the attribute `price_mean` or `price_median` to access both values regardless of this setting."
                 },
-                "submit": "Continue →"
+                "submit": "↩ Save & Back"
             },
             "display_settings": {
                 "title": "💱 Currency Display Settings",
-                "description": "_{step_progress}_\n\n**Configure how electricity prices are displayed - in base currency (€, kr) or subunit (ct, øre).**\n\n---",
+                "description": "**Configure how electricity prices are displayed - in base currency (€, kr) or subunit (ct, øre).**\n\n---",
                 "data": {
                     "currency_display_mode": "Display Mode"
                 },
                 "data_description": {
                     "currency_display_mode": "Choose how prices are displayed:\n\n• **Base Currency** (€/kWh, kr/kWh): Decimal values (e.g., 0.25 €/kWh) - differences visible from 3rd-4th decimal place\n• **Subunit Currency** (ct/kWh, øre/kWh): Larger values (e.g., 25.00 ct/kWh) - differences visible from 1st decimal place\n\nDefault depends on your currency:\n• EUR → Subunit (cents) - German/Dutch preference\n• NOK/SEK/DKK → Base (kroner) - Scandinavian preference\n• USD/GBP → Base currency\n\n**💡 Tip:** When selecting Subunit Currency, you can enable the additional \"Current Electricity Price (Energy Dashboard)\" sensor (disabled by default)."
                 },
-                "submit": "Continue →"
+                "submit": "↩ Save & Back"
             },
             "current_interval_price_rating": {
-                "title": "📊 Price Rating Thresholds",
-                "description": "_{step_progress}_\n\n**Configure thresholds for price rating levels (low/normal/high) based on comparison with trailing 24-hour average.**\n\n---",
-                "sections": {
-                    "price_rating_thresholds": {
-                        "name": "Price Rating Thresholds",
-                        "description": "Define price rating classification levels.",
+                "title": "📊 Price Rating Settings",
+                "description": "**Configure thresholds and stabilization for price rating levels (low/normal/high) based on comparison with trailing 24-hour average.**{entity_warning}",
                 "data": {
                     "price_rating_threshold_low": "Low Threshold",
-                            "price_rating_threshold_high": "High Threshold"
+                    "price_rating_threshold_high": "High Threshold",
+                    "price_rating_hysteresis": "Hysteresis",
+                    "price_rating_gap_tolerance": "Gap Tolerance"
                 },
                 "data_description": {
-                            "price_rating_threshold_low": "Percentage below the trailing 24-hour average that the current price must be to qualify as 'low' rating. Example: 5 means at least 5% below average. Sensors with this rating indicate favorable time windows. Default: 5%",
-                            "price_rating_threshold_high": "Percentage above the trailing 24-hour average that the current price must be to qualify as 'high' rating. Example: 10 means at least 10% above average. Sensors with this rating warn about expensive time windows. Default: 10%"
-                        }
-                    }
+                    "price_rating_threshold_low": "Percentage below the trailing 24-hour average that the current price must be to qualify as 'low' rating. Example: -10 means at least 10% below average. Sensors with this rating indicate favorable time windows. Default: -10%",
+                    "price_rating_threshold_high": "Percentage above the trailing 24-hour average that the current price must be to qualify as 'high' rating. Example: 10 means at least 10% above average. Sensors with this rating warn about expensive time windows. Default: 10%",
+                    "price_rating_hysteresis": "Percentage band around thresholds to prevent rapid state changes. When the rating is already LOW, the price must rise above (threshold + hysteresis) to switch to NORMAL. Similarly, HIGH requires the price to fall below (threshold - hysteresis) to leave. This provides stability for automations that react to rating changes. Set to 0 to disable. Default: 2%",
+                    "price_rating_gap_tolerance": "Maximum number of consecutive intervals that can be 'smoothed out' if they differ from surrounding ratings. Small isolated rating changes are merged into the dominant neighboring block. This provides stability for automations by preventing brief rating spikes from triggering unnecessary actions. Example: 1 means a single 'normal' interval surrounded by 'high' intervals gets corrected to 'high'. Set to 0 to disable. Default: 1"
                 },
-                "submit": "Continue →"
+                "submit": "↩ Save & Back"
+            },
+            "price_level": {
+                "title": "🏷️ Price Level Settings",
+                "description": "**Configure stabilization for Tibber's price level classification (very cheap/cheap/normal/expensive/very expensive).**\n\nTibber's API provides a price level field for each interval. This setting smooths out brief fluctuations to prevent automation instability.{entity_warning}",
+                "data": {
+                    "price_level_gap_tolerance": "Gap Tolerance"
+                },
+                "data_description": {
+                    "price_level_gap_tolerance": "Maximum number of consecutive intervals that can be 'smoothed out' if they differ from surrounding price levels. Small isolated level changes are merged into the dominant neighboring block. Example: 1 means a single 'normal' interval surrounded by 'cheap' intervals gets corrected to 'cheap'. Set to 0 to disable. Default: 1"
+                },
+                "submit": "↩ Save & Back"
             },
             "best_price": {
                 "title": "💚 Best Price Period Settings",
-                "description": "_{step_progress}_\n\n**Configure settings for the Best Price Period binary sensor. This sensor is active during periods with the lowest electricity prices.**\n\n---",
+                "description": "**Configure settings for the Best Price Period binary sensor. This sensor is active during periods with the lowest electricity prices.**{entity_warning}{override_warning}\n\n---",
                 "sections": {
                     "period_settings": {
                         "name": "Period Duration & Levels",
@@ -219,11 +259,11 @@
                         }
                     }
                 },
-                "submit": "Continue →"
+                "submit": "↩ Save & Back"
             },
             "peak_price": {
                 "title": "🔴 Peak Price Period Settings",
-                "description": "_{step_progress}_\n\n**Configure settings for the Peak Price Period binary sensor. This sensor is active during periods with the highest electricity prices.**\n\n---",
+                "description": "**Configure settings for the Peak Price Period binary sensor. This sensor is active during periods with the highest electricity prices.**{entity_warning}{override_warning}\n\n---",
                 "sections": {
                     "period_settings": {
                         "name": "Period Settings",
@@ -266,39 +306,28 @@
                         }
                     }
                 },
-                "submit": "Continue →"
+                "submit": "↩ Save & Back"
             },
             "price_trend": {
                 "title": "📈 Price Trend Thresholds",
-                "description": "_{step_progress}_\n\n**Configure thresholds for price trend sensors. These sensors compare current price with the average of the next N hours to determine if prices are rising, falling, or stable.**\n\n---",
-                "sections": {
-                    "price_trend_thresholds": {
-                        "name": "Price Trend Thresholds",
-                        "description": "Define price trend classification levels.",
+                "description": "**Configure thresholds for price trend sensors.** These sensors compare current price with the average of the next N hours to determine if prices are rising, falling, or stable.\n\n**5-Level Scale:** Uses strongly_falling (-2), falling (-1), stable (0), rising (+1), strongly_rising (+2) for automation comparisons via trend_value attribute.{entity_warning}",
                 "data": {
                     "price_trend_threshold_rising": "Rising Threshold",
-                            "price_trend_threshold_falling": "Falling Threshold"
+                    "price_trend_threshold_strongly_rising": "Strongly Rising Threshold",
+                    "price_trend_threshold_falling": "Falling Threshold",
+                    "price_trend_threshold_strongly_falling": "Strongly Falling Threshold"
                 },
                 "data_description": {
-                            "price_trend_threshold_rising": "Percentage that the average of the next N hours must be above the current price to qualify as 'rising' trend. Example: 5 means average is at least 5% higher → prices will rise. Typical values: 5-15%. Default: 5%",
-                            "price_trend_threshold_falling": "Percentage (negative) that the average of the next N hours must be below the current price to qualify as 'falling' trend. Example: -5 means average is at least 5% lower → prices will fall. Typical values: -5 to -15%. Default: -5%"
-                        }
-                    }
+                    "price_trend_threshold_rising": "Percentage that the average of the next N hours must be above the current price to qualify as 'rising' trend. Example: 3 means average is at least 3% higher → prices will rise. Typical values: 3-10%. Default: 3%",
+                    "price_trend_threshold_strongly_rising": "Percentage for 'strongly rising' trend. Must be higher than rising threshold. Example: 6 means average is at least 6% higher → prices will rise significantly. Typical values: 6-15%. Default: 6%",
+                    "price_trend_threshold_falling": "Percentage (negative) that the average of the next N hours must be below the current price to qualify as 'falling' trend. Example: -3 means average is at least 3% lower → prices will fall. Typical values: -3 to -10%. Default: -3%",
+                    "price_trend_threshold_strongly_falling": "Percentage (negative) for 'strongly falling' trend. Must be lower (more negative) than falling threshold. Example: -6 means average is at least 6% lower → prices will fall significantly. Typical values: -6 to -15%. Default: -6%"
                 },
-                "submit": "Continue →"
-            },
-            "chart_data_export": {
-                "title": "📊 Chart Data Export Sensor",
-                "description": "_{step_progress}_\n\nThe Chart Data Export Sensor provides price data as sensor attributes.\n\n⚠️ **Note:** This sensor is a legacy feature for compatibility with older tools.\n\n**Recommended for new setups:** Use the `tibber_prices.get_chartdata` **service directly** - it's more flexible, efficient, and the modern Home Assistant approach.\n\n**When this sensor makes sense:**\n\n✅ Your dashboard tool can **only** read attributes (no service calls)\n✅ You need static data that updates automatically\n❌ **Not for automations:** Use `tibber_prices.get_chartdata` directly there - more flexible and efficient!\n\n---\n\n**Enable the sensor:**\n\n1. Open **Settings → Devices & Services → Tibber Prices**\n2. Select your home → Find **'Chart Data Export'** (Diagnostic section)\n3. **Enable the sensor** (disabled by default)\n\n**Configuration (optional):**\n\nDefault settings work out-of-the-box (today+tomorrow, 15-minute intervals, prices only).\n\nFor customization, add to **`configuration.yaml`**:\n\n```yaml\ntibber_prices:\n  chart_export:\n    day:\n      - today\n      - tomorrow\n    include_level: true\n    include_rating_level: true\n```\n\n**All parameters:** See `tibber_prices.get_chartdata` service documentation",
-                "submit": "Complete ✓"
+                "submit": "↩ Save & Back"
             },
             "volatility": {
                 "title": "💨 Price Volatility Thresholds",
-                "description": "_{step_progress}_\n\n**Configure thresholds for volatility classification.** Volatility measures relative price variation using the coefficient of variation (CV = standard deviation / mean × 100%). These thresholds are percentage values that work across all price levels.\n\nUsed by:\n• Volatility sensors (classification)\n• Trend sensors (adaptive threshold adjustment: <moderate = more sensitive, ≥high = less sensitive)\n\n---",
-                "sections": {
-                    "volatility_thresholds": {
-                        "name": "Volatility Thresholds",
-                        "description": "Define price volatility classification levels.",
+                "description": "**Configure thresholds for volatility classification.** Volatility measures relative price variation using the coefficient of variation (CV = standard deviation / mean × 100%). These thresholds are percentage values that work across all price levels.\n\nUsed by:\n• Volatility sensors (classification)\n• Trend sensors (adaptive threshold adjustment: <moderate = more sensitive, ≥high = less sensitive){entity_warning}",
                 "data": {
                     "volatility_threshold_moderate": "Moderate Threshold",
                     "volatility_threshold_high": "High Threshold",
@@ -308,10 +337,21 @@
                     "volatility_threshold_moderate": "Coefficient of Variation (CV) at which prices are considered 'moderately volatile'. CV = (standard deviation / mean) × 100%. Example: 15 means price fluctuations of ±15% around average. Sensors show this classification, trend sensors become more sensitive. Default: 15%",
                     "volatility_threshold_high": "Coefficient of Variation (CV) at which prices are considered 'highly volatile'. Example: 30 means price fluctuations of ±30% around average. Larger price jumps expected, trend sensors become less sensitive. Default: 30%",
                     "volatility_threshold_very_high": "Coefficient of Variation (CV) at which prices are considered 'very highly volatile'. Example: 50 means extreme price fluctuations of ±50% around average. On such days, strong price spikes are likely. Default: 50%"
-                        }
-                    }
                 },
-                "submit": "Continue →"
+                "submit": "↩ Save & Back"
+            },
+            "chart_data_export": {
+                "title": "📊 Chart Data Export Sensor",
+                "description": "The Chart Data Export Sensor provides price data as sensor attributes.\n\n⚠️ **Note:** This sensor is a legacy feature for compatibility with older tools.\n\n**Recommended for new setups:** Use the `tibber_prices.get_chartdata` **service directly** - it's more flexible, efficient, and the modern Home Assistant approach.\n\n**When this sensor makes sense:**\n\n✅ Your dashboard tool can **only** read attributes (no service calls)\n✅ You need static data that updates automatically\n❌ **Not for automations:** Use `tibber_prices.get_chartdata` directly there - more flexible and efficient!\n\n---\n\n{sensor_status_info}",
+                "submit": "↩ Ok & Back"
+            },
+            "reset_to_defaults": {
+                "title": "🔄 Reset to Defaults",
+                "description": "⚠️ **Warning:** This will reset **ALL** settings to factory defaults.\n\n**What will be reset:**\n• All price rating thresholds\n• All volatility thresholds\n• All price trend thresholds\n• All best price period settings\n• All peak price period settings\n• Display settings\n• General settings\n\n**What will NOT be reset:**\n• Your Tibber API token\n• Selected home\n• Currency\n\n**💡 Tip:** This is useful if you want to start fresh after experimenting with settings.",
+                "data": {
+                    "confirm_reset": "Yes, reset everything to defaults"
+                },
+                "submit": "Reset Now"
             }
         },
         "error": {
@@ -336,10 +376,17 @@
             "invalid_volatility_threshold_very_high": "Very high volatility threshold must be between 35% and 80%",
             "invalid_volatility_thresholds": "Thresholds must be in ascending order: moderate < high < very high",
             "invalid_price_trend_rising": "Rising trend threshold must be between 1% and 50%",
-            "invalid_price_trend_falling": "Falling trend threshold must be between -50% and -1%"
+            "invalid_price_trend_falling": "Falling trend threshold must be between -50% and -1%",
+            "invalid_price_trend_strongly_rising": "Strongly rising trend threshold must be between 2% and 100%",
+            "invalid_price_trend_strongly_falling": "Strongly falling trend threshold must be between -100% and -2%",
+            "invalid_trend_strongly_rising_less_than_rising": "Strongly rising threshold must be greater than rising threshold",
+            "invalid_trend_strongly_falling_greater_than_falling": "Strongly falling threshold must be less (more negative) than falling threshold"
         },
         "abort": {
-            "entry_not_found": "Tibber configuration entry not found."
+            "entry_not_found": "Tibber configuration entry not found.",
+            "reset_cancelled": "Reset cancelled. No changes were made to your configuration.",
+            "reset_successful": "✅ All settings have been reset to factory defaults. Your configuration is now like a fresh installation.",
+            "finished": "Configuration completed."
         }
     },
     "entity": {
@@ -569,73 +616,91 @@
             "price_trend_1h": {
                 "name": "Price Trend (1h)",
                 "state": {
+                    "strongly_rising": "Strongly Rising",
                     "rising": "Rising",
+                    "stable": "Stable",
                     "falling": "Falling",
-                    "stable": "Stable"
+                    "strongly_falling": "Strongly Falling"
                 }
             },
             "price_trend_2h": {
                 "name": "Price Trend (2h)",
                 "state": {
+                    "strongly_rising": "Strongly Rising",
                     "rising": "Rising",
+                    "stable": "Stable",
                     "falling": "Falling",
-                    "stable": "Stable"
+                    "strongly_falling": "Strongly Falling"
                 }
             },
             "price_trend_3h": {
                 "name": "Price Trend (3h)",
                 "state": {
+                    "strongly_rising": "Strongly Rising",
                     "rising": "Rising",
+                    "stable": "Stable",
                     "falling": "Falling",
-                    "stable": "Stable"
+                    "strongly_falling": "Strongly Falling"
                 }
             },
             "price_trend_4h": {
                 "name": "Price Trend (4h)",
                 "state": {
+                    "strongly_rising": "Strongly Rising",
                     "rising": "Rising",
+                    "stable": "Stable",
                     "falling": "Falling",
-                    "stable": "Stable"
+                    "strongly_falling": "Strongly Falling"
                 }
             },
             "price_trend_5h": {
                 "name": "Price Trend (5h)",
                 "state": {
+                    "strongly_rising": "Strongly Rising",
                     "rising": "Rising",
+                    "stable": "Stable",
                     "falling": "Falling",
-                    "stable": "Stable"
+                    "strongly_falling": "Strongly Falling"
                 }
             },
             "price_trend_6h": {
                 "name": "Price Trend (6h)",
                 "state": {
+                    "strongly_rising": "Strongly Rising",
                     "rising": "Rising",
+                    "stable": "Stable",
                     "falling": "Falling",
-                    "stable": "Stable"
+                    "strongly_falling": "Strongly Falling"
                 }
             },
             "price_trend_8h": {
                 "name": "Price Trend (8h)",
                 "state": {
+                    "strongly_rising": "Strongly Rising",
                     "rising": "Rising",
+                    "stable": "Stable",
                     "falling": "Falling",
-                    "stable": "Stable"
+                    "strongly_falling": "Strongly Falling"
                 }
             },
             "price_trend_12h": {
                 "name": "Price Trend (12h)",
                 "state": {
+                    "strongly_rising": "Strongly Rising",
                     "rising": "Rising",
+                    "stable": "Stable",
                     "falling": "Falling",
-                    "stable": "Stable"
+                    "strongly_falling": "Strongly Falling"
                 }
             },
             "current_price_trend": {
                 "name": "Current Price Trend",
                 "state": {
+                    "strongly_rising": "Strongly Rising",
                     "rising": "Rising",
+                    "stable": "Stable",
                     "falling": "Falling",
-                    "stable": "Stable"
+                    "strongly_falling": "Strongly Falling"
                 }
             },
             "next_price_trend_change": {
@@ -837,6 +902,52 @@
             "realtime_consumption_enabled": {
                 "name": "Realtime Consumption Enabled"
             }
+        },
+        "number": {
+            "best_price_flex_override": {
+                "name": "Best Price: Flexibility"
+            },
+            "best_price_min_distance_override": {
+                "name": "Best Price: Minimum Distance"
+            },
+            "best_price_min_period_length_override": {
+                "name": "Best Price: Minimum Period Length"
+            },
+            "best_price_min_periods_override": {
+                "name": "Best Price: Minimum Periods"
+            },
+            "best_price_relaxation_attempts_override": {
+                "name": "Best Price: Relaxation Attempts"
+            },
+            "best_price_gap_count_override": {
+                "name": "Best Price: Gap Tolerance"
+            },
+            "peak_price_flex_override": {
+                "name": "Peak Price: Flexibility"
+            },
+            "peak_price_min_distance_override": {
+                "name": "Peak Price: Minimum Distance"
+            },
+            "peak_price_min_period_length_override": {
+                "name": "Peak Price: Minimum Period Length"
+            },
+            "peak_price_min_periods_override": {
+                "name": "Peak Price: Minimum Periods"
+            },
+            "peak_price_relaxation_attempts_override": {
+                "name": "Peak Price: Relaxation Attempts"
+            },
+            "peak_price_gap_count_override": {
+                "name": "Peak Price: Gap Tolerance"
+            }
+        },
+        "switch": {
+            "best_price_enable_relaxation_override": {
+                "name": "Best Price: Achieve Minimum Count"
+            },
+            "peak_price_enable_relaxation_override": {
+                "name": "Peak Price: Achieve Minimum Count"
+            }
         }
     },
     "issues": {
@@ -899,6 +1010,14 @@
                 "highlight_best_price": {
                     "name": "Highlight Best Price Periods",
                     "description": "Add a semi-transparent green overlay to highlight the best price periods on the chart. This makes it easy to visually identify the optimal times for energy consumption."
+                },
+                "highlight_peak_price": {
+                    "name": "Highlight Peak Price Periods",
+                    "description": "Add a semi-transparent red overlay to highlight the peak price periods on the chart. This makes it easy to visually identify times when energy is most expensive."
+                },
+                "resolution": {
+                    "name": "Resolution",
+                    "description": "Time resolution for the chart data. 'interval' (default): Original 15-minute intervals (96 points per day). 'hourly': Aggregated hourly values using a rolling 60-minute window (24 points per day) for a cleaner, less cluttered chart."
                 }
             }
         },
@@ -1043,6 +1162,16 @@
                     "description": "The config entry ID for the Tibber integration."
                 }
             }
+        },
+        "debug_clear_tomorrow": {
+            "name": "Debug: Clear Tomorrow Data",
+            "description": "DEBUG/TESTING: Removes tomorrow's price data from the interval pool cache. Use this to test the tomorrow data refresh cycle without waiting for the next day. After calling this service, the lifecycle sensor will show 'searching_tomorrow' (after 13:00) and the next Timer #1 cycle will fetch new data from the API.",
+            "fields": {
+                "entry_id": {
+                    "name": "Entry ID",
+                    "description": "Optional config entry ID. If not provided, uses the first available entry."
+                }
+            }
         }
     },
     "selector": {

custom_components/tibber_prices/translations/nb.json

@@ -11,14 +11,14 @@
             },
             "new_token": {
                 "title": "Skriv inn API-token",
-                "description": "Sett opp Tibber Prisinformasjon & Vurderinger.\n\nFor å generere et API-tilgangstoken, besøk https://developer.tibber.com.",
+                "description": "Sett opp Tibber Prisinformasjon & Vurderinger.\n\nFor å generere et API-tilgangstoken, besøk [{tibber_url}]({tibber_url}).",
                 "data": {
                     "access_token": "API-tilgangstoken"
                 },
                 "submit": "Valider token"
             },
             "user": {
-                "description": "Sett opp Tibber Prisinformasjon & Vurderinger.\n\nFor å generere et API-tilgangstoken, besøk https://developer.tibber.com.",
+                "description": "Sett opp Tibber Prisinformasjon & Vurderinger.\n\nFor å generere et API-tilgangstoken, besøk [{tibber_url}]({tibber_url}).",
                 "data": {
                     "access_token": "API-tilgangstoken"
                 },
@@ -42,7 +42,7 @@
             },
             "reauth_confirm": {
                 "title": "Autentiser Tibber Prisintegrasjonen på nytt",
-                "description": "Tilgangstokenet for Tibber er ikke lenger gyldig. Vennligst oppgi et nytt API-tilgangstoken for å fortsette å bruke denne integrasjonen.\n\nFor å generere et nytt API-tilgangstoken, besøk https://developer.tibber.com.",
+                "description": "Tilgangstokenet for Tibber er ikke lenger gyldig. Vennligst oppgi et nytt API-tilgangstoken for å fortsette å bruke denne integrasjonen.\n\nFor å generere et nytt API-tilgangstoken, besøk [{tibber_url}]({tibber_url}).",
                 "data": {
                     "access_token": "API-tilgangstoken"
                 },
@@ -77,7 +77,23 @@
         }
     },
     "common": {
-        "step_progress": "{step_num} / {total_steps}"
+        "step_progress": "{step_num} / {total_steps}",
+        "override_warning_template": "⚠️ {fields} styres av konfigurasjons-entitet",
+        "override_warning_and": "og",
+        "override_field_label_best_price_min_period_length": "Minste periodelengde",
+        "override_field_label_best_price_max_level_gap_count": "Gaptoleranse",
+        "override_field_label_best_price_flex": "Fleksibilitet",
+        "override_field_label_best_price_min_distance_from_avg": "Minimumsavstand",
+        "override_field_label_enable_min_periods_best": "Oppnå minimum antall",
+        "override_field_label_min_periods_best": "Minimumperioder",
+        "override_field_label_relaxation_attempts_best": "Avslapningsforsøk",
+        "override_field_label_peak_price_min_period_length": "Minste periodelengde",
+        "override_field_label_peak_price_max_level_gap_count": "Gaptoleranse",
+        "override_field_label_peak_price_flex": "Fleksibilitet",
+        "override_field_label_peak_price_min_distance_from_avg": "Minimumsavstand",
+        "override_field_label_enable_min_periods_peak": "Oppnå minimum antall",
+        "override_field_label_min_periods_peak": "Minimumperioder",
+        "override_field_label_relaxation_attempts_peak": "Avslapningsforsøk"
     },
     "config_subentries": {
         "home": {
@@ -132,17 +148,32 @@
     "options": {
         "step": {
             "init": {
+                "menu_options": {
+                    "general_settings": "⚙️ Generelle innstillinger",
+                    "display_settings": "💱 Valutavisning",
+                    "current_interval_price_rating": "📊 Prisvurdering",
+                    "price_level": "🏷️ Prisnivå",
+                    "volatility": "💨 Prisvolatilitet",
+                    "best_price": "💚 Beste prisperiode",
+                    "peak_price": "🔴 Toppprisperiode",
+                    "price_trend": "📈 Pristrend",
+                    "chart_data_export": "📊 Diagramdata-eksportsensor",
+                    "reset_to_defaults": "🔄 Tilbakestill til standard",
+                    "finish": "⬅️ Tilbake"
+                }
+            },
+            "general_settings": {
                 "title": "⚙️ Generelle innstillinger",
-                "description": "_{step_progress}_\n\n**Konfigurer generelle innstillinger for Tibber prisinformasjon og vurderinger.**\n\n---\n\n**Bruker:** {user_login}",
+                "description": "**Konfigurer generelle innstillinger for Tibber prisinformasjon og vurderinger.**\n\n---\n\n**Bruker:** {user_login}",
                 "data": {
                     "extended_descriptions": "Utvidede beskrivelser",
                     "average_sensor_display": "Gjennomsnittssensor-visning"
                 },
                 "data_description": {
                     "extended_descriptions": "Styrer om entitetsattributter inkluderer detaljerte forklaringer og brukstips.\n\n• Deaktivert (standard): Bare kort beskrivelse\n• Aktivert: Detaljert forklaring + praktiske brukseksempler\n\nEksempel:\nDeaktivert = 1 attributt\nAktivert = 2 ekstra attributter",
-                    "average_sensor_display": "Velg hvilket statistisk mål som skal vises i sensortilstanden for gjennomsnittspris-sensorer. Den andre verdien vises som attributt. Median er mer motstandsdyktig mot ekstremverdier, mens aritmetisk gjennomsnitt representerer tradisjonelt gjennomsnitt. Standard: Median"
+                    "average_sensor_display": "Velg hvilket statistisk mål som skal vises i sensortilstanden for gjennomsnittspris-sensorer. Den andre verdien vises som attributt.\n\n• **Median (standard)**: Viser den 'typiske' prisen, motstandsdyktig mot ekstreme topper - best for visning og menneskelig tolkning\n• **Aritmetisk gjennomsnitt**: Viser det sanne matematiske gjennomsnittet inkludert alle priser - best når du trenger eksakte kostnadsberegninger\n\nFor automatiseringer, bruk attributtet `price_mean` eller `price_median` for å få tilgang til begge verdier uavhengig av denne innstillingen."
                 },
-                "submit": "Videre til trinn 2"
+                "submit": "↩ Lagre & tilbake"
             },
             "display_settings": {
                 "title": "💱 Valutavisningsinnstillinger",
@@ -153,30 +184,28 @@
                 "data_description": {
                     "currency_display_mode": "Velg hvordan priser vises:\n\n• **Basisvaluta** (€/kWh, kr/kWh): Desimalverdier (f.eks. 0,25 €/kWh) - forskjeller synlige fra 3.-4. desimalplass\n• **Underenhet** (ct/kWh, øre/kWh): Større verdier (f.eks. 25,00 ct/kWh) - forskjeller allerede synlige fra 1. desimalplass\n\nStandard avhenger av valutaen din:\n• EUR → Underenhet (cent) - tysk/nederlandsk preferanse\n• NOK/SEK/DKK → Basisvaluta (kroner) - skandinavisk preferanse\n• USD/GBP → Basisvaluta\n\n**💡 Tips:** Ved valg av underenhet kan du aktivere den ekstra sensoren \"Nåværende strømpris (Energi-dashboard)\" (deaktivert som standard)."
                 },
-                "submit": "Videre til trinn 3"
+                "submit": "↩ Lagre & tilbake"
             },
             "current_interval_price_rating": {
-                "title": "📊 Prisvurderings-terskler",
-                "description": "_{step_progress}_\n\n**Konfigurer terskler for prisvurderingsnivåer (lav/normal/høy) basert på sammenligning med etterfølgende 24-timers gjennomsnitt.**\n\n---",
-                "sections": {
-                    "price_rating_thresholds": {
-                        "name": "Prisvurderings-terskler",
-                        "description": "Definer prisvurderingsnivåer.",
+                "title": "📊 Prisvurderingsinnstillinger",
+                "description": "**Konfigurer terskler og stabilisering for prisvurderingsnivåer (lav/normal/høy) basert på sammenligning med etterfølgende 24-timers gjennomsnitt.**{entity_warning}",
                 "data": {
                     "price_rating_threshold_low": "Lav-terskel",
-                            "price_rating_threshold_high": "Høy-terskel"
+                    "price_rating_threshold_high": "Høy-terskel",
+                    "price_rating_hysteresis": "Hysterese",
+                    "price_rating_gap_tolerance": "Gap-toleranse"
                 },
                 "data_description": {
-                            "price_rating_threshold_low": "Prosentverdi for hvor mye gjeldende pris må være under det etterfølgende 24-timers gjennomsnittet for å kvalifisere som 'lav' vurdering. Eksempel: 5 betyr minst 5% under gjennomsnitt. Sensorer med denne vurderingen indikerer gunstige tidsvinduer. Standard: 5%",
-                            "price_rating_threshold_high": "Prosentverdi for hvor mye gjeldende pris må være over det etterfølgende 24-timers gjennomsnittet for å kvalifisere som 'høy' vurdering. Eksempel: 10 betyr minst 10% over gjennomsnitt. Sensorer med denne vurderingen advarer om dyre tidsvinduer. Standard: 10%"
-                        }
-                    }
+                    "price_rating_threshold_low": "Prosentverdi for hvor mye gjeldende pris må være under det etterfølgende 24-timers gjennomsnittet for å kvalifisere som 'lav' vurdering. Eksempel: -10 betyr minst 10% under gjennomsnitt. Sensorer med denne vurderingen indikerer gunstige tidsvinduer. Standard: -10%",
+                    "price_rating_threshold_high": "Prosentverdi for hvor mye gjeldende pris må være over det etterfølgende 24-timers gjennomsnittet for å kvalifisere som 'høy' vurdering. Eksempel: 10 betyr minst 10% over gjennomsnitt. Sensorer med denne vurderingen advarer om dyre tidsvinduer. Standard: 10%",
+                    "price_rating_hysteresis": "Prosentbånd rundt terskler for å unngå raske tilstandsendringer. Når vurderingen allerede er LAV, må prisen stige over (terskel + hysterese) for å bytte til NORMAL. Tilsvarende krever HØY at prisen faller under (terskel - hysterese) for å forlate tilstanden. Dette gir stabilitet for automatiseringer som reagerer på vurderingsendringer. Sett til 0 for å deaktivere. Standard: 2%",
+                    "price_rating_gap_tolerance": "Maksimalt antall påfølgende intervaller som kan 'jevnes ut' hvis de avviker fra omkringliggende vurderinger. Små isolerte vurderingsendringer slås sammen med den dominerende nabogruppen. Dette gir stabilitet for automatiseringer ved å forhindre at korte vurderingstopper utløser unødvendige handlinger. Eksempel: 1 betyr at et enkelt 'normal'-intervall omgitt av 'høy'-intervaller korrigeres til 'høy'. Sett til 0 for å deaktivere. Standard: 1"
                 },
-                "submit": "Fortsett →"
+                "submit": "↩ Lagre & tilbake"
             },
             "best_price": {
                 "title": "💚 Beste Prisperiode Innstillinger",
-                "description": "_{step_progress}_\n\nKonfigurer innstillinger for **Beste Prisperiode** binærsensor. Denne sensoren er aktiv i perioder med de laveste strømprisene.\n\n---",
+                "description": "**Konfigurer innstillinger for Beste Prisperiode binærsensor. Denne sensoren er aktiv i perioder med de laveste strømprisene.**{entity_warning}{override_warning}\n\n---",
                 "sections": {
                     "period_settings": {
                         "name": "Periodeinnstillinger",
@@ -219,11 +248,11 @@
                         }
                     }
                 },
-                "submit": "Fortsett →"
+                "submit": "↩ Lagre & tilbake"
             },
             "peak_price": {
                 "title": "🔴 Toppprisperiode Innstillinger",
-                "description": "_{step_progress}_\n\nKonfigurer innstillinger for **Toppprisperiode** binærsensor. Denne sensoren er aktiv i perioder med de høyeste strømprisene.\n\n---",
+                "description": "**Konfigurer innstillinger for Toppprisperiode binærsensor. Denne sensoren er aktiv i perioder med de høyeste strømprisene.**{entity_warning}{override_warning}\n\n---",
                 "sections": {
                     "period_settings": {
                         "name": "Periodeinnstillinger",
@@ -266,52 +295,63 @@
                         }
                     }
                 },
-                "submit": "Fortsett →"
+                "submit": "↩ Lagre & tilbake"
             },
             "price_trend": {
                 "title": "📈 Pristrendterskler",
-                "description": "_{step_progress}_\n\n**Konfigurer terskler for pristrendsensorer. Disse sensorene sammenligner nåværende pris med gjennomsnittet av de neste N timene for å bestemme om prisene stiger, faller eller er stabile.**\n\n---",
-                "sections": {
-                    "price_trend_thresholds": {
-                        "name": "Pristrendterskler",
-                        "description": "Definer pristrendnivåer.",
+                "description": "**Konfigurer terskler for pristrendsensorer. Disse sensorene sammenligner nåværende pris med gjennomsnittet av de neste N timene for å bestemme om prisene stiger sterkt, stiger, er stabile, faller eller faller sterkt.**{entity_warning}",
                 "data": {
                     "price_trend_threshold_rising": "Stigende terskel",
-                            "price_trend_threshold_falling": "Fallende terskel"
+                    "price_trend_threshold_strongly_rising": "Sterkt stigende terskel",
+                    "price_trend_threshold_falling": "Fallende terskel",
+                    "price_trend_threshold_strongly_falling": "Sterkt fallende terskel"
                 },
                 "data_description": {
-                            "price_trend_threshold_rising": "Prosentverdi for gjennomsnittlig prisøkning per time som kvalifiserer trenden som 'stigende'. Eksempel: 5 betyr minst 5% økning per time. Sensorer med denne trenden indikerer at prisene vil stige raskt. Standard: 5%",
-                            "price_trend_threshold_falling": "Prosentverdi for gjennomsnittlig prisnedgang per time som kvalifiserer trenden som 'synkende'. Eksempel: -5 betyr minst 5% nedgang per time. Sensorer med denne trenden indikerer at prisene vil synke raskt. Standard: -5%"
-                        }
-                    }
+                    "price_trend_threshold_rising": "Prosentverdi som gjennomsnittet av de neste N timene må være over den nåværende prisen for å kvalifisere som 'stigende' trend. Eksempel: 3 betyr gjennomsnittet er minst 3% høyere → prisene vil stige. Typiske verdier: 3-10%. Standard: 3%",
+                    "price_trend_threshold_strongly_rising": "Prosentverdi som gjennomsnittet av de neste N timene må være over den nåværende prisen for å kvalifisere som 'sterkt stigende' trend. Må være høyere enn stigende terskel. Typiske verdier: 6-20%. Standard: 6%",
+                    "price_trend_threshold_falling": "Prosentverdi (negativ) som gjennomsnittet av de neste N timene må være under den nåværende prisen for å kvalifisere som 'synkende' trend. Eksempel: -3 betyr gjennomsnittet er minst 3% lavere → prisene vil falle. Typiske verdier: -3 til -10%. Standard: -3%",
+                    "price_trend_threshold_strongly_falling": "Prosentverdi (negativ) som gjennomsnittet av de neste N timene må være under den nåværende prisen for å kvalifisere som 'sterkt synkende' trend. Må være lavere (mer negativ) enn fallende terskel. Typiske verdier: -6 til -20%. Standard: -6%"
                 },
-                "submit": "Fortsett →"
+                "submit": "↩ Lagre & tilbake"
             },
             "volatility": {
                 "title": "💨 Volatilitets-terskler",
-                "description": "_{step_progress}_\n\n**Konfigurer terskler for volatilitetsklassifisering. Volatilitet måler relativ prisvariation ved hjelp av variasjonskoeffisienten (VK = standardavvik / gjennomsnitt × 100%). Disse tersklene er prosentverdier som fungerer på tvers av alle prisnivåer.**\n\nBrukes av:\n• Volatilitetssensorer (klassifisering)\n• Trendsensorer (adaptiv terskel justering: <moderat = mer følsom, ≥høy = mindre følsom)\n\n---",
-                "sections": {
-                    "volatility_thresholds": {
-                        "name": "Volatilitetsterskler",
-                        "description": "Definer volatilitetsklassifiseringsnivåer.",
+                "description": "**Konfigurer terskler for volatilitetsklassifisering.** Volatilitet måler relativ prisvariation ved hjelp av variasjonskoeffisienten (VK = standardavvik / gjennomsnitt × 100%). Disse tersklene er prosentverdier som fungerer på tvers av alle prisnivåer.\n\nBrukes av:\n• Volatilitetssensorer (klassifisering)\n• Trendsensorer (adaptiv terskel justering: <moderat = mer følsom, ≥høy = mindre følsom){entity_warning}",
                 "data": {
                     "volatility_threshold_moderate": "Moderat terskel",
                     "volatility_threshold_high": "Høy terskel",
                     "volatility_threshold_very_high": "Veldig høy terskel"
                 },
                 "data_description": {
-                            "volatility_threshold_moderate": "Grenseverdi for standardavvik (% av gjennomsnitt) for å klassifisere prisvariasjonen som 'moderat'. Eksempel: 10 betyr standardavvik ≥ 10% av gjennomsnitt. Dette indikerer økt prisustabilitet. Standard: 10%",
-                            "volatility_threshold_high": "Grenseverdi for standardavvik (% av gjennomsnitt) for å klassifisere prisvariasjonen som 'høy'. Eksempel: 20 betyr standardavvik ≥ 20% av gjennomsnitt. Dette indikerer betydelige prissvingninger. Standard: 20%",
-                            "volatility_threshold_very_high": "Grenseverdi for standardavvik (% av gjennomsnitt) for å klassifisere prisvariasjonen som 'veldig høy'. Eksempel: 30 betyr standardavvik ≥ 30% av gjennomsnitt. Dette indikerer ekstrem prisustabilitet. Standard: 30%"
-                        }
-                    }
+                    "volatility_threshold_moderate": "Variasjonskoeffisient (VK) der prisene anses som 'moderat volatile'. VK = (standardavvik / gjennomsnitt) × 100%. Eksempel: 15 betyr prissvingninger på ±15% rundt gjennomsnittet. Sensorer viser denne klassifiseringen, trendsensorer blir mer følsomme. Standard: 15%",
+                    "volatility_threshold_high": "Variasjonskoeffisient (VK) der prisene anses som 'svært volatile'. Eksempel: 30 betyr prissvingninger på ±30% rundt gjennomsnittet. Større prishopp forventes, trendsensorer blir mindre følsomme. Standard: 30%",
+                    "volatility_threshold_very_high": "Variasjonskoeffisient (VK) der prisene anses som 'veldig svært volatile'. Eksempel: 50 betyr ekstreme prissvingninger på ±50% rundt gjennomsnittet. På slike dager er sterke pristoppsannsynlige. Standard: 50%"
                 },
-                "submit": "Fortsett →"
+                "submit": "↩ Lagre & tilbake"
             },
             "chart_data_export": {
                 "title": "📊 Diagram-dataeksport Sensor",
-                "description": "_{step_progress}_\n\nDiagram-dataeksport-sensoren gir prisdata som sensorattributter.\n\n⚠️ **Merk:** Denne sensoren er en legacy-funksjon for kompatibilitet med eldre verktøy.\n\n**Anbefalt for nye oppsett:** Bruk `tibber_prices.get_chartdata` **tjenesten direkte** - den er mer fleksibel, effektiv og den moderne Home Assistant-tilnærmingen.\n\n**Når denne sensoren gir mening:**\n\n✅ Dashboardverktøyet ditt kan **kun** lese attributter (ingen tjenestekall)\n✅ Du trenger statiske data som oppdateres automatisk\n❌ **Ikke for automatiseringer:** Bruk `tibber_prices.get_chartdata` direkte der - mer fleksibel og effektiv!\n\n---\n\n**Aktiver sensoren:**\n\n1. Åpne **Innstillinger → Enheter og tjenester → Tibber Prices**\n2. Velg ditt hjem → Finn **'Diagramdataeksport'** (Diagnostikk-seksjonen)\n3. **Aktiver sensoren** (deaktivert som standard)\n\n**Konfigurasjon (valgfritt):**\n\nStandardinnstillinger fungerer umiddelbart (i dag+i morgen, 15-minutters intervaller, bare priser).\n\nFor tilpasning, legg til i **`configuration.yaml`**:\n\n```yaml\ntibber_prices:\n  chart_export:\n    day:\n      - today\n      - tomorrow\n    include_level: true\n    include_rating_level: true\n```\n\n**Alle parametere:** Se `tibber_prices.get_chartdata` tjenestens dokumentasjon",
-                "submit": "Fullfør ✓"
+                "description": "Diagram-dataeksport-sensoren gir prisdata som sensorattributter.\n\n⚠️ **Merk:** Denne sensoren er en legacy-funksjon for kompatibilitet med eldre verktøy.\n\n**Anbefalt for nye oppsett:** Bruk `tibber_prices.get_chartdata` **tjenesten direkte** - den er mer fleksibel, effektiv og den moderne Home Assistant-tilnærmingen.\n\n**Når denne sensoren gir mening:**\n\n✅ Dashboardverktøyet ditt kan **kun** lese attributter (ingen tjenestekall)\n✅ Du trenger statiske data som oppdateres automatisk\n❌ **Ikke for automatiseringer:** Bruk `tibber_prices.get_chartdata` direkte der - mer fleksibel og effektiv!\n\n---\n\n{sensor_status_info}",
+                "submit": "↩ Ok & tilbake"
+            },
+            "reset_to_defaults": {
+                "title": "🔄 Tilbakestill til standard",
+                "description": "⚠️ **Advarsel:** Dette vil tilbakestille **ALLE** innstillinger til fabrikkstandard.\n\n**Hva vil bli tilbakestilt:**\n• Alle prisvurderingsterskler\n• Alle volatilitetsterskler\n• Alle pristrendterskler\n• Alle innstillinger for beste prisperiode\n• Alle innstillinger for toppprisperiode\n• Visningsinnstillinger\n• Generelle innstillinger\n\n**Hva vil IKKE bli tilbakestilt:**\n• Ditt Tibber API-token\n• Valgt hjem\n• Valuta\n\n**💡 Tips:** Dette er nyttig hvis du vil starte på nytt etter å ha eksperimentert med innstillinger.",
+                "data": {
+                    "confirm_reset": "Ja, tilbakestill alt til standard"
+                },
+                "submit": "Tilbakestill nå"
+            },
+            "price_level": {
+                "title": "🏷️ Prisnivå-innstillinger",
+                "description": "**Konfigurer stabilisering for Tibbers prisnivå-klassifisering (veldig billig/billig/normal/dyr/veldig dyr).**\n\nTibbers API gir et prisnivå-felt for hvert intervall. Denne innstillingen jevner ut korte svingninger for å forhindre ustabilitet i automatiseringer.{entity_warning}",
+                "data": {
+                    "price_level_gap_tolerance": "Gap-toleranse"
+                },
+                "data_description": {
+                    "price_level_gap_tolerance": "Maksimalt antall påfølgende intervaller som kan 'jevnes ut' hvis de avviker fra omkringliggende prisnivåer. Små isolerte nivåendringer slås sammen med den dominerende nabogruppen. Eksempel: 1 betyr at et enkelt 'normal'-intervall omgitt av 'billig'-intervaller korrigeres til 'billig'. Sett til 0 for å deaktivere. Standard: 1"
+                },
+                "submit": "↩ Lagre & tilbake"
             }
         },
         "error": {
@@ -336,10 +376,17 @@
             "invalid_volatility_threshold_very_high": "Svært høy volatilitetsgrense må være mellom 35% og 80%",
             "invalid_volatility_thresholds": "Grensene må være i stigende rekkefølge: moderat < høy < svært høy",
             "invalid_price_trend_rising": "Stigende trendgrense må være mellom 1% og 50%",
-            "invalid_price_trend_falling": "Fallende trendgrense må være mellom -50% og -1%"
+            "invalid_price_trend_falling": "Fallende trendgrense må være mellom -50% og -1%",
+            "invalid_price_trend_strongly_rising": "Sterkt stigende trendgrense må være mellom 2% og 100%",
+            "invalid_price_trend_strongly_falling": "Sterkt fallende trendgrense må være mellom -100% og -2%",
+            "invalid_trend_strongly_rising_less_than_rising": "Sterkt stigende-grense må være høyere enn stigende-grense",
+            "invalid_trend_strongly_falling_greater_than_falling": "Sterkt fallende-grense må være lavere (mer negativ) enn fallende-grense"
         },
         "abort": {
-            "entry_not_found": "Tibber-konfigurasjonsoppføring ikke funnet."
+            "entry_not_found": "Tibber-konfigurasjonsoppføring ikke funnet.",
+            "reset_cancelled": "Tilbakestilling avbrutt. Ingen endringer ble gjort i konfigurasjonen din.",
+            "reset_successful": "✅ Alle innstillinger har blitt tilbakestilt til fabrikkstandard. Konfigurasjonen din er nå som en ny installasjon.",
+            "finished": "Konfigurasjon fullført."
         }
     },
     "entity": {
@@ -569,73 +616,91 @@
             "price_trend_1h": {
                 "name": "Pristrend (1t)",
                 "state": {
+                    "strongly_rising": "Sterkt stigende",
                     "rising": "Stigende",
+                    "stable": "Stabil",
                     "falling": "Fallende",
-                    "stable": "Stabil"
+                    "strongly_falling": "Sterkt fallende"
                 }
             },
             "price_trend_2h": {
                 "name": "Pristrend (2t)",
                 "state": {
+                    "strongly_rising": "Sterkt stigende",
                     "rising": "Stigende",
+                    "stable": "Stabil",
                     "falling": "Fallende",
-                    "stable": "Stabil"
+                    "strongly_falling": "Sterkt fallende"
                 }
             },
             "price_trend_3h": {
                 "name": "Pristrend (3t)",
                 "state": {
+                    "strongly_rising": "Sterkt stigende",
                     "rising": "Stigende",
+                    "stable": "Stabil",
                     "falling": "Fallende",
-                    "stable": "Stabil"
+                    "strongly_falling": "Sterkt fallende"
                 }
             },
             "price_trend_4h": {
                 "name": "Pristrend (4t)",
                 "state": {
+                    "strongly_rising": "Sterkt stigende",
                     "rising": "Stigende",
+                    "stable": "Stabil",
                     "falling": "Fallende",
-                    "stable": "Stabil"
+                    "strongly_falling": "Sterkt fallende"
                 }
             },
             "price_trend_5h": {
                 "name": "Pristrend (5t)",
                 "state": {
+                    "strongly_rising": "Sterkt stigende",
                     "rising": "Stigende",
+                    "stable": "Stabil",
                     "falling": "Fallende",
-                    "stable": "Stabil"
+                    "strongly_falling": "Sterkt fallende"
                 }
             },
             "price_trend_6h": {
                 "name": "Pristrend (6t)",
                 "state": {
+                    "strongly_rising": "Sterkt stigende",
                     "rising": "Stigende",
+                    "stable": "Stabil",
                     "falling": "Fallende",
-                    "stable": "Stabil"
+                    "strongly_falling": "Sterkt fallende"
                 }
             },
             "price_trend_8h": {
                 "name": "Pristrend (8t)",
                 "state": {
+                    "strongly_rising": "Sterkt stigende",
                     "rising": "Stigende",
+                    "stable": "Stabil",
                     "falling": "Fallende",
-                    "stable": "Stabil"
+                    "strongly_falling": "Sterkt fallende"
                 }
             },
             "price_trend_12h": {
                 "name": "Pristrend (12t)",
                 "state": {
+                    "strongly_rising": "Sterkt stigende",
                     "rising": "Stigende",
+                    "stable": "Stabil",
                     "falling": "Fallende",
-                    "stable": "Stabil"
+                    "strongly_falling": "Sterkt fallende"
                 }
             },
             "current_price_trend": {
                 "name": "Nåværende pristrend",
                 "state": {
+                    "strongly_rising": "Sterkt stigende",
                     "rising": "Stigende",
+                    "stable": "Stabil",
                     "falling": "Fallende",
-                    "stable": "Stabil"
+                    "strongly_falling": "Sterkt fallende"
                 }
             },
             "next_price_trend_change": {
@@ -837,6 +902,52 @@
             "realtime_consumption_enabled": {
                 "name": "Sanntidsforbruk aktivert"
             }
+        },
+        "number": {
+            "best_price_flex_override": {
+                "name": "Beste pris: Fleksibilitet"
+            },
+            "best_price_min_distance_override": {
+                "name": "Beste pris: Minimumsavstand"
+            },
+            "best_price_min_period_length_override": {
+                "name": "Beste pris: Minimum periodelengde"
+            },
+            "best_price_min_periods_override": {
+                "name": "Beste pris: Minimum perioder"
+            },
+            "best_price_relaxation_attempts_override": {
+                "name": "Beste pris: Lemping forsøk"
+            },
+            "best_price_gap_count_override": {
+                "name": "Beste pris: Gaptoleranse"
+            },
+            "peak_price_flex_override": {
+                "name": "Topppris: Fleksibilitet"
+            },
+            "peak_price_min_distance_override": {
+                "name": "Topppris: Minimumsavstand"
+            },
+            "peak_price_min_period_length_override": {
+                "name": "Topppris: Minimum periodelengde"
+            },
+            "peak_price_min_periods_override": {
+                "name": "Topppris: Minimum perioder"
+            },
+            "peak_price_relaxation_attempts_override": {
+                "name": "Topppris: Lemping forsøk"
+            },
+            "peak_price_gap_count_override": {
+                "name": "Topppris: Gaptoleranse"
+            }
+        },
+        "switch": {
+            "best_price_enable_relaxation_override": {
+                "name": "Beste pris: Oppnå minimumsantall"
+            },
+            "peak_price_enable_relaxation_override": {
+                "name": "Topppris: Oppnå minimumsantall"
+            }
         }
     },
     "issues": {
@@ -899,6 +1010,14 @@
                 "highlight_best_price": {
                     "name": "Fremhev beste prisperioder",
                     "description": "Legg til et halvgjennomsiktig grønt overlegg for å fremheve de beste prisperiodene i diagrammet. Dette gjør det enkelt å visuelt identifisere de optimale tidene for energiforbruk."
+                },
+                "highlight_peak_price": {
+                    "name": "Fremhev høyeste prisperioder",
+                    "description": "Legg til et halvgjennomsiktig rødt overlegg for å fremheve de høyeste prisperiodene i diagrammet. Dette gjør det enkelt å visuelt identifisere tidene når energi er dyrest."
+                },
+                "resolution": {
+                    "name": "Oppløsning",
+                    "description": "Tidsoppløsning for diagramdata. 'interval' (standard): Opprinnelige 15-minutters intervaller (96 punkter per dag). 'hourly': Aggregerte timeverdier med et rullende 60-minutters vindu (24 punkter per dag) for et ryddigere og mindre rotete diagram."
                 }
             }
         },

custom_components/tibber_prices/utils/__init__.py

@@ -17,24 +17,28 @@ For entity-specific utilities (icons, colors, attributes), see entity_utils/ pac
 from __future__ import annotations
 
 from .average import (
-    calculate_current_leading_avg,
     calculate_current_leading_max,
+    calculate_current_leading_mean,
     calculate_current_leading_min,
-    calculate_current_trailing_avg,
     calculate_current_trailing_max,
+    calculate_current_trailing_mean,
     calculate_current_trailing_min,
-    calculate_next_n_hours_avg,
+    calculate_mean,
+    calculate_median,
+    calculate_next_n_hours_mean,
 )
 from .price import (
     aggregate_period_levels,
     aggregate_period_ratings,
     aggregate_price_levels,
     aggregate_price_rating,
+    calculate_coefficient_of_variation,
     calculate_difference_percentage,
     calculate_price_trend,
     calculate_rating_level,
     calculate_trailing_average_for_interval,
     calculate_volatility_level,
+    calculate_volatility_with_cv,
     enrich_price_info_with_differences,
     find_price_data_for_interval,
 )
@@ -44,18 +48,22 @@ __all__ = [
     "aggregate_period_ratings",
     "aggregate_price_levels",
     "aggregate_price_rating",
-    "calculate_current_leading_avg",
+    "calculate_coefficient_of_variation",
     "calculate_current_leading_max",
+    "calculate_current_leading_mean",
     "calculate_current_leading_min",
-    "calculate_current_trailing_avg",
     "calculate_current_trailing_max",
+    "calculate_current_trailing_mean",
     "calculate_current_trailing_min",
     "calculate_difference_percentage",
-    "calculate_next_n_hours_avg",
+    "calculate_mean",
+    "calculate_median",
+    "calculate_next_n_hours_mean",
     "calculate_price_trend",
     "calculate_rating_level",
     "calculate_trailing_average_for_interval",
     "calculate_volatility_level",
+    "calculate_volatility_with_cv",
     "enrich_price_info_with_differences",
     "find_price_data_for_interval",
 ]

custom_components/tibber_prices/utils/average.py

@@ -35,17 +35,43 @@ def calculate_median(prices: list[float]) -> float | None:
     return sorted_prices[n // 2]
 
 
-def calculate_trailing_24h_avg(all_prices: list[dict], interval_start: datetime) -> tuple[float | None, float | None]:
+def calculate_mean(prices: list[float]) -> float:
     """
-    Calculate trailing 24-hour average and median price for a given interval.
+    Calculate arithmetic mean (average) from a list of prices.
+
+    Args:
+        prices: List of price values (must not be empty)
+
+    Returns:
+        Mean price
+
+    Raises:
+        ValueError: If prices list is empty
+
+    """
+    if not prices:
+        msg = "Cannot calculate mean of empty list"
+        raise ValueError(msg)
+
+    return sum(prices) / len(prices)
+
+
+def calculate_trailing_24h_mean(
+    all_prices: list[dict],
+    interval_start: datetime,
+    *,
+    time: TibberPricesTimeService,
+) -> tuple[float | None, float | None]:
+    """
+    Calculate trailing 24-hour mean and median price for a given interval.
 
     Args:
         all_prices: List of all price data (yesterday, today, tomorrow combined)
-        interval_start: Start time of the interval to calculate average for
+        interval_start: Start time of the interval to calculate mean for
         time: TibberPricesTimeService instance (required)
 
     Returns:
-        Tuple of (average price, median price) for the 24 hours preceding the interval,
+        Tuple of (mean price, median price) for the 24 hours preceding the interval,
         or (None, None) if no data in window
 
     """
@@ -56,34 +82,39 @@ def calculate_trailing_24h_avg(all_prices: list[dict], interval_start: datetime)
     # Filter prices within the 24-hour window
     prices_in_window = []
     for price_data in all_prices:
-        starts_at = price_data["startsAt"]  # Already datetime object in local timezone
+        starts_at = time.get_interval_time(price_data)
         if starts_at is None:
             continue
         # Include intervals that start within the window (not including the current interval's end)
         if window_start <= starts_at < window_end:
             prices_in_window.append(float(price_data["total"]))
 
-    # Calculate average and median
+    # Calculate mean and median
     # CRITICAL: Return None instead of 0.0 when no data available
-    # With negative prices, 0.0 could be misinterpreted as a real average value
+    # With negative prices, 0.0 could be misinterpreted as a real mean value
     if prices_in_window:
-        avg = sum(prices_in_window) / len(prices_in_window)
+        mean = calculate_mean(prices_in_window)
         median = calculate_median(prices_in_window)
-        return avg, median
+        return mean, median
     return None, None
 
 
-def calculate_leading_24h_avg(all_prices: list[dict], interval_start: datetime) -> tuple[float | None, float | None]:
+def calculate_leading_24h_mean(
+    all_prices: list[dict],
+    interval_start: datetime,
+    *,
+    time: TibberPricesTimeService,
+) -> tuple[float | None, float | None]:
     """
-    Calculate leading 24-hour average and median price for a given interval.
+    Calculate leading 24-hour mean and median price for a given interval.
 
     Args:
         all_prices: List of all price data (yesterday, today, tomorrow combined)
-        interval_start: Start time of the interval to calculate average for
+        interval_start: Start time of the interval to calculate mean for
         time: TibberPricesTimeService instance (required)
 
     Returns:
-        Tuple of (average price, median price) for up to 24 hours following the interval,
+        Tuple of (mean price, median price) for up to 24 hours following the interval,
         or (None, None) if no data in window
 
     """
@@ -94,77 +125,79 @@ def calculate_leading_24h_avg(all_prices: list[dict], interval_start: datetime)
     # Filter prices within the 24-hour window
     prices_in_window = []
     for price_data in all_prices:
-        starts_at = price_data["startsAt"]  # Already datetime object in local timezone
+        starts_at = time.get_interval_time(price_data)
         if starts_at is None:
             continue
         # Include intervals that start within the window
         if window_start <= starts_at < window_end:
             prices_in_window.append(float(price_data["total"]))
 
-    # Calculate average and median
+    # Calculate mean and median
     # CRITICAL: Return None instead of 0.0 when no data available
-    # With negative prices, 0.0 could be misinterpreted as a real average value
+    # With negative prices, 0.0 could be misinterpreted as a real mean value
     if prices_in_window:
-        avg = sum(prices_in_window) / len(prices_in_window)
+        mean = calculate_mean(prices_in_window)
         median = calculate_median(prices_in_window)
-        return avg, median
+        return mean, median
     return None, None
 
 
-def calculate_current_trailing_avg(
+def calculate_current_trailing_mean(
     coordinator_data: dict,
     *,
     time: TibberPricesTimeService,
-) -> float | None:
+) -> tuple[float | None, float | None]:
     """
-    Calculate the trailing 24-hour average for the current time.
+    Calculate the trailing 24-hour mean and median for the current time.
 
     Args:
         coordinator_data: The coordinator data containing priceInfo
         time: TibberPricesTimeService instance (required)
 
     Returns:
-        Current trailing 24-hour average price, or None if unavailable
+        Tuple of (mean price, median price), or (None, None) if unavailable
 
     """
     if not coordinator_data:
-        return None
+        return None, None
 
     # Get all intervals (yesterday, today, tomorrow) via helper
     all_prices = get_intervals_for_day_offsets(coordinator_data, [-1, 0, 1])
     if not all_prices:
-        return None
+        return None, None
 
     now = time.now()
-    return calculate_trailing_24h_min(all_prices, now, time=time)
+    # calculate_trailing_24h_mean returns (mean, median) tuple
+    return calculate_trailing_24h_mean(all_prices, now, time=time)
 
 
-def calculate_current_leading_avg(
+def calculate_current_leading_mean(
     coordinator_data: dict,
     *,
     time: TibberPricesTimeService,
-) -> float | None:
+) -> tuple[float | None, float | None]:
     """
-    Calculate the leading 24-hour average for the current time.
+    Calculate the leading 24-hour mean and median for the current time.
 
     Args:
         coordinator_data: The coordinator data containing priceInfo
         time: TibberPricesTimeService instance (required)
 
     Returns:
-        Current leading 24-hour average price, or None if unavailable
+        Tuple of (mean price, median price), or (None, None) if unavailable
 
     """
     if not coordinator_data:
-        return None
+        return None, None
 
     # Get all intervals (yesterday, today, tomorrow) via helper
     all_prices = get_intervals_for_day_offsets(coordinator_data, [-1, 0, 1])
     if not all_prices:
-        return None
+        return None, None
 
     now = time.now()
-    return calculate_leading_24h_min(all_prices, now, time=time)
+    # calculate_leading_24h_mean returns (mean, median) tuple
+    return calculate_leading_24h_mean(all_prices, now, time=time)
 
 
 def calculate_trailing_24h_min(
@@ -408,11 +441,7 @@ def calculate_current_leading_min(
         return None
 
     now = time.now()
-    # calculate_leading_24h_avg returns (avg, median) - we just need the avg
-    result = calculate_leading_24h_avg(all_prices, now)
-    if isinstance(result, tuple):
-        return result[0]  # Return avg only
-    return None
+    return calculate_leading_24h_min(all_prices, now, time=time)
 
 
 def calculate_current_leading_max(
@@ -443,16 +472,16 @@ def calculate_current_leading_max(
     return calculate_leading_24h_max(all_prices, now, time=time)
 
 
-def calculate_next_n_hours_avg(
+def calculate_next_n_hours_mean(
     coordinator_data: dict,
     hours: int,
     *,
     time: TibberPricesTimeService,
 ) -> tuple[float | None, float | None]:
     """
-    Calculate average and median price for the next N hours starting from the next interval.
+    Calculate mean and median price for the next N hours starting from the next interval.
 
-    This function computes the average and median of all 15-minute intervals starting from
+    This function computes the mean and median of all 15-minute intervals starting from
     the next interval (not current) up to N hours into the future.
 
     Args:
@@ -461,7 +490,7 @@ def calculate_next_n_hours_avg(
         time: TibberPricesTimeService instance (required)
 
     Returns:
-        Tuple of (average price, median price) for the next N hours,
+        Tuple of (mean price, median price) for the next N hours,
         or (None, None) if insufficient data
 
     """
@@ -506,7 +535,7 @@ def calculate_next_n_hours_avg(
     if not prices_in_window:
         return None, None
 
-    # Return average and median (prefer full period, but allow graceful degradation)
-    avg = sum(prices_in_window) / len(prices_in_window)
+    # Return mean and median (prefer full period, but allow graceful degradation)
+    mean = calculate_mean(prices_in_window)
     median = calculate_median(prices_in_window)
-    return avg, median
+    return mean, median

custom_components/tibber_prices/utils/price.py

@@ -11,12 +11,21 @@ if TYPE_CHECKING:
     from custom_components.tibber_prices.coordinator.time_service import TibberPricesTimeService
 
 from custom_components.tibber_prices.const import (
+    DEFAULT_PRICE_LEVEL_GAP_TOLERANCE,
+    DEFAULT_PRICE_RATING_GAP_TOLERANCE,
+    DEFAULT_PRICE_RATING_HYSTERESIS,
     DEFAULT_VOLATILITY_THRESHOLD_HIGH,
     DEFAULT_VOLATILITY_THRESHOLD_MODERATE,
     DEFAULT_VOLATILITY_THRESHOLD_VERY_HIGH,
     PRICE_LEVEL_MAPPING,
     PRICE_LEVEL_NORMAL,
     PRICE_RATING_NORMAL,
+    PRICE_TREND_FALLING,
+    PRICE_TREND_MAPPING,
+    PRICE_TREND_RISING,
+    PRICE_TREND_STABLE,
+    PRICE_TREND_STRONGLY_FALLING,
+    PRICE_TREND_STRONGLY_RISING,
     VOLATILITY_HIGH,
     VOLATILITY_LOW,
     VOLATILITY_MODERATE,
@@ -44,6 +53,91 @@ VOLATILITY_FACTOR_NORMAL = 1.0  # Moderate volatility → baseline
 VOLATILITY_FACTOR_INSENSITIVE = 1.4  # High volatility → noise filtering
 
 
+def calculate_coefficient_of_variation(prices: list[float]) -> float | None:
+    """
+    Calculate coefficient of variation (CV) from price list.
+
+    CV = (std_dev / mean) * 100, expressed as percentage.
+    This is a standardized measure of volatility that works across different
+    price levels and period lengths.
+
+    Used by:
+    - Volatility sensors (via calculate_volatility_with_cv)
+    - Outlier filtering (adaptive confidence level)
+    - Period statistics
+
+    Args:
+        prices: List of price values (in any unit)
+
+    Returns:
+        CV as percentage (e.g., 15.0 for 15%), or None if calculation not possible
+        (fewer than 2 prices or mean is zero)
+
+    Examples:
+        - CV ~5-10%: Very stable prices
+        - CV ~15-20%: Moderate variation
+        - CV ~30-50%: High volatility
+        - CV >50%: Extreme volatility
+
+    """
+    if len(prices) < MIN_PRICES_FOR_VOLATILITY:
+        return None
+
+    mean = statistics.mean(prices)
+    if mean == 0:
+        return None
+
+    std_dev = statistics.stdev(prices)
+    # Use abs(mean) for negative prices (Norway/Germany electricity markets)
+    return (std_dev / abs(mean)) * 100
+
+
+def calculate_volatility_with_cv(
+    prices: list[float],
+    threshold_moderate: float | None = None,
+    threshold_high: float | None = None,
+    threshold_very_high: float | None = None,
+) -> tuple[str, float | None]:
+    """
+    Calculate volatility level AND coefficient of variation from price list.
+
+    Returns both the level string (for sensor state) and the numeric CV value
+    (for sensor attributes), allowing users to see the exact volatility percentage.
+
+    Args:
+        prices: List of price values (in any unit)
+        threshold_moderate: Custom threshold for MODERATE level
+        threshold_high: Custom threshold for HIGH level
+        threshold_very_high: Custom threshold for VERY_HIGH level
+
+    Returns:
+        Tuple of (level, cv):
+        - level: "LOW", "MODERATE", "HIGH", or "VERY_HIGH" (uppercase)
+        - cv: Coefficient of variation as percentage (e.g., 15.0), or None if not calculable
+
+    """
+    cv = calculate_coefficient_of_variation(prices)
+    if cv is None:
+        return VOLATILITY_LOW, None
+
+    # Use provided thresholds or fall back to constants
+    t_moderate = threshold_moderate if threshold_moderate is not None else DEFAULT_VOLATILITY_THRESHOLD_MODERATE
+    t_high = threshold_high if threshold_high is not None else DEFAULT_VOLATILITY_THRESHOLD_HIGH
+    t_very_high = threshold_very_high if threshold_very_high is not None else DEFAULT_VOLATILITY_THRESHOLD_VERY_HIGH
+
+    # Classify based on thresholds
+    if cv < t_moderate:
+        level = VOLATILITY_LOW
+    elif cv < t_high:
+        level = VOLATILITY_MODERATE
+    elif cv < t_very_high:
+        level = VOLATILITY_HIGH
+    else:
+        level = VOLATILITY_VERY_HIGH
+
+    return level, cv
+
+
 def calculate_volatility_level(
     prices: list[float],
     threshold_moderate: float | None = None,
@@ -78,34 +172,8 @@ def calculate_volatility_level(
         Works identically for short periods (2-3 intervals) and long periods (96 intervals/day).
 
     """
-    # Need at least 2 values for standard deviation
-    if len(prices) < MIN_PRICES_FOR_VOLATILITY:
-        return VOLATILITY_LOW
-
-    # Use provided thresholds or fall back to constants
-    t_moderate = threshold_moderate if threshold_moderate is not None else DEFAULT_VOLATILITY_THRESHOLD_MODERATE
-    t_high = threshold_high if threshold_high is not None else DEFAULT_VOLATILITY_THRESHOLD_HIGH
-    t_very_high = threshold_very_high if threshold_very_high is not None else DEFAULT_VOLATILITY_THRESHOLD_VERY_HIGH
-
-    # Calculate coefficient of variation
-    # CRITICAL: Use absolute value of mean for negative prices (Norway/Germany)
-    # Negative electricity prices are valid and should have measurable volatility
-    mean = statistics.mean(prices)
-    if mean == 0:
-        # Division by zero case (all prices exactly zero)
-        return VOLATILITY_LOW
-
-    std_dev = statistics.stdev(prices)
-    coefficient_of_variation = (std_dev / abs(mean)) * 100  # As percentage, use abs(mean)
-
-    # Classify based on thresholds
-    if coefficient_of_variation < t_moderate:
-        return VOLATILITY_LOW
-    if coefficient_of_variation < t_high:
-        return VOLATILITY_MODERATE
-    if coefficient_of_variation < t_very_high:
-        return VOLATILITY_HIGH
-    return VOLATILITY_VERY_HIGH
+    level, _cv = calculate_volatility_with_cv(prices, threshold_moderate, threshold_high, threshold_very_high)
+    return level
 
 
 def calculate_trailing_average_for_interval(
@@ -186,27 +254,41 @@ def calculate_difference_percentage(
     return ((current_interval_price - trailing_average) / abs(trailing_average)) * 100
 
 
-def calculate_rating_level(
+def calculate_rating_level(  # noqa: PLR0911 - Multiple returns justified by clear hysteresis state machine
     difference: float | None,
     threshold_low: float,
     threshold_high: float,
+    *,
+    previous_rating: str | None = None,
+    hysteresis: float = 0.0,
 ) -> str | None:
     """
     Calculate the rating level based on difference percentage and thresholds.
 
     This mimics the API's "level" field from priceRating endpoint.
 
+    Supports hysteresis to prevent flickering at threshold boundaries. When a previous
+    rating is provided, the threshold for leaving that state is adjusted by the
+    hysteresis value, requiring a more significant change to switch states.
+
     Args:
         difference: The difference percentage (from calculate_difference_percentage)
         threshold_low: The low threshold percentage (typically -100 to 0)
         threshold_high: The high threshold percentage (typically 0 to 100)
+        previous_rating: The rating level of the previous interval (for hysteresis)
+        hysteresis: The hysteresis percentage (default 0.0 = no hysteresis)
 
     Returns:
-        "LOW" if difference <= threshold_low
-        "HIGH" if difference >= threshold_high
+        "LOW" if difference <= threshold_low (adjusted by hysteresis)
+        "HIGH" if difference >= threshold_high (adjusted by hysteresis)
         "NORMAL" otherwise
         None if difference is None
 
+    Example with hysteresis=2.0 and threshold_low=-10:
+        - To enter LOW from NORMAL: difference must be <= -10% (threshold_low)
+        - To leave LOW back to NORMAL: difference must be > -8% (threshold_low + hysteresis)
+        This creates a "dead zone" that prevents rapid switching at boundaries.
+
     """
     if difference is None:
         return None
@@ -222,7 +304,29 @@ def calculate_rating_level(
         )
         return PRICE_RATING_NORMAL
 
-    # Classify based on thresholds
+    # Apply hysteresis based on previous state
+    # The idea: make it "harder" to leave the current state than to enter it
+    if previous_rating == "LOW":
+        # Currently LOW: need to exceed threshold_low + hysteresis to leave
+        exit_threshold_low = threshold_low + hysteresis
+        if difference <= exit_threshold_low:
+            return "LOW"
+        # Check if we should go to HIGH (rare, but possible with large price swings)
+        if difference >= threshold_high:
+            return "HIGH"
+        return PRICE_RATING_NORMAL
+
+    if previous_rating == "HIGH":
+        # Currently HIGH: need to drop below threshold_high - hysteresis to leave
+        exit_threshold_high = threshold_high - hysteresis
+        if difference >= exit_threshold_high:
+            return "HIGH"
+        # Check if we should go to LOW (rare, but possible with large price swings)
+        if difference <= threshold_low:
+            return "LOW"
+        return PRICE_RATING_NORMAL
+
+    # No previous state or previous was NORMAL: use standard thresholds
     if difference <= threshold_low:
         return "LOW"
 
@@ -232,12 +336,15 @@ def calculate_rating_level(
     return PRICE_RATING_NORMAL
 
 
-def _process_price_interval(
+def _process_price_interval(  # noqa: PLR0913 - Extra params needed for hysteresis
     price_interval: dict[str, Any],
     all_prices: list[dict[str, Any]],
     threshold_low: float,
     threshold_high: float,
-) -> None:
+    *,
+    previous_rating: str | None = None,
+    hysteresis: float = 0.0,
+) -> str | None:
     """
     Process a single price interval and add difference and rating_level.
 
@@ -246,16 +353,20 @@ def _process_price_interval(
         all_prices: All available price intervals for lookback calculation
         threshold_low: Low threshold percentage
         threshold_high: High threshold percentage
-        day_label: Label for logging ("today" or "tomorrow")
+        previous_rating: The rating level of the previous interval (for hysteresis)
+        hysteresis: The hysteresis percentage to prevent flickering
+
+    Returns:
+        The calculated rating_level (for use as previous_rating in next call)
 
     """
     starts_at = price_interval.get("startsAt")  # Already datetime object in local timezone
     if not starts_at:
-        return
+        return previous_rating
     current_interval_price = price_interval.get("total")
 
     if current_interval_price is None:
-        return
+        return previous_rating
 
     # Calculate trailing average
     trailing_avg = calculate_trailing_average_for_interval(starts_at, all_prices)
@@ -265,20 +376,398 @@ def _process_price_interval(
         difference = calculate_difference_percentage(float(current_interval_price), trailing_avg)
         price_interval["difference"] = difference
 
-        # Calculate rating_level based on difference
-        rating_level = calculate_rating_level(difference, threshold_low, threshold_high)
+        # Calculate rating_level based on difference with hysteresis
+        rating_level = calculate_rating_level(
+            difference,
+            threshold_low,
+            threshold_high,
+            previous_rating=previous_rating,
+            hysteresis=hysteresis,
+        )
         price_interval["rating_level"] = rating_level
-    else:
+        return rating_level
+
     # Set to None if we couldn't calculate (expected for intervals in first 24h)
     price_interval["difference"] = None
     price_interval["rating_level"] = None
+    return None
 
 
-def enrich_price_info_with_differences(
+def _build_rating_blocks(
+    rated_intervals: list[tuple[int, dict[str, Any], str]],
+) -> list[tuple[int, int, str, int]]:
+    """
+    Build list of contiguous rating blocks from rated intervals.
+
+    Args:
+        rated_intervals: List of (original_idx, interval_dict, rating) tuples
+
+    Returns:
+        List of (start_idx, end_idx, rating, length) tuples where indices
+        refer to positions in rated_intervals
+
+    """
+    blocks: list[tuple[int, int, str, int]] = []
+    if not rated_intervals:
+        return blocks
+
+    block_start = 0
+    current_rating = rated_intervals[0][2]
+
+    for idx in range(1, len(rated_intervals)):
+        if rated_intervals[idx][2] != current_rating:
+            # End current block
+            blocks.append((block_start, idx - 1, current_rating, idx - block_start))
+            block_start = idx
+            current_rating = rated_intervals[idx][2]
+
+    # Don't forget the last block
+    blocks.append((block_start, len(rated_intervals) - 1, current_rating, len(rated_intervals) - block_start))
+    return blocks
+
+
+def _build_level_blocks(
+    level_intervals: list[tuple[int, dict[str, Any], str]],
+) -> list[tuple[int, int, str, int]]:
+    """
+    Build list of contiguous price level blocks from intervals.
+
+    Args:
+        level_intervals: List of (original_idx, interval_dict, level) tuples
+
+    Returns:
+        List of (start_idx, end_idx, level, length) tuples where indices
+        refer to positions in level_intervals
+
+    """
+    blocks: list[tuple[int, int, str, int]] = []
+    if not level_intervals:
+        return blocks
+
+    block_start = 0
+    current_level = level_intervals[0][2]
+
+    for idx in range(1, len(level_intervals)):
+        if level_intervals[idx][2] != current_level:
+            # End current block
+            blocks.append((block_start, idx - 1, current_level, idx - block_start))
+            block_start = idx
+            current_level = level_intervals[idx][2]
+
+    # Don't forget the last block
+    blocks.append((block_start, len(level_intervals) - 1, current_level, len(level_intervals) - block_start))
+    return blocks
+
+
+def _calculate_gravitational_pull(
+    blocks: list[tuple[int, int, str, int]],
+    block_idx: int,
+    direction: str,
+    gap_tolerance: int,
+) -> tuple[int, str]:
+    """
+    Calculate "gravitational pull" from neighboring blocks in one direction.
+
+    This finds the first LARGE block (> gap_tolerance) in the given direction
+    and returns its size and rating. Small intervening blocks are "looked through".
+
+    This approach ensures that small isolated blocks are always pulled toward
+    the dominant large block, even if there are other small blocks in between.
+
+    Args:
+        blocks: List of (start_idx, end_idx, rating, length) tuples
+        block_idx: Index of the current block being evaluated
+        direction: "left" or "right"
+        gap_tolerance: Maximum size of blocks considered "small"
+
+    Returns:
+        Tuple of (size, rating) of the first large block found,
+        or (immediate_neighbor_size, immediate_neighbor_rating) if no large block exists
+
+    """
+    probe_range = range(block_idx - 1, -1, -1) if direction == "left" else range(block_idx + 1, len(blocks))
+    total_small_accumulated = 0
+
+    for probe_idx in probe_range:
+        probe_rating = blocks[probe_idx][2]
+        probe_size = blocks[probe_idx][3]
+
+        if probe_size > gap_tolerance:
+            # Found a large block - return its characteristics
+            # Add any accumulated small blocks of the same rating
+            if total_small_accumulated > 0:
+                return (probe_size + total_small_accumulated, probe_rating)
+            return (probe_size, probe_rating)
+
+        # Small block - accumulate if same rating as what we've seen
+        total_small_accumulated += probe_size
+
+    # No large block found - return the immediate neighbor's info
+    neighbor_idx = block_idx - 1 if direction == "left" else block_idx + 1
+    return (blocks[neighbor_idx][3], blocks[neighbor_idx][2])
+
+
+def _apply_rating_gap_tolerance(
+    all_intervals: list[dict[str, Any]],
+    gap_tolerance: int,
+) -> None:
+    """
+    Apply gap tolerance to smooth out isolated rating level changes.
+
+    This is a post-processing step after hysteresis. It identifies short sequences
+    of intervals (≤ gap_tolerance) and merges them into the larger neighboring block.
+    The algorithm is bidirectional - it compares block sizes on both sides and
+    assigns the small block to whichever neighbor is larger.
+
+    This matches human intuition: a single "different" interval feels like it
+    should belong to the larger surrounding group.
+
+    Example with gap_tolerance=1:
+        LOW LOW LOW NORMAL LOW LOW → LOW LOW LOW LOW LOW LOW
+        (single NORMAL gets merged into larger LOW block)
+
+    Example with gap_tolerance=1 (bidirectional):
+        NORMAL NORMAL HIGH NORMAL HIGH HIGH HIGH → NORMAL NORMAL HIGH HIGH HIGH HIGH HIGH
+        (single NORMAL at position 4 gets merged into larger HIGH block on the right)
+
+    Args:
+        all_intervals: List of price intervals with rating_level already set (modified in-place)
+        gap_tolerance: Maximum number of consecutive "different" intervals to smooth out
+
+    Note:
+        - Compares block sizes on both sides and merges small blocks into larger neighbors
+        - If both neighbors have equal size, prefers the LEFT neighbor (earlier in time)
+        - Skips intervals without rating_level (None)
+        - Intervals must be sorted chronologically for this to work correctly
+        - Multiple passes may be needed as merging can create new small blocks
+
+    """
+    if gap_tolerance <= 0:
+        return
+
+    # Extract intervals with valid rating_level in chronological order
+    rated_intervals: list[tuple[int, dict[str, Any], str]] = [
+        (i, interval, interval["rating_level"])
+        for i, interval in enumerate(all_intervals)
+        if interval.get("rating_level") is not None
+    ]
+
+    if len(rated_intervals) < 3:  # noqa: PLR2004 - Minimum 3 for before/gap/after pattern
+        return
+
+    # Iteratively merge small blocks until no more changes
+    max_iterations = 10
+    total_corrections = 0
+
+    for iteration in range(max_iterations):
+        blocks = _build_rating_blocks(rated_intervals)
+        corrections_this_pass = _merge_small_blocks(blocks, rated_intervals, gap_tolerance)
+        total_corrections += corrections_this_pass
+
+        if corrections_this_pass == 0:
+            break
+
+        _LOGGER.debug(
+            "Gap tolerance pass %d: merged %d small blocks",
+            iteration + 1,
+            corrections_this_pass,
+        )
+
+    if total_corrections > 0:
+        _LOGGER.debug("Gap tolerance: total %d block merges across all passes", total_corrections)
+
+
+def _apply_level_gap_tolerance(
+    all_intervals: list[dict[str, Any]],
+    gap_tolerance: int,
+) -> None:
+    """
+    Apply gap tolerance to smooth out isolated price level changes.
+
+    Similar to rating gap tolerance, but operates on Tibber's "level" field
+    (VERY_CHEAP, CHEAP, NORMAL, EXPENSIVE, VERY_EXPENSIVE). Identifies short
+    sequences of intervals (≤ gap_tolerance) and merges them into the larger
+    neighboring block.
+
+    Example with gap_tolerance=1:
+        CHEAP CHEAP CHEAP NORMAL CHEAP CHEAP → CHEAP CHEAP CHEAP CHEAP CHEAP CHEAP
+        (single NORMAL gets merged into larger CHEAP block)
+
+    Example with gap_tolerance=1 (bidirectional):
+        NORMAL NORMAL EXPENSIVE NORMAL EXPENSIVE EXPENSIVE EXPENSIVE →
+        NORMAL NORMAL EXPENSIVE EXPENSIVE EXPENSIVE EXPENSIVE EXPENSIVE
+        (single NORMAL at position 4 gets merged into larger EXPENSIVE block on the right)
+
+    Args:
+        all_intervals: List of price intervals with level already set (modified in-place)
+        gap_tolerance: Maximum number of consecutive "different" intervals to smooth out
+
+    Note:
+        - Uses same bidirectional algorithm as rating gap tolerance
+        - Compares block sizes on both sides and merges small blocks into larger neighbors
+        - If both neighbors have equal size, prefers the LEFT neighbor (earlier in time)
+        - Skips intervals without level (None)
+        - Intervals must be sorted chronologically for this to work correctly
+        - Multiple passes may be needed as merging can create new small blocks
+
+    """
+    if gap_tolerance <= 0:
+        return
+
+    # Extract intervals with valid level in chronological order
+    level_intervals: list[tuple[int, dict[str, Any], str]] = [
+        (i, interval, interval["level"])
+        for i, interval in enumerate(all_intervals)
+        if interval.get("level") is not None
+    ]
+
+    if len(level_intervals) < 3:  # noqa: PLR2004 - Minimum 3 for before/gap/after pattern
+        return
+
+    # Iteratively merge small blocks until no more changes
+    max_iterations = 10
+    total_corrections = 0
+
+    for iteration in range(max_iterations):
+        blocks = _build_level_blocks(level_intervals)
+        corrections_this_pass = _merge_small_level_blocks(blocks, level_intervals, gap_tolerance)
+        total_corrections += corrections_this_pass
+
+        if corrections_this_pass == 0:
+            break
+
+        _LOGGER.debug(
+            "Level gap tolerance pass %d: merged %d small blocks",
+            iteration + 1,
+            corrections_this_pass,
+        )
+
+    if total_corrections > 0:
+        _LOGGER.debug("Level gap tolerance: total %d block merges across all passes", total_corrections)
+
+
+def _merge_small_blocks(
+    blocks: list[tuple[int, int, str, int]],
+    rated_intervals: list[tuple[int, dict[str, Any], str]],
+    gap_tolerance: int,
+) -> int:
+    """
+    Merge small blocks into their larger neighbors.
+
+    CRITICAL: This function collects ALL merge decisions FIRST, then applies them.
+    This prevents the order of processing from affecting outcomes. Without this,
+    earlier blocks could be merged incorrectly because the gravitational pull
+    calculation would see already-modified neighbors instead of the original state.
+
+    The merge decision is based on the FIRST LARGE BLOCK in each direction,
+    looking through any small intervening blocks. This ensures consistent
+    behavior when multiple small blocks are adjacent.
+
+    Args:
+        blocks: List of (start_idx, end_idx, rating, length) tuples
+        rated_intervals: List of (original_idx, interval_dict, rating) tuples (modified in-place)
+        gap_tolerance: Maximum size of blocks to merge
+
+    Returns:
+        Number of blocks merged in this pass
+
+    """
+    # Phase 1: Collect all merge decisions based on ORIGINAL block state
+    merge_decisions: list[tuple[int, int, str]] = []  # (start_ri_idx, end_ri_idx, target_rating)
+
+    for block_idx, (start, end, rating, length) in enumerate(blocks):
+        if length > gap_tolerance:
+            continue
+
+        # Must have neighbors on BOTH sides (not an edge block)
+        if block_idx == 0 or block_idx == len(blocks) - 1:
+            continue
+
+        # Calculate gravitational pull from each direction
+        left_pull, left_rating = _calculate_gravitational_pull(blocks, block_idx, "left", gap_tolerance)
+        right_pull, right_rating = _calculate_gravitational_pull(blocks, block_idx, "right", gap_tolerance)
+
+        # Determine target rating (prefer left if equal)
+        target_rating = left_rating if left_pull >= right_pull else right_rating
+
+        if rating != target_rating:
+            merge_decisions.append((start, end, target_rating))
+
+    # Phase 2: Apply all merge decisions
+    for start, end, target_rating in merge_decisions:
+        for ri_idx in range(start, end + 1):
+            original_idx, interval, _old_rating = rated_intervals[ri_idx]
+            interval["rating_level"] = target_rating
+            rated_intervals[ri_idx] = (original_idx, interval, target_rating)
+
+    return len(merge_decisions)
+
+
+def _merge_small_level_blocks(
+    blocks: list[tuple[int, int, str, int]],
+    level_intervals: list[tuple[int, dict[str, Any], str]],
+    gap_tolerance: int,
+) -> int:
+    """
+    Merge small price level blocks into their larger neighbors.
+
+    CRITICAL: This function collects ALL merge decisions FIRST, then applies them.
+    This prevents the order of processing from affecting outcomes. Without this,
+    earlier blocks could be merged incorrectly because the gravitational pull
+    calculation would see already-modified neighbors instead of the original state.
+
+    The merge decision is based on the FIRST LARGE BLOCK in each direction,
+    looking through any small intervening blocks. This ensures consistent
+    behavior when multiple small blocks are adjacent.
+
+    Args:
+        blocks: List of (start_idx, end_idx, level, length) tuples
+        level_intervals: List of (original_idx, interval_dict, level) tuples (modified in-place)
+        gap_tolerance: Maximum size of blocks to merge
+
+    Returns:
+        Number of blocks merged in this pass
+
+    """
+    # Phase 1: Collect all merge decisions based on ORIGINAL block state
+    merge_decisions: list[tuple[int, int, str]] = []  # (start_li_idx, end_li_idx, target_level)
+
+    for block_idx, (start, end, level, length) in enumerate(blocks):
+        if length > gap_tolerance:
+            continue
+
+        # Must have neighbors on BOTH sides (not an edge block)
+        if block_idx == 0 or block_idx == len(blocks) - 1:
+            continue
+
+        # Calculate gravitational pull from each direction
+        left_pull, left_level = _calculate_gravitational_pull(blocks, block_idx, "left", gap_tolerance)
+        right_pull, right_level = _calculate_gravitational_pull(blocks, block_idx, "right", gap_tolerance)
+
+        # Determine target level (prefer left if equal)
+        target_level = left_level if left_pull >= right_pull else right_level
+
+        if level != target_level:
+            merge_decisions.append((start, end, target_level))
+
+    # Phase 2: Apply all merge decisions
+    for start, end, target_level in merge_decisions:
+        for li_idx in range(start, end + 1):
+            original_idx, interval, _old_level = level_intervals[li_idx]
+            interval["level"] = target_level
+            level_intervals[li_idx] = (original_idx, interval, target_level)
+
+    return len(merge_decisions)
+
+
+def enrich_price_info_with_differences(  # noqa: PLR0913 - Extra params for rating stabilization
     all_intervals: list[dict[str, Any]],
     *,
     threshold_low: float | None = None,
     threshold_high: float | None = None,
+    hysteresis: float | None = None,
+    gap_tolerance: int | None = None,
+    level_gap_tolerance: int | None = None,
     time: TibberPricesTimeService | None = None,  # noqa: ARG001  # Used in production (via coordinator), kept for compatibility
 ) -> list[dict[str, Any]]:
     """
@@ -287,15 +776,34 @@ def enrich_price_info_with_differences(
     Computes the trailing 24-hour average, difference percentage, and rating level
     for intervals that have sufficient lookback data (in-place modification).
 
+    Uses hysteresis to prevent flickering at threshold boundaries. When an interval's
+    difference is near a threshold, hysteresis ensures that the rating only changes
+    when there's a significant movement, not just minor fluctuations.
+
+    After hysteresis, applies gap tolerance as post-processing to smooth out any
+    remaining isolated rating changes (e.g., a single NORMAL interval surrounded
+    by LOW intervals gets corrected to LOW).
+
+    Similarly, applies level gap tolerance to smooth out isolated price level changes
+    from Tibber's API (e.g., a single NORMAL interval surrounded by CHEAP intervals
+    gets corrected to CHEAP).
+
     CRITICAL: Only enriches intervals that have at least 24 hours of prior data
     available. This is determined by checking if (interval_start - earliest_interval_start) >= 24h.
     Works independently of interval density (24 vs 96 intervals/day) and handles
     transition periods (e.g., Oct 1, 2025) correctly.
 
+    CRITICAL: Intervals are processed in chronological order to properly apply
+    hysteresis. The rating_level of each interval depends on the previous interval's
+    rating to prevent rapid switching at threshold boundaries.
+
     Args:
         all_intervals: Flat list of all price intervals (day_before_yesterday + yesterday + today + tomorrow).
         threshold_low: Low threshold percentage for rating_level (defaults to -10)
         threshold_high: High threshold percentage for rating_level (defaults to 10)
+        hysteresis: Hysteresis percentage to prevent flickering (defaults to 2.0)
+        gap_tolerance: Max consecutive intervals to smooth out for rating_level (defaults to 1, 0 = disabled)
+        level_gap_tolerance: Max consecutive intervals to smooth out for price level (defaults to 1, 0 = disabled)
         time: TibberPricesTimeService instance (kept for API compatibility, not used)
 
     Returns:
@@ -311,6 +819,9 @@ def enrich_price_info_with_differences(
     """
     threshold_low = threshold_low if threshold_low is not None else -10
     threshold_high = threshold_high if threshold_high is not None else 10
+    hysteresis = hysteresis if hysteresis is not None else DEFAULT_PRICE_RATING_HYSTERESIS
+    gap_tolerance = gap_tolerance if gap_tolerance is not None else DEFAULT_PRICE_RATING_GAP_TOLERANCE
+    level_gap_tolerance = level_gap_tolerance if level_gap_tolerance is not None else DEFAULT_PRICE_LEVEL_GAP_TOLERANCE
 
     if not all_intervals:
         return all_intervals
@@ -330,25 +841,47 @@ def enrich_price_info_with_differences(
     # Only intervals starting at or after this boundary have full 24h lookback
     enrichment_boundary = earliest_start + timedelta(hours=24)
 
-    # Process intervals (modifies in-place)
+    # CRITICAL: Sort intervals by time for proper hysteresis application
+    # We need to process intervals in chronological order so each interval
+    # can use the previous interval's rating_level for hysteresis
+    intervals_with_time: list[tuple[dict[str, Any], datetime]] = [
+        (interval, starts_at) for interval in all_intervals if (starts_at := interval.get("startsAt")) is not None
+    ]
+    intervals_with_time.sort(key=lambda x: x[1])
+
+    # Process intervals in chronological order (modifies in-place)
     # CRITICAL: Only enrich intervals that start >= 24h after earliest data
     enriched_count = 0
     skipped_count = 0
+    previous_rating: str | None = None
 
-    for price_interval in all_intervals:
-        starts_at = price_interval.get("startsAt")
-        if not starts_at:
-            skipped_count += 1
-            continue
-
+    for price_interval, starts_at in intervals_with_time:
         # Skip if interval doesn't have full 24h lookback
         if starts_at < enrichment_boundary:
             skipped_count += 1
             continue
 
-        _process_price_interval(price_interval, all_intervals, threshold_low, threshold_high)
+        # Process interval and get its rating for use as previous_rating in next iteration
+        previous_rating = _process_price_interval(
+            price_interval,
+            all_intervals,
+            threshold_low,
+            threshold_high,
+            previous_rating=previous_rating,
+            hysteresis=hysteresis,
+        )
         enriched_count += 1
 
+    # Apply gap tolerance as post-processing step
+    # This smooths out isolated rating changes that slip through hysteresis
+    if gap_tolerance > 0:
+        _apply_rating_gap_tolerance(all_intervals, gap_tolerance)
+
+    # Apply level gap tolerance as post-processing step
+    # This smooths out isolated price level changes from Tibber's API
+    if level_gap_tolerance > 0:
+        _apply_level_gap_tolerance(all_intervals, level_gap_tolerance)
+
     return all_intervals
 
 
@@ -603,15 +1136,27 @@ def calculate_price_trend(  # noqa: PLR0913 - All parameters are necessary for v
     threshold_rising: float = 3.0,
     threshold_falling: float = -3.0,
     *,
+    threshold_strongly_rising: float = 6.0,
+    threshold_strongly_falling: float = -6.0,
     volatility_adjustment: bool = True,
     lookahead_intervals: int | None = None,
     all_intervals: list[dict[str, Any]] | None = None,
     volatility_threshold_moderate: float = DEFAULT_VOLATILITY_THRESHOLD_MODERATE,
     volatility_threshold_high: float = DEFAULT_VOLATILITY_THRESHOLD_HIGH,
-) -> tuple[str, float]:
+) -> tuple[str, float, int]:
     """
     Calculate price trend by comparing current price with future average.
 
+    Uses a 5-level trend scale with integer values for automation comparisons:
+    - strongly_falling (-2): difference <= strongly_falling_threshold
+    - falling (-1): difference <= falling_threshold
+    - stable (0): difference between thresholds
+    - rising (+1): difference >= rising_threshold
+    - strongly_rising (+2): difference >= strongly_rising_threshold
+
+    The strong thresholds are independently configurable (not derived from base
+    thresholds), allowing fine-grained control over trend sensitivity.
+
     Supports volatility-adaptive thresholds: when enabled, the effective threshold
     is adjusted based on price volatility in the lookahead period. This makes the
     trend detection more sensitive during stable periods and less noisy during
@@ -625,6 +1170,8 @@ def calculate_price_trend(  # noqa: PLR0913 - All parameters are necessary for v
         future_average: Average price of future intervals
         threshold_rising: Base threshold for rising trend (%, positive, default 3%)
         threshold_falling: Base threshold for falling trend (%, negative, default -3%)
+        threshold_strongly_rising: Threshold for strongly rising (%, positive, default 6%)
+        threshold_strongly_falling: Threshold for strongly falling (%, negative, default -6%)
         volatility_adjustment: Enable volatility-adaptive thresholds (default True)
         lookahead_intervals: Number of intervals in trend period for volatility calc
         all_intervals: Price intervals (today + tomorrow) for volatility calculation
@@ -632,9 +1179,10 @@ def calculate_price_trend(  # noqa: PLR0913 - All parameters are necessary for v
         volatility_threshold_high: User-configured high volatility threshold (%)
 
     Returns:
-        Tuple of (trend_state, difference_percentage)
-        trend_state: "rising" | "falling" | "stable"
+        Tuple of (trend_state, difference_percentage, trend_value)
+        trend_state: PRICE_TREND_* constant (e.g., "strongly_rising")
         difference_percentage: % change from current to future ((future - current) / current * 100)
+        trend_value: Integer value from -2 to +2 for automation comparisons
 
     Note:
         Volatility adjustment factor:
@@ -645,12 +1193,13 @@ def calculate_price_trend(  # noqa: PLR0913 - All parameters are necessary for v
     """
     if current_interval_price == 0:
         # Avoid division by zero - return stable trend
-        return "stable", 0.0
+        return PRICE_TREND_STABLE, 0.0, PRICE_TREND_MAPPING[PRICE_TREND_STABLE]
 
     # Apply volatility adjustment if enabled and data available
     effective_rising = threshold_rising
     effective_falling = threshold_falling
-    volatility_factor = 1.0
+    effective_strongly_rising = threshold_strongly_rising
+    effective_strongly_falling = threshold_strongly_falling
 
     if volatility_adjustment and lookahead_intervals and all_intervals:
         volatility_factor = _calculate_lookahead_volatility_factor(
@@ -658,22 +1207,25 @@ def calculate_price_trend(  # noqa: PLR0913 - All parameters are necessary for v
         )
         effective_rising = threshold_rising * volatility_factor
         effective_falling = threshold_falling * volatility_factor
+        effective_strongly_rising = threshold_strongly_rising * volatility_factor
+        effective_strongly_falling = threshold_strongly_falling * volatility_factor
 
     # Calculate percentage difference from current to future
     # CRITICAL: Use abs() for negative prices to get correct percentage direction
     # Example: current=-10, future=-5 → diff=5, pct=5/abs(-10)*100=+50% (correctly shows rising)
-    if current_interval_price == 0:
-        # Edge case: avoid division by zero
-        diff_pct = 0.0
-    else:
     diff_pct = ((future_average - current_interval_price) / abs(current_interval_price)) * 100
 
-    # Determine trend based on effective thresholds
-    if diff_pct >= effective_rising:
-        trend = "rising"
+    # Determine trend based on effective thresholds (5-level scale)
+    # Check "strongly" conditions first (more extreme), then regular conditions
+    if diff_pct >= effective_strongly_rising:
+        trend = PRICE_TREND_STRONGLY_RISING
+    elif diff_pct >= effective_rising:
+        trend = PRICE_TREND_RISING
+    elif diff_pct <= effective_strongly_falling:
+        trend = PRICE_TREND_STRONGLY_FALLING
     elif diff_pct <= effective_falling:
-        trend = "falling"
+        trend = PRICE_TREND_FALLING
     else:
-        trend = "stable"
+        trend = PRICE_TREND_STABLE
 
-    return trend, diff_pct
+    return trend, diff_pct, PRICE_TREND_MAPPING[trend]

docs/developer/docs/architecture.md

@@ -6,7 +6,7 @@ comments: false
 
 This document provides a visual overview of the integration's architecture, focusing on end-to-end data flow and caching layers.
 
-For detailed implementation patterns, see [`AGENTS.md`](https://github.com/jpawlowski/hass.tibber_prices/blob/v0.20.0/AGENTS.md).
+For detailed implementation patterns, see [`AGENTS.md`](https://github.com/jpawlowski/hass.tibber_prices/blob/main/AGENTS.md).
 
 ---
 
@@ -355,4 +355,4 @@ Sensors organized by **calculation method** (refactored Nov 2025):
 - **[Setup Guide](./setup.md)** - Development environment setup
 - **[Testing Guide](./testing.md)** - How to test changes
 - **[Release Management](./release-management.md)** - Release workflow and versioning
-- **[AGENTS.md](https://github.com/jpawlowski/hass.tibber_prices/blob/v0.20.0/AGENTS.md)** - Complete reference for AI development
+- **[AGENTS.md](https://github.com/jpawlowski/hass.tibber_prices/blob/main/AGENTS.md)** - Complete reference for AI development

docs/developer/docs/caching-strategy.md

@@ -444,4 +444,4 @@ Options Update
 
 - **[Timer Architecture](./timer-architecture.md)** - Timer system, scheduling, midnight coordination
 - **[Architecture](./architecture.md)** - Overall system design, data flow
-- **[AGENTS.md](https://github.com/jpawlowski/hass.tibber_prices/blob/v0.20.0/AGENTS.md)** - Complete reference for AI development
+- **[AGENTS.md](https://github.com/jpawlowski/hass.tibber_prices/blob/main/AGENTS.md)** - Complete reference for AI development

docs/developer/docs/coding-guidelines.md

@@ -4,7 +4,7 @@ comments: false
 
 # Coding Guidelines
 
-> **Note:** For complete coding standards, see [`AGENTS.md`](https://github.com/jpawlowski/hass.tibber_prices/blob/v0.20.0/AGENTS.md).
+> **Note:** For complete coding standards, see [`AGENTS.md`](https://github.com/jpawlowski/hass.tibber_prices/blob/main/AGENTS.md).
 
 ## Code Style
 
@@ -75,7 +75,7 @@ Many existing classes lack the `TibberPrices` prefix. Before refactoring:
 2. Use `multi_replace_string_in_file` for bulk renames
 3. Test thoroughly after each module
 
-See [`AGENTS.md`](https://github.com/jpawlowski/hass.tibber_prices/blob/v0.20.0/AGENTS.md) for complete list of classes needing rename.
+See [`AGENTS.md`](https://github.com/jpawlowski/hass.tibber_prices/blob/main/AGENTS.md) for complete list of classes needing rename.
 
 ## Import Order
 
@@ -118,4 +118,4 @@ enriched = enrich_price_info_with_differences(
 )
 ```
 
-See [`AGENTS.md`](https://github.com/jpawlowski/hass.tibber_prices/blob/v0.20.0/AGENTS.md) for complete guidelines.
+See [`AGENTS.md`](https://github.com/jpawlowski/hass.tibber_prices/blob/main/AGENTS.md) for complete guidelines.

docs/developer/docs/intro.md

@@ -20,7 +20,7 @@ This is an independent, community-maintained custom integration for Home Assista
 
 ## 🤖 AI Documentation
 
-The main AI/Copilot documentation is in [`AGENTS.md`](https://github.com/jpawlowski/hass.tibber_prices/blob/v0.20.0/AGENTS.md). This file serves as long-term memory for AI assistants and contains:
+The main AI/Copilot documentation is in [`AGENTS.md`](https://github.com/jpawlowski/hass.tibber_prices/blob/main/AGENTS.md). This file serves as long-term memory for AI assistants and contains:
 
 -   Detailed architectural patterns
 -   Code quality rules and conventions
@@ -28,7 +28,7 @@ The main AI/Copilot documentation is in [`AGENTS.md`](https://github.com/jpawlow
 -   Common pitfalls and anti-patterns
 -   Project-specific patterns and utilities
 
-**Important:** When proposing changes to patterns or conventions, always update [`AGENTS.md`](https://github.com/jpawlowski/hass.tibber_prices/blob/v0.20.0/AGENTS.md) to keep AI guidance consistent.
+**Important:** When proposing changes to patterns or conventions, always update [`AGENTS.md`](https://github.com/jpawlowski/hass.tibber_prices/blob/main/AGENTS.md) to keep AI guidance consistent.
 
 ### AI-Assisted Development
 
@@ -61,7 +61,7 @@ This integration is developed with extensive AI assistance (GitHub Copilot, Clau
 -   Translation quality depends on AI's understanding of target language
 -   User feedback is crucial for discovering real-world issues
 
-If you're working with AI tools on this project, the [`AGENTS.md`](https://github.com/jpawlowski/hass.tibber_prices/blob/v0.20.0/AGENTS.md) file provides the context and patterns that ensure consistency.
+If you're working with AI tools on this project, the [`AGENTS.md`](https://github.com/jpawlowski/hass.tibber_prices/blob/main/AGENTS.md) file provides the context and patterns that ensure consistency.
 
 ## 🚀 Quick Start for Contributors
 

docs/developer/docs/refactoring-guide.md

@@ -302,7 +302,7 @@ This project uses AI heavily (GitHub Copilot, Claude). The planning process supp
 -   `docs/development/`: Practical, focused, human-optimized
 -   Both stay in sync but serve different audiences
 
-See [AGENTS.md](https://github.com/jpawlowski/hass.tibber_prices/blob/v0.20.0/AGENTS.md) section "Planning Major Refactorings" for AI-specific guidance.
+See [AGENTS.md](https://github.com/jpawlowski/hass.tibber_prices/blob/main/AGENTS.md) section "Planning Major Refactorings" for AI-specific guidance.
 
 ## Tools and Resources
 

docs/developer/docs/setup.md

@@ -1,6 +1,6 @@
 # Development Setup
 
-> **Note:** This guide is under construction. For now, please refer to [`AGENTS.md`](https://github.com/jpawlowski/hass.tibber_prices/blob/v0.20.0/AGENTS.md) for detailed setup information.
+> **Note:** This guide is under construction. For now, please refer to [`AGENTS.md`](https://github.com/jpawlowski/hass.tibber_prices/blob/main/AGENTS.md) for detailed setup information.
 
 ## Prerequisites
 
@@ -54,4 +54,4 @@ Visit http://localhost:8123
 ./scripts/release/hassfest
 ```
 
-See [`AGENTS.md`](https://github.com/jpawlowski/hass.tibber_prices/blob/v0.20.0/AGENTS.md) for detailed patterns and conventions.
+See [`AGENTS.md`](https://github.com/jpawlowski/hass.tibber_prices/blob/main/AGENTS.md) for detailed patterns and conventions.

docs/developer/docs/timer-architecture.md

@@ -410,7 +410,7 @@ _LOGGER.setLevel(logging.DEBUG)
 
 - **[Architecture](./architecture.md)** - Overall system design, data flow
 - **[Caching Strategy](./caching-strategy.md)** - Cache lifetimes, invalidation, midnight turnover
-- **[AGENTS.md](https://github.com/jpawlowski/hass.tibber_prices/blob/v0.20.0/AGENTS.md)** - Complete reference for AI development
+- **[AGENTS.md](https://github.com/jpawlowski/hass.tibber_prices/blob/main/AGENTS.md)** - Complete reference for AI development
 
 ---
 

docs/developer/versioned_docs/version-v0.21.0/architecture.md

@@ -6,7 +6,7 @@ comments: false
 
 This document provides a visual overview of the integration's architecture, focusing on end-to-end data flow and caching layers.
 
-For detailed implementation patterns, see [`AGENTS.md`](https://github.com/jpawlowski/hass.tibber_prices/blob/v0.20.0/AGENTS.md).
+For detailed implementation patterns, see [`AGENTS.md`](https://github.com/jpawlowski/hass.tibber_prices/blob/main/AGENTS.md).
 
 ---
 
@@ -355,4 +355,4 @@ Sensors organized by **calculation method** (refactored Nov 2025):
 - **[Setup Guide](./setup.md)** - Development environment setup
 - **[Testing Guide](./testing.md)** - How to test changes
 - **[Release Management](./release-management.md)** - Release workflow and versioning
-- **[AGENTS.md](https://github.com/jpawlowski/hass.tibber_prices/blob/v0.20.0/AGENTS.md)** - Complete reference for AI development
+- **[AGENTS.md](https://github.com/jpawlowski/hass.tibber_prices/blob/main/AGENTS.md)** - Complete reference for AI development

docs/developer/versioned_docs/version-v0.21.0/caching-strategy.md

@@ -444,4 +444,4 @@ Options Update
 
 - **[Timer Architecture](./timer-architecture.md)** - Timer system, scheduling, midnight coordination
 - **[Architecture](./architecture.md)** - Overall system design, data flow
-- **[AGENTS.md](https://github.com/jpawlowski/hass.tibber_prices/blob/v0.20.0/AGENTS.md)** - Complete reference for AI development
+- **[AGENTS.md](https://github.com/jpawlowski/hass.tibber_prices/blob/main/AGENTS.md)** - Complete reference for AI development

docs/developer/versioned_docs/version-v0.21.0/coding-guidelines.md

@@ -4,7 +4,7 @@ comments: false
 
 # Coding Guidelines
 
-> **Note:** For complete coding standards, see [`AGENTS.md`](https://github.com/jpawlowski/hass.tibber_prices/blob/v0.20.0/AGENTS.md).
+> **Note:** For complete coding standards, see [`AGENTS.md`](https://github.com/jpawlowski/hass.tibber_prices/blob/main/AGENTS.md).
 
 ## Code Style
 
@@ -75,7 +75,7 @@ Many existing classes lack the `TibberPrices` prefix. Before refactoring:
 2. Use `multi_replace_string_in_file` for bulk renames
 3. Test thoroughly after each module
 
-See [`AGENTS.md`](https://github.com/jpawlowski/hass.tibber_prices/blob/v0.20.0/AGENTS.md) for complete list of classes needing rename.
+See [`AGENTS.md`](https://github.com/jpawlowski/hass.tibber_prices/blob/main/AGENTS.md) for complete list of classes needing rename.
 
 ## Import Order
 
@@ -118,4 +118,4 @@ enriched = enrich_price_info_with_differences(
 )
 ```
 
-See [`AGENTS.md`](https://github.com/jpawlowski/hass.tibber_prices/blob/v0.20.0/AGENTS.md) for complete guidelines.
+See [`AGENTS.md`](https://github.com/jpawlowski/hass.tibber_prices/blob/main/AGENTS.md) for complete guidelines.

docs/developer/versioned_docs/version-v0.21.0/intro.md

@@ -20,7 +20,7 @@ This is an independent, community-maintained custom integration for Home Assista
 
 ## 🤖 AI Documentation
 
-The main AI/Copilot documentation is in [`AGENTS.md`](https://github.com/jpawlowski/hass.tibber_prices/blob/v0.20.0/AGENTS.md). This file serves as long-term memory for AI assistants and contains:
+The main AI/Copilot documentation is in [`AGENTS.md`](https://github.com/jpawlowski/hass.tibber_prices/blob/main/AGENTS.md). This file serves as long-term memory for AI assistants and contains:
 
 -   Detailed architectural patterns
 -   Code quality rules and conventions
@@ -28,7 +28,7 @@ The main AI/Copilot documentation is in [`AGENTS.md`](https://github.com/jpawlow
 -   Common pitfalls and anti-patterns
 -   Project-specific patterns and utilities
 
-**Important:** When proposing changes to patterns or conventions, always update [`AGENTS.md`](https://github.com/jpawlowski/hass.tibber_prices/blob/v0.20.0/AGENTS.md) to keep AI guidance consistent.
+**Important:** When proposing changes to patterns or conventions, always update [`AGENTS.md`](https://github.com/jpawlowski/hass.tibber_prices/blob/main/AGENTS.md) to keep AI guidance consistent.
 
 ### AI-Assisted Development
 
@@ -61,7 +61,7 @@ This integration is developed with extensive AI assistance (GitHub Copilot, Clau
 -   Translation quality depends on AI's understanding of target language
 -   User feedback is crucial for discovering real-world issues
 
-If you're working with AI tools on this project, the [`AGENTS.md`](https://github.com/jpawlowski/hass.tibber_prices/blob/v0.20.0/AGENTS.md) file provides the context and patterns that ensure consistency.
+If you're working with AI tools on this project, the [`AGENTS.md`](https://github.com/jpawlowski/hass.tibber_prices/blob/main/AGENTS.md) file provides the context and patterns that ensure consistency.
 
 ## 🚀 Quick Start for Contributors
 
@@ -174,11 +174,11 @@ Documentation is organized in two Docusaurus sites:
 
 ## 🤝 Contributing
 
-See [CONTRIBUTING.md](https://github.com/jpawlowski/hass.tibber_prices/blob/v0.21.0/CONTRIBUTING.md) for detailed contribution guidelines, code of conduct, and pull request process.
+See [CONTRIBUTING.md](https://github.com/jpawlowski/hass.tibber_prices/blob/main/CONTRIBUTING.md) for detailed contribution guidelines, code of conduct, and pull request process.
 
 ## 📄 License
 
-This project is licensed under the [MIT License](https://github.com/jpawlowski/hass.tibber_prices/blob/v0.21.0/LICENSE).
+This project is licensed under the [MIT License](https://github.com/jpawlowski/hass.tibber_prices/blob/main/LICENSE).
 
 ---
 

docs/developer/versioned_docs/version-v0.21.0/period-calculation-theory.md

@@ -1106,7 +1106,7 @@ Low volatility (< 15%) means classification changes are less economically signif
 - [User Documentation: Period Calculation](https://jpawlowski.github.io/hass.tibber_prices/user/period-calculation)
 - [Architecture Overview](./architecture.md)
 - [Caching Strategy](./caching-strategy.md)
-- [AGENTS.md](https://github.com/jpawlowski/hass.tibber_prices/blob/v0.21.0/AGENTS.md) - AI assistant memory (implementation patterns)
+- [AGENTS.md](https://github.com/jpawlowski/hass.tibber_prices/blob/main/AGENTS.md) - AI assistant memory (implementation patterns)
 
 ## Changelog
 

docs/developer/versioned_docs/version-v0.21.0/refactoring-guide.md

@@ -302,7 +302,7 @@ This project uses AI heavily (GitHub Copilot, Claude). The planning process supp
 -   `docs/development/`: Practical, focused, human-optimized
 -   Both stay in sync but serve different audiences
 
-See [AGENTS.md](https://github.com/jpawlowski/hass.tibber_prices/blob/v0.20.0/AGENTS.md) section "Planning Major Refactorings" for AI-specific guidance.
+See [AGENTS.md](https://github.com/jpawlowski/hass.tibber_prices/blob/main/AGENTS.md) section "Planning Major Refactorings" for AI-specific guidance.
 
 ## Tools and Resources
 

docs/developer/versioned_docs/version-v0.21.0/setup.md

@@ -1,6 +1,6 @@
 # Development Setup
 
-> **Note:** This guide is under construction. For now, please refer to [`AGENTS.md`](https://github.com/jpawlowski/hass.tibber_prices/blob/v0.20.0/AGENTS.md) for detailed setup information.
+> **Note:** This guide is under construction. For now, please refer to [`AGENTS.md`](https://github.com/jpawlowski/hass.tibber_prices/blob/main/AGENTS.md) for detailed setup information.
 
 ## Prerequisites
 
@@ -54,4 +54,4 @@ Visit http://localhost:8123
 ./scripts/release/hassfest
 ```
 
-See [`AGENTS.md`](https://github.com/jpawlowski/hass.tibber_prices/blob/v0.20.0/AGENTS.md) for detailed patterns and conventions.
+See [`AGENTS.md`](https://github.com/jpawlowski/hass.tibber_prices/blob/main/AGENTS.md) for detailed patterns and conventions.

docs/developer/versioned_docs/version-v0.21.0/timer-architecture.md

@@ -410,7 +410,7 @@ _LOGGER.setLevel(logging.DEBUG)
 
 - **[Architecture](./architecture.md)** - Overall system design, data flow
 - **[Caching Strategy](./caching-strategy.md)** - Cache lifetimes, invalidation, midnight turnover
-- **[AGENTS.md](https://github.com/jpawlowski/hass.tibber_prices/blob/v0.20.0/AGENTS.md)** - Complete reference for AI development
+- **[AGENTS.md](https://github.com/jpawlowski/hass.tibber_prices/blob/main/AGENTS.md)** - Complete reference for AI development
 
 ---
 

docs/developer/versioned_docs/version-v0.22.0/architecture.md

@@ -6,7 +6,7 @@ comments: false
 
 This document provides a visual overview of the integration's architecture, focusing on end-to-end data flow and caching layers.
 
-For detailed implementation patterns, see [`AGENTS.md`](https://github.com/jpawlowski/hass.tibber_prices/blob/v0.20.0/AGENTS.md).
+For detailed implementation patterns, see [`AGENTS.md`](https://github.com/jpawlowski/hass.tibber_prices/blob/main/AGENTS.md).
 
 ---
 
@@ -355,4 +355,4 @@ Sensors organized by **calculation method** (refactored Nov 2025):
 - **[Setup Guide](./setup.md)** - Development environment setup
 - **[Testing Guide](./testing.md)** - How to test changes
 - **[Release Management](./release-management.md)** - Release workflow and versioning
-- **[AGENTS.md](https://github.com/jpawlowski/hass.tibber_prices/blob/v0.20.0/AGENTS.md)** - Complete reference for AI development
+- **[AGENTS.md](https://github.com/jpawlowski/hass.tibber_prices/blob/main/AGENTS.md)** - Complete reference for AI development