diff --git a/custom_components/tibber_prices/blueprints/script/tibber_prices/notify_residents.yaml b/custom_components/tibber_prices/blueprints/script/tibber_prices/notify_residents.yaml
index fa1c9cb..5f8ebc1 100644
--- a/custom_components/tibber_prices/blueprints/script/tibber_prices/notify_residents.yaml
+++ b/custom_components/tibber_prices/blueprints/script/tibber_prices/notify_residents.yaml
@@ -3,7 +3,7 @@ blueprint:
   description: >
     **Companion script blueprint for
     [Tibber Prices](https://my.home-assistant.io/redirect/hacs_repository/?owner=jpawlowski&repository=hass.tibber_prices&category=integration)
-    appliance blueprints** · Blueprint v2.0.0
+    appliance blueprints** · Blueprint v1.0.0
 
 
     Advanced notification dispatcher that replaces the simple
diff --git a/custom_components/tibber_prices/services.yaml b/custom_components/tibber_prices/services.yaml
index 54eefc1..1c14203 100644
--- a/custom_components/tibber_prices/services.yaml
+++ b/custom_components/tibber_prices/services.yaml
@@ -1011,6 +1011,11 @@ find_cheapest_schedule:
             - next_24h
             - next_48h
           translation_key: search_scope
+    include_current_interval:
+      required: false
+      default: true
+      selector:
+        boolean:
     search_range:
       collapsed: true
       fields:
diff --git a/custom_components/tibber_prices/services/find_cheapest_block.py b/custom_components/tibber_prices/services/find_cheapest_block.py
index 9a871f5..42d4a00 100644
--- a/custom_components/tibber_prices/services/find_cheapest_block.py
+++ b/custom_components/tibber_prices/services/find_cheapest_block.py
@@ -191,6 +191,7 @@ def _attempt_find_block(
     duration_intervals: int,
     smooth_outliers: bool,
     min_distance_from_avg: float | None,
+    power_profile: list[int] | None,
     reverse: bool,
 ) -> tuple[dict | None, str]:
     """Attempt to find a block with specific filter parameters.
@@ -207,7 +208,9 @@ def _attempt_find_block(
     else:
         search_data = filtered
 
-    result = find_cheapest_contiguous_window(search_data, duration_intervals, reverse=reverse)
+    result = find_cheapest_contiguous_window(
+        search_data, duration_intervals, reverse=reverse, power_profile=power_profile
+    )
 
     if result is None:
         return None, _determine_no_window_reason(
@@ -335,6 +338,7 @@ async def _handle_find_block(
         duration_intervals=effective_duration,
         smooth_outliers=smooth_outliers,
         min_distance_from_avg=min_distance_from_avg,
+        power_profile=power_profile,
         reverse=reverse,
     )
 
@@ -362,6 +366,7 @@ async def _handle_find_block(
                 duration_intervals=effective_duration,
                 smooth_outliers=smooth_outliers,
                 min_distance_from_avg=step.min_distance_from_avg,
+                power_profile=power_profile,
                 reverse=reverse,
             )
             if result is not None:
@@ -411,7 +416,9 @@ async def _handle_find_block(
     effective_duration_minutes = effective_duration * INTERVAL_MINUTES
 
     # Find the opposite-direction window for price comparison (from full unfiltered list)
-    comparison_result = find_cheapest_contiguous_window(price_info, effective_duration, reverse=not reverse)
+    comparison_result = find_cheapest_contiguous_window(
+        price_info, effective_duration, reverse=not reverse, power_profile=power_profile
+    )
 
     # Calculate statistics and build response
     stats = calculate_window_statistics(
diff --git a/custom_components/tibber_prices/services/find_cheapest_schedule.py b/custom_components/tibber_prices/services/find_cheapest_schedule.py
index 48d551a..d105d16 100644
--- a/custom_components/tibber_prices/services/find_cheapest_schedule.py
+++ b/custom_components/tibber_prices/services/find_cheapest_schedule.py
@@ -113,6 +113,7 @@ FIND_CHEAPEST_SCHEDULE_SERVICE_SCHEMA = vol.Schema(
         ),
         vol.Optional("must_finish_by"): or_entity_ref(cv.datetime),
         vol.Optional("search_scope"): vol.In(VALID_SEARCH_SCOPES),
+        vol.Optional("include_current_interval", default=True): cv.boolean,
         vol.Optional("max_price_level"): vol.In([lvl.lower() for lvl in PRICE_LEVEL_ORDER]),
         vol.Optional("min_price_level"): vol.In([lvl.lower() for lvl in PRICE_LEVEL_ORDER]),
         vol.Optional("include_comparison_details", default=False): cv.boolean,
@@ -133,10 +134,13 @@ def _compute_task_price_comparison(
     unit_factor: int,
     *,
     include_details: bool,
+    power_profile: list[int] | None = None,
 ) -> dict[str, float | str | None] | None:
     """Compute per-task comparison against most expensive window of same duration."""
     duration_intervals = len(task_intervals)
-    comparison_result = find_cheapest_contiguous_window(full_price_info, duration_intervals, reverse=True)
+    comparison_result = find_cheapest_contiguous_window(
+        full_price_info, duration_intervals, reverse=True, power_profile=power_profile
+    )
     if comparison_result is None:
         return None
 
@@ -196,6 +200,8 @@ def _find_cheapest_window_in_pool(
     pool: list[dict[str, Any]],
     duration_intervals: int,
     available: list[bool],
+    *,
+    power_profile: list[int] | None = None,
 ) -> tuple[int, int] | None:
     """
     Find the cheapest contiguous window of `duration_intervals` in available pool slots.
@@ -204,6 +210,9 @@ def _find_cheapest_window_in_pool(
         pool: Full sorted interval list.
         duration_intervals: Required contiguous count.
         available: Boolean mask, same length as pool. True = still available.
+        power_profile: Optional watt value per interval for weighted scoring.
+            Only the first duration_intervals values are used. When provided,
+            scoring uses \u03a3 price[i] \u00d7 watt[i] instead of \u03a3 price[i].
 
     Returns:
         (start_index, end_index_exclusive) of the best window, or None if not found.
@@ -235,7 +244,10 @@ def _find_cheapest_window_in_pool(
             j += 1
 
         if len(block) == duration_intervals:
-            window_sum = sum(iv["total"] for iv in block)
+            if power_profile:
+                window_sum = sum(block[k]["total"] * power_profile[k] for k in range(len(block)))
+            else:
+                window_sum = sum(iv["total"] for iv in block)
             if best_sum is None or window_sum < best_sum:
                 best_sum = window_sum
                 best_start = i
@@ -306,7 +318,9 @@ def _attempt_schedule(
             for k in range(min(sequential_min_idx, len(search_data))):
                 available[k] = False
 
-        window = _find_cheapest_window_in_pool(search_data, dur_intervals, available)
+        window = _find_cheapest_window_in_pool(
+            search_data, dur_intervals, available, power_profile=task.get("power_profile")
+        )
 
         if window is None:
             unscheduled.append(task["name"])
@@ -622,6 +636,7 @@ async def handle_find_cheapest_schedule(call: ServiceCall) -> ServiceResponse:
                     price_info,
                     unit_factor,
                     include_details=include_comparison_details,
+                    power_profile=task.get("power_profile"),
                 ),
             }
         )
diff --git a/custom_components/tibber_prices/services/helpers.py b/custom_components/tibber_prices/services/helpers.py
index 7d0db4a..c49e546 100644
--- a/custom_components/tibber_prices/services/helpers.py
+++ b/custom_components/tibber_prices/services/helpers.py
@@ -357,7 +357,13 @@ def _resolve_time_with_day_offset(
     )
 
 
-def _resolve_scope(scope: str, now: datetime, _home_tz: ZoneInfo) -> tuple[datetime, datetime]:
+def _resolve_scope(
+    scope: str,
+    now: datetime,
+    _home_tz: ZoneInfo,
+    *,
+    include_current: bool,
+) -> tuple[datetime, datetime]:
     """
     Convert a search_scope shorthand into explicit start/end datetimes.
 
@@ -374,16 +380,18 @@ def _resolve_scope(scope: str, now: datetime, _home_tz: ZoneInfo) -> tuple[datet
     tomorrow_start = today_start + timedelta(days=1)
     day_after_start = today_start + timedelta(days=2)
 
+    rolling_start = floor_to_quarter_hour(now) if include_current else now
+
     if scope == "today":
         return today_start, tomorrow_start
     if scope == "tomorrow":
         return tomorrow_start, day_after_start
     if scope == "remaining_today":
-        return floor_to_quarter_hour(now), tomorrow_start
+        return rolling_start, tomorrow_start
     if scope == "next_24h":
-        return floor_to_quarter_hour(now), now + timedelta(hours=24)
+        return rolling_start, now + timedelta(hours=24)
     if scope == "next_48h":
-        return floor_to_quarter_hour(now), now + timedelta(hours=48)
+        return rolling_start, now + timedelta(hours=48)
 
     raise ServiceValidationError(
         translation_domain=DOMAIN,
@@ -517,7 +525,7 @@ def resolve_search_range(
 
     # Priority 0: search_scope shorthand
     if "search_scope" in call_data:
-        return _resolve_scope(call_data["search_scope"], now, home_tz)
+        return _resolve_scope(call_data["search_scope"], now, home_tz, include_current=include_current)
 
     # --- Resolve start ---
     if "search_start" in call_data:
diff --git a/custom_components/tibber_prices/translations/de.json b/custom_components/tibber_prices/translations/de.json
index b5e6e3e..c7b12f3 100644
--- a/custom_components/tibber_prices/translations/de.json
+++ b/custom_components/tibber_prices/translations/de.json
@@ -1669,7 +1669,7 @@
         },
         "power_profile": {
           "name": "Leistungsprofil",
-          "description": "Variable Leistungsaufnahme in Watt pro 15-Minuten-Intervall. Wenn gesetzt, gibt estimated_total_cost den tatsächlichen Verbrauch statt einer festen 1-kW-Last an."
+          "description": "Variable Leistungsaufnahme in Watt pro 15-Minuten-Intervall. Beeinflusst die Fensterauswahl (Phasen mit hoher Leistung landen auf den günstigsten bzw. teuersten Intervallen) und die Kostenberechnung (estimated_total_cost nutzt den tatsächlichen Verbrauch statt einer festen 1-kW-Last)."
         },
         "smooth_outliers": {
           "name": "Ausreißer glätten",
@@ -1789,7 +1789,7 @@
         },
         "power_profile": {
           "name": "Leistungsprofil",
-          "description": "Variable Leistungsaufnahme in Watt pro 15-Minuten-Intervall. Wenn gesetzt, gibt estimated_total_cost den tatsächlichen Verbrauch statt einer festen 1-kW-Last an."
+          "description": "Variable Leistungsaufnahme in Watt pro 15-Minuten-Intervall. Beeinflusst die Fensterauswahl (Phasen mit hoher Leistung landen auf den günstigsten bzw. teuersten Intervallen) und die Kostenberechnung (estimated_total_cost nutzt den tatsächlichen Verbrauch statt einer festen 1-kW-Last)."
         },
         "smooth_outliers": {
           "name": "Ausreißer glätten",
@@ -1913,7 +1913,7 @@
         },
         "power_profile": {
           "name": "Leistungsprofil",
-          "description": "Variable Leistungsaufnahme in Watt pro 15-Minuten-Intervall. Wenn gesetzt, gibt estimated_total_cost den tatsächlichen Verbrauch statt einer festen 1-kW-Last an."
+          "description": "Variable Leistungsaufnahme in Watt pro 15-Minuten-Intervall. Beeinflusst nur die Kostenberechnung (estimated_total_cost nutzt den tatsächlichen Verbrauch statt einer festen 1-kW-Last). Profilgewichtete Auswahl gilt nicht für nicht-zusammenhängende Intervalle."
         },
         "smooth_outliers": {
           "name": "Ausreißer glätten",
@@ -2037,7 +2037,7 @@
         },
         "power_profile": {
           "name": "Leistungsprofil",
-          "description": "Variable Leistungsaufnahme in Watt pro 15-Minuten-Intervall. Wenn gesetzt, gibt estimated_total_cost den tatsächlichen Verbrauch statt einer festen 1-kW-Last an."
+          "description": "Variable Leistungsaufnahme in Watt pro 15-Minuten-Intervall. Beeinflusst nur die Kostenberechnung (estimated_total_cost nutzt den tatsächlichen Verbrauch statt einer festen 1-kW-Last). Profilgewichtete Auswahl gilt nicht für nicht-zusammenhängende Intervalle."
         },
         "smooth_outliers": {
           "name": "Ausreißer glätten",
@@ -2139,6 +2139,10 @@
           "name": "Suchende-Versatz (Minuten)",
           "description": "Alternative: Suche endet in dieser Anzahl Minuten ab jetzt. Positiv = Zukunft (480 = in 8 Stunden), negativ = Vergangenheit (-60 = vor 1 Stunde). Wird ignoriert, wenn Suchende oder Suchende-Uhrzeit gesetzt ist."
         },
+        "include_current_interval": {
+          "name": "Aktuelles Intervall einbeziehen",
+          "description": "Das aktuell laufende 15-Minuten-Intervall in die Suche einbeziehen. Wenn aktiviert, starten rollierende Suchbereiche wie remaining_today und next_24h am Beginn des aktuellen Intervalls, sodass es ausgewählt werden kann."
+        },
         "max_price_level": {
           "name": "Maximale Preisstufe",
           "description": "Nur Intervalle bis zu dieser Tibber-Preisstufe berücksichtigen. very_cheap = restriktivste, very_expensive = keine Einschränkung."
diff --git a/custom_components/tibber_prices/translations/en.json b/custom_components/tibber_prices/translations/en.json
index 40aebbb..b5a61e4 100644
--- a/custom_components/tibber_prices/translations/en.json
+++ b/custom_components/tibber_prices/translations/en.json
@@ -1669,7 +1669,7 @@
         },
         "power_profile": {
           "name": "Power Profile",
-          "description": "Variable power draw in watts per 15-minute interval. When set, estimated_total_cost reflects actual consumption instead of a flat 1 kW load. The profile is extended by repeating the last value if shorter than the window."
+          "description": "Variable power draw in watts per 15-minute interval. Affects window selection (high-wattage phases land on cheapest/most expensive intervals) and cost reporting (estimated_total_cost uses actual consumption instead of flat 1 kW)."
         },
         "smooth_outliers": {
           "name": "Smooth Outliers",
@@ -1789,7 +1789,7 @@
         },
         "power_profile": {
           "name": "Power Profile",
-          "description": "Variable power draw in watts per 15-minute interval. When set, estimated_total_cost reflects actual consumption instead of a flat 1 kW load. The profile is extended by repeating the last value if shorter than the window."
+          "description": "Variable power draw in watts per 15-minute interval. Affects window selection (high-wattage phases land on cheapest/most expensive intervals) and cost reporting (estimated_total_cost uses actual consumption instead of flat 1 kW)."
         },
         "smooth_outliers": {
           "name": "Smooth Outliers",
@@ -1913,7 +1913,7 @@
         },
         "power_profile": {
           "name": "Power Profile",
-          "description": "Variable power draw in watts per 15-minute interval. When set, estimated_total_cost reflects actual consumption instead of a flat 1 kW load. The profile is extended by repeating the last value if shorter than the window."
+          "description": "Variable power draw in watts per 15-minute interval. Affects cost reporting only (estimated_total_cost uses actual consumption instead of flat 1 kW). Profile-weighted selection is not applied to non-contiguous interval picks."
         },
         "smooth_outliers": {
           "name": "Smooth Outliers",
@@ -2037,7 +2037,7 @@
         },
         "power_profile": {
           "name": "Power Profile",
-          "description": "Variable power draw in watts per 15-minute interval. When set, estimated_total_cost reflects actual consumption instead of a flat 1 kW load. The profile is extended by repeating the last value if shorter than the window."
+          "description": "Variable power draw in watts per 15-minute interval. Affects cost reporting only (estimated_total_cost uses actual consumption instead of flat 1 kW). Profile-weighted selection is not applied to non-contiguous interval picks."
         },
         "smooth_outliers": {
           "name": "Smooth Outliers",
@@ -2059,7 +2059,7 @@
     },
     "find_cheapest_schedule": {
       "name": "Find Cheapest Schedule",
-      "description": "Schedules multiple appliances optimally without time overlap. Each task gets the cheapest available contiguous window; tasks are placed greedily in ascending cost order. Returns a per-task schedule with start/end times and price stats. If scheduling is incomplete, the response includes a stable reason code in the reason field (for example: no_data_in_range, no_intervals_matching_level_filter, insufficient_contiguous_window, insufficient_contiguous_window_for_some_tasks).",
+      "description": "Schedules multiple appliances optimally without time overlap. Each task gets the cheapest available contiguous window; tasks are placed longest-first for efficient packing unless sequential ordering is enabled. Returns a per-task schedule with start/end times and price stats. If scheduling is incomplete, the response includes a stable reason code in the reason field (for example: no_data_in_range, no_intervals_matching_level_filter, insufficient_contiguous_window, insufficient_contiguous_window_for_some_tasks).",
       "sections": {
         "search_range": {
           "name": "Custom Search Range",
@@ -2139,6 +2139,10 @@
           "name": "Search End Offset (minutes)",
           "description": "Alternative: stop searching this many minutes from now. Positive = future, negative = past. Ignored if Search End or Search End Time is set."
         },
+        "include_current_interval": {
+          "name": "Include Current Interval",
+          "description": "Include the currently running 15-minute interval in the search. When enabled, rolling scopes like remaining_today and next_24h start at the beginning of the current interval so it can be selected."
+        },
         "max_price_level": {
           "name": "Maximum Price Level",
           "description": "Only consider intervals at or below this Tibber price level. very_cheap = most restrictive, very_expensive = no restriction."
diff --git a/custom_components/tibber_prices/translations/nb.json b/custom_components/tibber_prices/translations/nb.json
index 3c1bc14..388c104 100644
--- a/custom_components/tibber_prices/translations/nb.json
+++ b/custom_components/tibber_prices/translations/nb.json
@@ -1669,7 +1669,7 @@
         },
         "power_profile": {
           "name": "Effektprofil",
-          "description": "Variabelt effektforbruk i watt per 15-minuttersintervall. Naa satt, gjenspeiler estimated_total_cost faktisk forbruk i stedet for en fast 1 kW-last."
+          "description": "Variabelt effektforbruk i watt per 15-minuttersintervall. Påvirker valg av tidsvindu (faser med høyt forbruk legges til de billigste/dyreste intervallene) og kostnadsrapportering (estimated_total_cost bruker faktisk forbruk i stedet for en fast 1 kW-last)."
         },
         "smooth_outliers": {
           "name": "Glatt utliggere",
@@ -1789,7 +1789,7 @@
         },
         "power_profile": {
           "name": "Effektprofil",
-          "description": "Variabelt effektforbruk i watt per 15-minuttersintervall. Naa satt, gjenspeiler estimated_total_cost faktisk forbruk i stedet for en fast 1 kW-last."
+          "description": "Variabelt effektforbruk i watt per 15-minuttersintervall. Påvirker valg av tidsvindu (faser med høyt forbruk legges til de billigste/dyreste intervallene) og kostnadsrapportering (estimated_total_cost bruker faktisk forbruk i stedet for en fast 1 kW-last)."
         },
         "smooth_outliers": {
           "name": "Glatt utliggere",
@@ -1913,7 +1913,7 @@
         },
         "power_profile": {
           "name": "Effektprofil",
-          "description": "Variabelt effektforbruk i watt per 15-minuttersintervall. Naa satt, gjenspeiler estimated_total_cost faktisk forbruk i stedet for en fast 1 kW-last."
+          "description": "Variabelt effektforbruk i watt per 15-minuttersintervall. Påvirker kun kostnadsrapportering (estimated_total_cost bruker faktisk forbruk i stedet for en fast 1 kW-last). Profilveiet utvalg gjelder ikke for ikke-sammenhengende intervaller."
         },
         "smooth_outliers": {
           "name": "Glatt utliggere",
@@ -2037,7 +2037,7 @@
         },
         "power_profile": {
           "name": "Effektprofil",
-          "description": "Variabelt effektforbruk i watt per 15-minuttersintervall. Naa satt, gjenspeiler estimated_total_cost faktisk forbruk i stedet for en fast 1 kW-last."
+          "description": "Variabelt effektforbruk i watt per 15-minuttersintervall. Påvirker kun kostnadsrapportering (estimated_total_cost bruker faktisk forbruk i stedet for en fast 1 kW-last). Profilveiet utvalg gjelder ikke for ikke-sammenhengende intervaller."
         },
         "smooth_outliers": {
           "name": "Glatt utliggere",
@@ -2139,6 +2139,10 @@
           "name": "Søkeslutt-forskyvning (minutter)",
           "description": "Alternativ: Stopp søk dette antall minutter fra nå. Positiv = fremtid (480 = om 8 timer), negativ = fortid (-60 = 1 time siden). Ignoreres hvis Søkeslutt eller Søkeslutt-klokkeslett er satt."
         },
+        "include_current_interval": {
+          "name": "Ta med gjeldende intervall",
+          "description": "Ta med det pågående 15-minuttersintervallet i søket. Når dette er aktivert, starter rullerende søkeområder som remaining_today og next_24h ved starten av gjeldende intervall slik at det kan velges."
+        },
         "max_price_level": {
           "name": "Maksimalt prisnivaae",
           "description": "Ta bare med intervaller paa eller under dette Tibber-prisnivaeet. very_cheap = mest restriktivt, very_expensive = ingen begrensning."
diff --git a/custom_components/tibber_prices/translations/nl.json b/custom_components/tibber_prices/translations/nl.json
index 900f04d..19b2f42 100644
--- a/custom_components/tibber_prices/translations/nl.json
+++ b/custom_components/tibber_prices/translations/nl.json
@@ -1669,7 +1669,7 @@
         },
         "power_profile": {
           "name": "Vermogensprofiel",
-          "description": "Variabel vermogensverbruik in watt per 15-minuten-interval. Indien ingesteld, weerspiegelt estimated_total_cost het werkelijke verbruik."
+          "description": "Variabel vermogensverbruik in watt per 15-minuten-interval. Beïnvloedt vensterselectie (fasen met hoog vermogen worden op de goedkoopste/duurste intervallen geplaatst) en kostenrapportage (estimated_total_cost gebruikt werkelijk verbruik in plaats van een vaste 1 kW-last)."
         },
         "smooth_outliers": {
           "name": "Uitschieters gladstrijken",
@@ -1789,7 +1789,7 @@
         },
         "power_profile": {
           "name": "Vermogensprofiel",
-          "description": "Variabel vermogensverbruik in watt per 15-minuten-interval. Indien ingesteld, weerspiegelt estimated_total_cost het werkelijke verbruik."
+          "description": "Variabel vermogensverbruik in watt per 15-minuten-interval. Beïnvloedt vensterselectie (fasen met hoog vermogen worden op de goedkoopste/duurste intervallen geplaatst) en kostenrapportage (estimated_total_cost gebruikt werkelijk verbruik in plaats van een vaste 1 kW-last)."
         },
         "smooth_outliers": {
           "name": "Uitschieters gladstrijken",
@@ -1913,7 +1913,7 @@
         },
         "power_profile": {
           "name": "Vermogensprofiel",
-          "description": "Variabel vermogensverbruik in watt per 15-minuten-interval. Indien ingesteld, weerspiegelt estimated_total_cost het werkelijke verbruik."
+          "description": "Variabel vermogensverbruik in watt per 15-minuten-interval. Beïnvloedt alleen de kostenrapportage (estimated_total_cost gebruikt werkelijk verbruik in plaats van een vaste 1 kW-last). Profielgewogen selectie geldt niet voor niet-aaneengesloten intervallen."
         },
         "smooth_outliers": {
           "name": "Uitschieters gladstrijken",
@@ -2037,7 +2037,7 @@
         },
         "power_profile": {
           "name": "Vermogensprofiel",
-          "description": "Variabel vermogensverbruik in watt per 15-minuten-interval. Indien ingesteld, weerspiegelt estimated_total_cost het werkelijke verbruik."
+          "description": "Variabel vermogensverbruik in watt per 15-minuten-interval. Beïnvloedt alleen de kostenrapportage (estimated_total_cost gebruikt werkelijk verbruik in plaats van een vaste 1 kW-last). Profielgewogen selectie geldt niet voor niet-aaneengesloten intervallen."
         },
         "smooth_outliers": {
           "name": "Uitschieters gladstrijken",
@@ -2139,6 +2139,10 @@
           "name": "Zoekeinde-offset (minuten)",
           "description": "Alternatief: Stop met zoeken over dit aantal minuten vanaf nu. Positief = toekomst (480 = over 8 uur), negatief = verleden (-60 = 1 uur geleden). Wordt genegeerd als Zoekeinde of Zoekeinde-tijd is ingesteld."
         },
+        "include_current_interval": {
+          "name": "Huidig interval opnemen",
+          "description": "Neem het momenteel lopende interval van 15 minuten mee in de zoekopdracht. Wanneer ingeschakeld, starten rollende scopes zoals remaining_today en next_24h aan het begin van het huidige interval zodat het gekozen kan worden."
+        },
         "max_price_level": {
           "name": "Maximaal prijsniveau",
           "description": "Overweeg alleen intervallen op of onder dit Tibber-prijsniveau. very_cheap = meest restrictief, very_expensive = geen beperking."
diff --git a/custom_components/tibber_prices/translations/sv.json b/custom_components/tibber_prices/translations/sv.json
index 88dc828..ecd3139 100644
--- a/custom_components/tibber_prices/translations/sv.json
+++ b/custom_components/tibber_prices/translations/sv.json
@@ -1669,7 +1669,7 @@
         },
         "power_profile": {
           "name": "Effektprofil",
-          "description": "Variabel effektfoerbruekning i watt per 15-minutersintervall. Om instaellt, aaterspeglar estimated_total_cost faktisk foerbruekning istaellet foer en fast 1 kW-last."
+          "description": "Variabel effektförbrukning i watt per 15-minutersintervall. Påverkar fönsterurval (faser med hög effekt placeras på billigaste/dyraste intervallen) och kostnadsrapportering (estimated_total_cost använder faktisk förbrukning istället för en fast 1 kW-last)."
         },
         "smooth_outliers": {
           "name": "Jämna utliggare",
@@ -1789,7 +1789,7 @@
         },
         "power_profile": {
           "name": "Effektprofil",
-          "description": "Variabel effektfoerbruekning i watt per 15-minutersintervall. Om instaellt, aaterspeglar estimated_total_cost faktisk foerbruekning istaellet foer en fast 1 kW-last."
+          "description": "Variabel effektförbrukning i watt per 15-minutersintervall. Påverkar fönsterurval (faser med hög effekt placeras på billigaste/dyraste intervallen) och kostnadsrapportering (estimated_total_cost använder faktisk förbrukning istället för en fast 1 kW-last)."
         },
         "smooth_outliers": {
           "name": "Jämna utliggare",
@@ -1913,7 +1913,7 @@
         },
         "power_profile": {
           "name": "Effektprofil",
-          "description": "Variabel effektfoerbruekning i watt per 15-minutersintervall. Om instaellt, aaterspeglar estimated_total_cost faktisk foerbruekning istaellet foer en fast 1 kW-last."
+          "description": "Variabel effektförbrukning i watt per 15-minutersintervall. Påverkar bara kostnadsrapportering (estimated_total_cost använder faktisk förbrukning istället för en fast 1 kW-last). Profilvägt urval tillämpas inte för icke-sammanhängande intervaller."
         },
         "smooth_outliers": {
           "name": "Jämna utliggare",
@@ -2037,7 +2037,7 @@
         },
         "power_profile": {
           "name": "Effektprofil",
-          "description": "Variabel effektfoerbruekning i watt per 15-minutersintervall. Om instaellt, aaterspeglar estimated_total_cost faktisk foerbruekning istaellet foer en fast 1 kW-last."
+          "description": "Variabel effektförbrukning i watt per 15-minutersintervall. Påverkar bara kostnadsrapportering (estimated_total_cost använder faktisk förbrukning istället för en fast 1 kW-last). Profilvägt urval tillämpas inte för icke-sammanhängande intervaller."
         },
         "smooth_outliers": {
           "name": "Jämna utliggare",
@@ -2139,6 +2139,10 @@
           "name": "Sökslut-förskjutning (minuter)",
           "description": "Alternativ: Sluta söka detta antal minuter från nu. Positivt = framtid (480 = om 8 timmar), negativt = förflutet (-60 = 1 timme sedan). Ignoreras om Sökslut eller Sökslut-klockslag är satt."
         },
+        "include_current_interval": {
+          "name": "Inkludera aktuellt intervall",
+          "description": "Inkludera det pågående 15-minutersintervallet i sökningen. När detta är aktiverat börjar rullande sökomfång som remaining_today och next_24h vid början av det aktuella intervallet så att det kan väljas."
+        },
         "max_price_level": {
           "name": "Maximal prisnivaae",
           "description": "Ta bara med intervall paa eller under denna Tibber-prisnivaae. very_cheap = mest restriktivt, very_expensive = ingen begraensning."
diff --git a/custom_components/tibber_prices/utils/price_window.py b/custom_components/tibber_prices/utils/price_window.py
index e8bc577..ba47705 100644
--- a/custom_components/tibber_prices/utils/price_window.py
+++ b/custom_components/tibber_prices/utils/price_window.py
@@ -22,18 +22,24 @@ def find_cheapest_contiguous_window(
     duration_intervals: int,
     *,
     reverse: bool = False,
+    power_profile: list[int] | None = None,
 ) -> dict[str, Any] | None:
     """
     Find the cheapest (or most expensive) contiguous window of exactly N intervals.
 
-    Uses a sliding window algorithm (O(n)) to find the window with the
-    lowest (or highest) average price.
+    Uses a sliding window algorithm (O(n)) when no power profile is given.
+    With a power profile, uses O(n\u00d7k) direct scoring so that the window with the
+    lowest weighted cost (\u03a3 price[i] \u00d7 watt[i]) is selected instead of lowest
+    average price. This ensures high-wattage phases of the cycle land on cheap intervals.
 
     Args:
         intervals: Sorted list of price interval dicts with 'startsAt' and 'total' keys.
             Must be pre-sorted by startsAt in ascending order.
         duration_intervals: Number of consecutive intervals required.
         reverse: If True, find the most expensive window instead of cheapest.
+        power_profile: Optional watt value per interval. Only the first
+            duration_intervals values are used (profile may be longer). When
+            provided, scoring uses \u03a3 price[i] \u00d7 watt[i] instead of \u03a3 price[i].
 
     Returns:
         Dict with window details (start, end, intervals, statistics),
@@ -44,20 +50,47 @@ def find_cheapest_contiguous_window(
     if n == 0 or duration_intervals <= 0 or n < duration_intervals:
         return None
 
-    # Calculate initial window sum
-    window_sum = sum(intervals[i]["total"] for i in range(duration_intervals))
-    best_sum = window_sum
-    best_start = 0
+    best_intervals: list[dict[str, Any]] | None = None
+    best_sum: float | None = None
 
-    # Slide the window
-    for i in range(1, n - duration_intervals + 1):
-        window_sum += intervals[i + duration_intervals - 1]["total"]
-        window_sum -= intervals[i - 1]["total"]
-        if (window_sum > best_sum) if reverse else (window_sum < best_sum):
-            best_sum = window_sum
-            best_start = i
+    # Price-level filtering can create gaps in time. Search each truly contiguous
+    # run independently so the returned window always matches real timestamps.
+    for segment in group_intervals_into_segments(intervals):
+        segment_intervals = segment["intervals"]
+        if len(segment_intervals) < duration_intervals:
+            continue
+
+        if power_profile:
+            # With a power profile the weights rotate with each window position,
+            # so a simple O(1) sliding update is not possible. Recompute each score
+            # directly. Only the first duration_intervals weights are used.
+            segment_best_sum: float = sum(
+                segment_intervals[k]["total"] * power_profile[k] for k in range(duration_intervals)
+            )
+            segment_best_start = 0
+            for i in range(1, len(segment_intervals) - duration_intervals + 1):
+                score = sum(segment_intervals[i + k]["total"] * power_profile[k] for k in range(duration_intervals))
+                if (score > segment_best_sum) if reverse else (score < segment_best_sum):
+                    segment_best_sum = score
+                    segment_best_start = i
+        else:
+            window_sum = sum(segment_intervals[i]["total"] for i in range(duration_intervals))
+            segment_best_sum = window_sum
+            segment_best_start = 0
+            for i in range(1, len(segment_intervals) - duration_intervals + 1):
+                window_sum += segment_intervals[i + duration_intervals - 1]["total"]
+                window_sum -= segment_intervals[i - 1]["total"]
+                if (window_sum > segment_best_sum) if reverse else (window_sum < segment_best_sum):
+                    segment_best_sum = window_sum
+                    segment_best_start = i
+
+        if best_sum is None or ((segment_best_sum > best_sum) if reverse else (segment_best_sum < best_sum)):
+            best_sum = segment_best_sum
+            best_intervals = segment_intervals[segment_best_start : segment_best_start + duration_intervals]
+
+    if best_intervals is None:
+        return None
 
-    best_intervals = intervals[best_start : best_start + duration_intervals]
     return {
         "start": best_intervals[0]["startsAt"],
         "end_interval_start": best_intervals[-1]["startsAt"],
@@ -123,87 +156,101 @@ def _find_with_min_segment(
     """
     Find cheapest/most expensive N intervals with minimum segment length constraint.
 
-    Iteratively picks intervals, discards segments that are too
-    short, and replaces them with next-best alternatives.
-
-    Converges in at most `count` iterations (worst case: every replacement
-    creates a new short segment that gets discarded).
+    Uses dynamic programming to find an exact selection of `count` intervals
+    where every contiguous run has at least `min_segment` intervals. Real time
+    gaps break segments even if the filtered list remains index-contiguous.
     """
     n = len(intervals)
 
-    # Build index lookup: interval original index → position
-    # Price-sorted indices for picking cheapest/most expensive available
-    price_order = sorted(range(n), key=lambda i: intervals[i]["total"], reverse=reverse)
+    contiguous_with_prev = [False] * n
+    for i in range(1, n):
+        prev_start = _parse_timestamp(intervals[i - 1]["startsAt"])
+        curr_start = _parse_timestamp(intervals[i]["startsAt"])
+        contiguous_with_prev[i] = curr_start - prev_start == timedelta(minutes=15)
 
-    selected: set[int] = set()
-    excluded: set[int] = set()
+    def is_better(new_cost: float, old_cost: float | None) -> bool:
+        if old_cost is None:
+            return True
+        return new_cost > old_cost if reverse else new_cost < old_cost
 
-    # Initial pick: cheapest 'count' intervals
-    picked = 0
-    for idx in price_order:
-        if picked >= count:
-            break
-        if idx not in excluded:
-            selected.add(idx)
-            picked += 1
+    current_states: dict[tuple[int, int], float] = {(0, 0): 0.0}
+    backpointers: list[dict[tuple[int, int], tuple[tuple[int, int], bool]]] = [{} for _ in range(n + 1)]
 
-    if len(selected) < count:
+    for idx, interval in enumerate(intervals, start=1):
+        next_states: dict[tuple[int, int], float] = {}
+        next_back: dict[tuple[int, int], tuple[tuple[int, int], bool]] = {}
+        interval_cost = float(interval["total"])
+
+        for prev_state, prev_cost in current_states.items():
+            selected_count, run_len = prev_state
+            effective_run_len = run_len
+
+            if idx > 1 and not contiguous_with_prev[idx - 1] and run_len != 0:
+                if run_len < min_segment:
+                    continue
+                effective_run_len = 0
+
+            if effective_run_len in (0, min_segment):
+                skip_state = (selected_count, 0)
+                if is_better(prev_cost, next_states.get(skip_state)):
+                    next_states[skip_state] = prev_cost
+                    next_back[skip_state] = (prev_state, False)
+
+            if selected_count >= count:
+                continue
+
+            if effective_run_len == 0:
+                new_run_len = 1
+            elif effective_run_len < min_segment:
+                new_run_len = effective_run_len + 1
+            else:
+                new_run_len = min_segment
+
+            take_state = (selected_count + 1, new_run_len)
+            take_cost = prev_cost + interval_cost
+            if is_better(take_cost, next_states.get(take_state)):
+                next_states[take_state] = take_cost
+                next_back[take_state] = (prev_state, True)
+
+        current_states = next_states
+        backpointers[idx] = next_back
+
+    best_state: tuple[int, int] | None = None
+    best_cost: float | None = None
+    for state, cost in current_states.items():
+        selected_count, run_len = state
+        if selected_count != count or run_len not in (0, min_segment):
+            continue
+        if is_better(cost, best_cost):
+            best_state = state
+            best_cost = cost
+
+    if best_state is None:
         return None
 
-    # Iterative refinement: discard short segments, replace with next-cheapest
-    max_iterations = count + 1  # Safety bound
-    for _ in range(max_iterations):
-        sorted_selected = sorted(selected)
-        segments = _group_indices_into_segments(sorted_selected)
+    selected_indices: list[int] = []
+    state = best_state
+    for idx in range(n, 0, -1):
+        prev_state, took_interval = backpointers[idx][state]
+        if took_interval:
+            selected_indices.append(idx - 1)
+        state = prev_state
 
-        short_segments = [seg for seg in segments if len(seg) < min_segment]
-        if not short_segments:
-            break  # All segments meet minimum length
-
-        # Exclude all indices in short segments
-        for seg in short_segments:
-            for idx in seg:
-                selected.discard(idx)
-                excluded.add(idx)
-
-        # Refill from price order
-        needed = count - len(selected)
-        for idx in price_order:
-            if needed <= 0:
-                break
-            if idx not in selected and idx not in excluded:
-                selected.add(idx)
-                needed -= 1
-
-        if len(selected) < count:
-            # Not enough intervals available after exclusions
-            # Return best effort with what we have
-            break
-
-    sorted_selected = sorted(selected)
-    result_intervals = [intervals[i] for i in sorted_selected]
+    selected_indices.reverse()
+    result_intervals = [intervals[i] for i in selected_indices]
     segments = group_intervals_into_segments(result_intervals)
 
+    if len(result_intervals) != count:
+        return None
+    if any(seg["interval_count"] < min_segment for seg in segments):
+        return None
+
     return {
         "intervals": result_intervals,
         "segments": segments,
     }
 
 
-def _group_indices_into_segments(indices: list[int]) -> list[list[int]]:
-    """Group sorted integer indices into contiguous runs."""
-    if not indices:
-        return []
-
-    segments: list[list[int]] = [[indices[0]]]
-    for i in range(1, len(indices)):
-        if indices[i] == indices[i - 1] + 1:
-            segments[-1].append(indices[i])
-        else:
-            segments.append([indices[i]])
-    return segments
-
-
 def group_intervals_into_segments(
     intervals: list[dict[str, Any]],
 ) -> list[dict[str, Any]]:
diff --git a/docs/user/docs/scheduling-actions.md b/docs/user/docs/scheduling-actions.md
index 6dcb169..c2fa22d 100644
--- a/docs/user/docs/scheduling-actions.md
+++ b/docs/user/docs/scheduling-actions.md
@@ -135,20 +135,26 @@ These parameters are available across all scheduling actions:
 | Parameter | Description | Default |
 |-----------|-------------|---------|
 | `entry_id` | Config entry ID. Auto-selects if you only have one home. | Auto |
-| `include_current_interval` | Include the currently running 15-minute interval in the search? | `true` |
+| `include_current_interval` | Include the currently running 15-minute interval in the search? Only applies to `remaining_today`, `next_24h`, `next_48h`, and default (no scope) — has no effect for `today` or `tomorrow` (those always cover the full calendar day). | `true` |
 | `min_price_level` | Only consider intervals at or above this Tibber level | — |
 | `max_price_level` | Only consider intervals at or below this Tibber level | — |
 | `smooth_outliers` | Smooth price outliers before searching (see [below](#outlier-smoothing)) | `true` |
 | `min_distance_from_avg` | Require result to differ from average by X% (see [below](#minimum-distance-from-average)) | — |
 | `allow_relaxation` | Progressively loosen filters to guarantee a result (see [below](#relaxation)) | `true` |
 | `duration_flexibility_minutes` | Max minutes the duration may be shortened during relaxation (see [below](#relaxation)) | Auto |
-| `power_profile` | Watt values per 15-min interval for accurate cost estimates | — |
+| `power_profile` | Watt values per 15-min interval. Affects **window selection** for block/schedule services and cost reporting for all services (see note below). | — |
 | `use_base_unit` | Use base currency (EUR, NOK) instead of subunit (ct, øre) | `false` |
 
 :::note `min_distance_from_avg` availability
 `min_distance_from_avg` is available in `find_cheapest_block`, `find_most_expensive_block`, `find_cheapest_hours`, and `find_most_expensive_hours`. It is **not** available in `find_cheapest_schedule` (multi-task semantics make a single threshold ambiguous).
 :::
 
+:::note `power_profile` selection impact
+For `find_cheapest_block`, `find_most_expensive_block`, and `find_cheapest_schedule`, the profile controls **which window is selected**: each candidate is scored by weighted cost (Σ price × watt per interval) so high-wattage phases land on the cheapest (or most expensive) intervals.
+
+For `find_cheapest_hours` and `find_most_expensive_hours`, the profile only affects cost reporting — non-contiguous interval picks make profile-weighted selection semantically undefined.
+:::
+
 ### Price Level Filtering
 
 Restrict the search to specific Tibber price levels. Levels from lowest to highest: `very_cheap`, `cheap`, `normal`, `expensive`, `very_expensive`.
@@ -169,7 +175,12 @@ data:
 
 ### Power Profile
 
-By default, cost estimates assume a constant 1 kW load. If your appliance has variable power draw, provide a power profile — **one watt value per 15-minute interval**:
+By default, cost estimates assume a constant 1 kW load. If your appliance has variable power draw, provide a power profile — **one watt value per 15-minute interval**.
+
+When a power profile is present it affects **both selection and reporting**:
+
+- **Selection** — instead of lowest average price, each candidate window is scored by weighted cost (Σ price × watt per interval). High-wattage phases of the cycle are placed on the cheapest intervals.
+- **Reporting** — `estimated_total_cost` and `estimated_load_kwh` reflect the actual variable power draw.
 
 <details>
 <summary>Show YAML: Power Profile</summary>
@@ -190,8 +201,6 @@ data:
 
   </details>
 
-The service then calculates `estimated_total_cost` using the actual power draw per interval instead of flat 1 kW, and adds `estimated_load_kwh` (total energy consumed) to the response.
-
 :::info Duration and profile must match
 The number of entries in `power_profile` must exactly match the number of 15-minute intervals in `duration`. A 2-hour duration needs 8 entries.
 :::
@@ -731,6 +740,7 @@ response_variable: result
 | `unscheduled_tasks` | List of task names that couldn't be placed (or `null` if all succeeded) |
 | `tasks[]` | Each task with its assigned time window and price statistics |
 | `tasks[].start` / `tasks[].end` | When to start and stop each appliance |
+| `tasks[].price_comparison` | Optional per-task comparison against the opposite extreme window when `include_comparison_details` is `true` |
 | `total_estimated_cost` | Combined cost across all tasks |
 | `relaxation_applied` | `true` if [relaxation](#relaxation) was needed to schedule all tasks |
 | `relaxation_steps` | Number of relaxation steps applied (only when `relaxation_applied` is `true`) |
@@ -740,7 +750,7 @@ response_variable: result
 If you call `find_cheapest_block` separately for each appliance, they might all find the **same** cheap time window. `find_cheapest_schedule` solves this by tracking which intervals are already claimed — each appliance gets its own non-overlapping slot.
 
 :::tip Sequential ordering
-By default, `find_cheapest_schedule` optimizes purely for **price** — it does not guarantee task order. The dryer could be scheduled before the washing machine if that's cheaper. For sequential workflows (washing machine → dryer), add `sequential: true` to guarantee declaration-order scheduling. See [Automation Examples — Sequential Scheduling](automation-examples.md#washing-machine--dryer-sequential-scheduling) for a complete example.
+By default, `find_cheapest_schedule` does not guarantee task order. In non-sequential mode, tasks are packed longest-first and each task then gets the cheapest slot that still fits, so the dryer may be scheduled before the washing machine. For sequential workflows (washing machine → dryer), add `sequential: true` to guarantee declaration-order scheduling. See [Automation Examples — Sequential Scheduling](automation-examples.md#washing-machine--dryer-sequential-scheduling) for a complete example.
 :::
 
 ### Gap Minutes
@@ -1005,7 +1015,7 @@ All durations are rounded **up** to the nearest 15 minutes because Tibber price
 
 ### Comparison Details
 
-Add `include_comparison_details: true` to `find_cheapest_block` or `find_cheapest_hours` to get extra fields in the comparison:
+Add `include_comparison_details: true` to `find_cheapest_block`, `find_cheapest_hours`, or `find_cheapest_schedule` to get extra fields in the comparison:
 
 <details>
 <summary>Show YAML: Comparison Details</summary>
@@ -1019,7 +1029,7 @@ data:
 
 </details>
 
-This adds `comparison_price_min`, `comparison_price_max`, and `comparison_window_end` to the `price_comparison` object.
+This adds `comparison_price_min`, `comparison_price_max`, and `comparison_window_end` to the `price_comparison` object. For `find_cheapest_schedule`, these details are added to each task's `price_comparison` object.
 
 ### Response When No Window Found
 
@@ -1041,6 +1051,8 @@ The `reason` field contains a stable machine-readable code you can use in automa
 | `window_below_distance_threshold` | Most expensive block found, but not far enough above average |
 | `selection_above_distance_threshold` | Hours found, but not far enough below average (`min_distance_from_avg`) |
 | `selection_below_distance_threshold` | Most expensive hours found, but not far enough above average |
+| `insufficient_contiguous_window` | No valid contiguous block could be built from the remaining intervals |
+| `insufficient_contiguous_window_for_some_tasks` | Schedule found slots for some tasks, but not all of them |
 | `relaxation_exhausted` | All relaxation steps tried, still no result (only when `allow_relaxation: true`) |
 
 Always check the failure fields in your automations before using the results.
diff --git a/tests/services/test_search_range.py b/tests/services/test_search_range.py
index 5f0a5d3..3a1c3f3 100644
--- a/tests/services/test_search_range.py
+++ b/tests/services/test_search_range.py
@@ -12,6 +12,7 @@ Also validates schema boundaries for all 4 services.
 from __future__ import annotations
 
 from datetime import datetime, time as dt_time, timedelta
+from typing import Any, cast
 from zoneinfo import ZoneInfo
 
 import pytest
@@ -148,6 +149,29 @@ class TestResolveSearchRangeNegativeOffsetMinutes:
         assert start.day == 10
         assert start.hour == 23
 
+    def test_search_scope_excludes_current_interval_when_disabled(self) -> None:
+        """Relative search scopes honor include_current_interval=false."""
+        now = datetime(2026, 4, 11, 14, 37, tzinfo=BERLIN)
+        call_data = {
+            "search_scope": "next_24h",
+            "include_current_interval": False,
+        }
+        start, end = resolve_search_range(call_data, now, BERLIN)
+        assert start == now
+        assert end == now + timedelta(hours=24)
+
+    def test_search_scope_includes_current_interval_when_enabled(self) -> None:
+        """Relative search scopes include the current quarter when enabled."""
+        now = datetime(2026, 4, 11, 14, 37, tzinfo=BERLIN)
+        call_data = {
+            "search_scope": "next_24h",
+            "include_current_interval": True,
+        }
+        start, end = resolve_search_range(call_data, now, BERLIN)
+        assert start.hour == 14
+        assert start.minute == 30
+        assert end == now + timedelta(hours=24)
+
 
 # =============================================================================
 # Schema validation: day_offset boundaries
@@ -160,12 +184,12 @@ class TestSchemaValidation:
     def _validate_block_schema(self, data: dict) -> dict:
         """Validate data through block schema."""
         schema = vol.Schema(_COMMON_BLOCK_SCHEMA)
-        return schema(data)
+        return cast("dict[str, Any]", schema(data))
 
     def _validate_hours_schema(self, data: dict) -> dict:
         """Validate data through hours schema."""
         schema = vol.Schema(_COMMON_HOURS_SCHEMA)
-        return schema(data)
+        return cast("dict[str, Any]", schema(data))
 
     def test_block_schema_accepts_negative_day_offset(self) -> None:
         """Block schema allows negative day offsets."""
diff --git a/tests/services/test_sequential_scheduling.py b/tests/services/test_sequential_scheduling.py
index fca267b..bd661c6 100644
--- a/tests/services/test_sequential_scheduling.py
+++ b/tests/services/test_sequential_scheduling.py
@@ -71,6 +71,18 @@ class TestSequentialSchema:
         )
         assert result["sequential"] is False
 
+    def test_schema_defaults_include_current_interval_true(self) -> None:
+        """Schedule schema should expose include_current_interval like other actions."""
+        result = cast(
+            "dict[str, Any]",
+            FIND_CHEAPEST_SCHEDULE_SERVICE_SCHEMA(
+                {
+                    "tasks": [{"name": "dishwasher", "duration": timedelta(hours=1)}],
+                }
+            ),
+        )
+        assert result["include_current_interval"] is True
+
 
 class TestSequentialOrdering:
     """Sequential mode preserves declaration order and chains search windows."""
diff --git a/tests/test_price_window.py b/tests/test_price_window.py
index 0033b80..4837c56 100644
--- a/tests/test_price_window.py
+++ b/tests/test_price_window.py
@@ -170,6 +170,87 @@ class TestFindCheapestContiguousWindow:
         selected_prices = [iv["total"] for iv in result["intervals"]]
         assert selected_prices == [5.0, 3.0, 2.0, 8.0]
 
+    def test_gap_breaks_contiguous_window(self) -> None:
+        """A real time gap prevents windows from spanning across it."""
+        intervals = _make_intervals([1.0, 2.0, 3.0, 4.0], gap_after={1})
+        assert find_cheapest_contiguous_window(intervals, 3) is None
+
+
+# =============================================================================
+# find_cheapest_contiguous_window — power_profile weighted scoring
+# =============================================================================
+
+
+class TestFindCheapestContiguousWindowWithPowerProfile:
+    """Tests for power-profile-weighted window selection."""
+
+    def test_profile_changes_selection(self) -> None:
+        """Front-loaded profile prefers placing cheap intervals at high-wattage positions."""
+        # Prices: [10, 10, 5, 5, 10]
+        # Without profile: windows 1 and 2 both sum to 20; first tie wins (index 1, prices [10,5,5])
+        # Profile [3000, 500, 500] — first interval costs 6× more per unit:
+        #   Window 0: 10*3000+10*500+5*500  = 37500
+        #   Window 1: 10*3000+ 5*500+5*500  = 35000
+        #   Window 2:  5*3000+ 5*500+10*500 = 22500  ← cheapest weighted
+        prices = [10.0, 10.0, 5.0, 5.0, 10.0]
+        intervals = _make_intervals(prices)
+
+        result_no_profile = find_cheapest_contiguous_window(intervals, 3)
+        assert result_no_profile is not None
+        assert result_no_profile["intervals"][0]["total"] == 10.0  # index 1
+
+        result_profile = find_cheapest_contiguous_window(intervals, 3, power_profile=[3000, 500, 500])
+        assert result_profile is not None
+        assert result_profile["intervals"][0]["total"] == 5.0  # index 2
+
+    def test_profile_no_effect_with_uniform_weights(self) -> None:
+        """A uniform profile produces the same selection as no profile."""
+        prices = [20.0, 15.0, 5.0, 3.0, 4.0, 18.0, 25.0]
+        intervals = _make_intervals(prices)
+
+        result_no_profile = find_cheapest_contiguous_window(intervals, 3)
+        result_uniform = find_cheapest_contiguous_window(intervals, 3, power_profile=[1000, 1000, 1000])
+
+        assert result_no_profile is not None
+        assert result_uniform is not None
+        assert result_no_profile["intervals"][0]["startsAt"] == result_uniform["intervals"][0]["startsAt"]
+
+    def test_profile_reverse_most_expensive(self) -> None:
+        """Profile-weighted most-expensive selection places high-watt phases on peak prices."""
+        # Prices: [5, 10, 20, 10, 5]
+        # Profile [3000, 500]: front-load is 6× heavier
+        #   Window 0: 5*3000+10*500 = 20000
+        #   Window 1: 10*3000+20*500 = 40000
+        #   Window 2: 20*3000+10*500 = 65000  ← most expensive weighted
+        #   Window 3: 10*3000+ 5*500 = 32500
+        prices = [5.0, 10.0, 20.0, 10.0, 5.0]
+        intervals = _make_intervals(prices)
+
+        result = find_cheapest_contiguous_window(intervals, 2, reverse=True, power_profile=[3000, 500])
+        assert result is not None
+        assert result["intervals"][0]["total"] == 20.0  # window starts at index 2
+
+    def test_profile_longer_than_duration_uses_first_n(self) -> None:
+        """A profile longer than duration only uses the first duration_intervals values."""
+        # Profile [3000, 500, 500, 999, 999] — only first 3 used for a 3-interval window
+        # Should be identical to profile [3000, 500, 500]
+        prices = [10.0, 10.0, 5.0, 5.0, 10.0]
+        intervals = _make_intervals(prices)
+
+        result_exact = find_cheapest_contiguous_window(intervals, 3, power_profile=[3000, 500, 500])
+        result_longer = find_cheapest_contiguous_window(intervals, 3, power_profile=[3000, 500, 500, 9999, 9999])
+
+        assert result_exact is not None
+        assert result_longer is not None
+        assert result_exact["intervals"][0]["startsAt"] == result_longer["intervals"][0]["startsAt"]
+
+    def test_profile_gap_still_prevents_spanning(self) -> None:
+        """Profile weighting does not override the temporal-gap check."""
+        # Very cheap interval at index 2 is separated by a gap — cannot be included
+        intervals = _make_intervals([10.0, 10.0, 1.0, 10.0], gap_after={1})
+        # Only two contiguous segments of 2 intervals each; 3-interval window impossible
+        assert find_cheapest_contiguous_window(intervals, 3, power_profile=[3000, 500, 500]) is None
+
 
 # =============================================================================
 # find_cheapest_n_intervals
@@ -280,6 +361,11 @@ class TestFindCheapestNIntervals:
         assert result is not None
         assert len(result["intervals"]) == 3
 
+    def test_min_segment_impossible_returns_none(self) -> None:
+        """Return None instead of partial results when min segment cannot be met."""
+        intervals = _make_intervals([1.0, 2.0, 3.0, 4.0], gap_after={0, 1, 2})
+        assert find_cheapest_n_intervals(intervals, 2, min_segment_intervals=2) is None
+
 
 # =============================================================================
 # group_intervals_into_segments