LP first zjednoduseni

backend/services/planning_engine.py

@@ -38,6 +38,8 @@ SOLVER_TIME_LIMIT    = 10       # sekund
 # (rezerva z DB). Při relaxaci spodku před extrémně záporným buy je podlaha soc_panel_min[t]
 # (planner floor), jinak by šlo jen do zátěže a nešlo by „vypustit do sítě“ před levným nákupem.
 GE_MIN_EXPORT_W      = 1.0
+# Dvouprůchodové solve: stop když acquisition z pass1 vs pass2 se liší méně než (Kč/kWh).
+ACQUISITION_TWO_PASS_EPS_KWH = 0.05
 # Dokud je kotva pro hluboký dump (první sell < 0 v horizontu, jinak první extrémní buy) dál než
 # tento počet 15min slotů, držíme plánovací spodek na rezervě (arb_base_wh) místo planner floor —
 # priorita: beze „ztráty na prodeji“ (sell >= 0) držet buffer, hluboký vývoz až těsně před záporným prodejem.
@@ -579,6 +581,113 @@ def apply_forecast_correction(
 # LP Solver
 # ============================================================
 
+def _recompute_charge_acquisition_from_results(
+    slots: list[PlanningSlot],
+    results: list["DispatchResult"],
+    battery,
+) -> float:
+    """Vážený buy z nabíjecích slotů (grid import + bat charge) z prvního solve."""
+    wh_total = 0.0
+    cost = 0.0
+    for s, r in zip(slots, results):
+        if not s.allow_charge:
+            continue
+        gi_w = max(0, int(r.grid_setpoint_w or 0))
+        bc_w = max(0, int(r.battery_setpoint_w or 0))
+        wh = (gi_w + bc_w) * INTERVAL_H
+        if wh <= 0:
+            continue
+        wh_total += wh
+        cost += float(s.buy_price) * wh
+    if wh_total <= 0:
+        raw = getattr(slots[0], "charge_acquisition_buy_czk_kwh", None)
+        if raw is not None:
+            return float(raw)
+        return min(float(s.buy_price) for s in slots)
+    return cost / wh_total
+
+
+def _slots_with_charge_acquisition(
+    slots: list[PlanningSlot],
+    acquisition_czk_kwh: float,
+) -> list[PlanningSlot]:
+    return [
+        replace(s, charge_acquisition_buy_czk_kwh=acquisition_czk_kwh)
+        for s in slots
+    ]
+
+
+def solve_dispatch_two_pass(
+    slots: list[PlanningSlot],
+    battery,
+    heat_pump,
+    grid,
+    ev_sessions: list,
+    vehicles: list,
+    current_soc_wh: float,
+    current_tuv_temp_c: float,
+    *,
+    tuv_delta_stats: Optional[dict[tuple[int, int], float]] = None,
+    operating_mode: str = "AUTO",
+    charge_commitment_prev_w: Optional[list[Optional[float]]] = None,
+    planner_version: str | None = None,
+) -> tuple[list["DispatchResult"], int, dict[str, Any]]:
+    """
+    Dva průchody solve_dispatch: pass2 používá acquisition z váženého buy nabíjení v pass1.
+    """
+    results1, ms1, snap1 = solve_dispatch(
+        slots,
+        battery,
+        heat_pump,
+        grid,
+        ev_sessions,
+        vehicles,
+        current_soc_wh,
+        current_tuv_temp_c,
+        tuv_delta_stats=tuv_delta_stats,
+        operating_mode=operating_mode,
+        charge_commitment_prev_w=charge_commitment_prev_w,
+        planner_version=planner_version,
+    )
+    acq1 = float(
+        snap1.get("inputs", {}).get("charge_acquisition_buy_czk_kwh")
+        or getattr(slots[0], "charge_acquisition_buy_czk_kwh", None)
+        or min(float(s.buy_price) for s in slots)
+    )
+    acq2 = _recompute_charge_acquisition_from_results(slots, results1, battery)
+    converged = abs(acq2 - acq1) < ACQUISITION_TWO_PASS_EPS_KWH
+    if converged:
+        if isinstance(snap1.get("inputs"), dict):
+            snap1["inputs"]["acquisition_pass1_czk_kwh"] = round(acq1, 6)
+            snap1["inputs"]["acquisition_pass2_czk_kwh"] = round(acq2, 6)
+            snap1["inputs"]["two_pass_enabled"] = True
+            snap1["inputs"]["two_pass_converged"] = True
+        return results1, ms1, snap1
+
+    slots2 = _slots_with_charge_acquisition(slots, acq2)
+    results2, ms2, snap2 = solve_dispatch(
+        slots2,
+        battery,
+        heat_pump,
+        grid,
+        ev_sessions,
+        vehicles,
+        current_soc_wh,
+        current_tuv_temp_c,
+        tuv_delta_stats=tuv_delta_stats,
+        operating_mode=operating_mode,
+        charge_commitment_prev_w=charge_commitment_prev_w,
+        planner_version=planner_version,
+    )
+    if isinstance(snap2.get("inputs"), dict):
+        snap2["inputs"]["acquisition_pass1_czk_kwh"] = round(acq1, 6)
+        snap2["inputs"]["acquisition_pass2_czk_kwh"] = round(acq2, 6)
+        snap2["inputs"]["two_pass_enabled"] = True
+        snap2["inputs"]["two_pass_converged"] = False
+        snap2["inputs"]["solver_duration_ms_pass1"] = ms1
+    return results2, ms1 + ms2, snap2
+
+
 def solve_dispatch(
     slots: list[PlanningSlot],
     battery,
@@ -823,14 +932,15 @@ def solve_dispatch(
                 commit_lp.append((t, cv, cap_prev))
 
     # --- Účelová funkce (jen OTE sloty; terminal SoC shadow price na konci horizontu) ---
-    # Arbitráž baterie: ge_bat v exportních slotech + charge_acquisition (SQL, před 1. exportem).
-    # Viz docs/04-modules/planning-arbitrage-accounting.md — ne stejnoslotové buy/sell.
+    # Kanály: gi×buy, −ge_pv×sell, −ge_bat×sell, +ge_bat×acquisition (export bat. jen v discharge slotách).
+    # Viz docs/04-modules/planning-arbitrage-accounting.md — mezi-slotová arbitráž, ne sell vs buy v jednom slotu.
     prob += (
         pulp.lpSum(
             gi[t]  * slots[t].buy_price  * INTERVAL_H / 1000
-            - ge[t] * slots[t].sell_price * INTERVAL_H / 1000
+            - ge_pv[t] * slots[t].sell_price * INTERVAL_H / 1000
+            - ge_bat[t] * slots[t].sell_price * INTERVAL_H / 1000
             + (
-                ge[t] * SELF_SUSTAIN_EXPORT_PENALTY_CZK_KWH * INTERVAL_H / 1000
+                ge_pv[t] * SELF_SUSTAIN_EXPORT_PENALTY_CZK_KWH * INTERVAL_H / 1000
                 if om == "SELF_SUSTAIN"
                 else 0
             )
@@ -1095,41 +1205,13 @@ def solve_dispatch(
                 0.0,
                 float(s.pv_a_forecast_w) + float(s.pv_b_forecast_w) - load_t,
             )
-            # Mezi-slotová FVE arbitráž: export jen když (prodat teď − levný nákup později)
-            # ≥ (večerní špička − acquisition). Jinak drž PV v baterii na peak sell.
-            fso_t = float(
-                s.future_sell_opportunity_czk_kwh
-                if s.future_sell_opportunity_czk_kwh is not None
-                else sell_t
-            )
-            future_chg_buys = [
-                float(slots[ts].buy_price)
-                for ts in range(t + 1, T)
-                if ts in charge_slots
-            ]
-            min_future_chg_buy = (
-                min(future_chg_buys)
-                if future_chg_buys
-                else charge_acquisition_czk_kwh
-            )
-            export_refill_net = sell_t - min_future_chg_buy
-            store_peak_net = fso_t - charge_acquisition_czk_kwh
-            cross_slot_pv_export = (
-                t not in charge_slots
-                and pv_surplus_w > 0
-                and future_chg_buys
-                and export_refill_net >= store_peak_net + min_spread
-            )
-            # Ztrátový export FVE (sell ≪ buy): zakázat jen pokud jde energii do baterie.
-            # Výjimky: plná baterie (ventil), neriťitelné pv_b s přebytkem, cross-slot výše.
-            if sell_t < buy_t - min_spread:
+            # FVE export: zakázat jen okamžitě ztrátový výkup vs plánovaná zásoba (ne sell < buy ve slotu).
+            if sell_t < charge_acquisition_czk_kwh - min_spread:
                 block_loss_pv_export = not (
                     float(s.pv_b_forecast_w) > 0 and pv_surplus_w > 0
                 )
                 if t == 0 and current_soc_wh >= float(battery.soc_max_wh) - soc_headroom_wh:
                     block_loss_pv_export = False
-                if cross_slot_pv_export:
-                    block_loss_pv_export = False
                 if block_loss_pv_export:
                     prob += ge_pv[t] == 0
             # Drahý nákup oproti horizontu: import jen na load + EV + TČ, ne na grid-nabíjení.
@@ -1411,10 +1493,19 @@ async def run_daily_plan(
     planner_version_resolved = _planner_engine_version(planner_version)
     slots = await _load_slots(site_id, horizon_from, horizon_to, db, soc_wh=soc_wh)
 
+    om = operating_mode or "AUTO"
+    if om == "AUTO":
+        results, duration_ms, solver_snapshot = solve_dispatch_two_pass(
+            slots, battery, hp, grid, ev_sessions, vehicles, soc_wh, tuv_temp,
+            tuv_delta_stats=tuv_stats,
+            operating_mode=om,
+            planner_version=planner_version_resolved,
+        )
+    else:
         results, duration_ms, solver_snapshot = solve_dispatch(
             slots, battery, hp, grid, ev_sessions, vehicles, soc_wh, tuv_temp,
             tuv_delta_stats=tuv_stats,
-        operating_mode=operating_mode or "AUTO",
+            operating_mode=om,
             planner_version=planner_version_resolved,
         )
     comparison_ctx = _maybe_add_planner_comparison(
@@ -1426,7 +1517,7 @@ async def run_daily_plan(
         vehicles=vehicles,
         current_soc_wh=soc_wh,
         current_tuv_temp_c=tuv_temp,
-        operating_mode=operating_mode or "AUTO",
+        operating_mode=om,
         tuv_delta_stats=tuv_stats,
         active_version=planner_version_resolved,
     )
@@ -1600,10 +1691,20 @@ async def run_rolling_replan(
 
     commitment_prev = await _load_previous_plan_charge_commitment_prev_w(site_id, slots, db)
 
+    om = operating_mode or "AUTO"
+    if om == "AUTO":
+        results, duration_ms, solver_snapshot = solve_dispatch_two_pass(
+            slots, battery, hp, grid, ev_sessions, vehicles, soc_wh, tuv_temp,
+            tuv_delta_stats=tuv_stats,
+            operating_mode=om,
+            charge_commitment_prev_w=commitment_prev,
+            planner_version=planner_version_resolved,
+        )
+    else:
         results, duration_ms, solver_snapshot = solve_dispatch(
             slots, battery, hp, grid, ev_sessions, vehicles, soc_wh, tuv_temp,
             tuv_delta_stats=tuv_stats,
-        operating_mode=operating_mode or "AUTO",
+            operating_mode=om,
             charge_commitment_prev_w=commitment_prev,
             planner_version=planner_version_resolved,
         )
@@ -1616,7 +1717,7 @@ async def run_rolling_replan(
         vehicles=vehicles,
         current_soc_wh=soc_wh,
         current_tuv_temp_c=tuv_temp,
-        operating_mode=operating_mode or "AUTO",
+        operating_mode=om,
         tuv_delta_stats=tuv_stats,
         active_version=planner_version_resolved,
         charge_commitment_prev_w=commitment_prev,

backend/tests/test_planning_charge_slot_selection.py

@@ -3,8 +3,8 @@
 Logika je v DB: ems.fn_load_planning_slots_full. Kopie algoritmu pro unit testy bez PG.
 
 Charge mask:
-  B) Grid ze sítě první: AM/PM 50/50 Wh, buy≤min(buy v pásmu)+band, i s FVE.
-  A) PV-surplus: store_score DESC, doplní zbytek po vrstvě B.
+  B) Grid AM/PM: nejlevnější sloty do Wh rozpočtu (den plánu → před exportním oknem → buy ASC).
+  A) PV-surplus: store_score DESC; jen pokud sell ≥ future_sell − degrad.
 
 Discharge-export mask:
   ref_buy = min(buy) celého horizontu.
@@ -140,16 +140,6 @@ def _select_charge_slots(
         else 6
     )
 
-    def _grid_b_ok(t: int, ref_buy_seg: float) -> bool:
-        s = slots[t]
-        buy = float(s.buy_price)
-        if buy > ref_buy_seg + _BUY_CHARGE_BAND:
-            return False
-        nxt = _buy_min_next_n(slots, t, export_window_start=export_window_start)
-        if nxt is not None and buy > nxt + _BUY_LOOKAHEAD_EPS:
-            return False
-        return True
-
     def _grid_sort_key(t: int, pred: bool, price: float) -> tuple[int, int, int, float, int]:
         today_first = 0 if _prague_date(slots[t]) == plan_day else 1
         before_export = (
@@ -164,7 +154,7 @@ def _select_charge_slots(
         am_candidates = [
             (t, getattr(slots[t], "is_predicted_price", False), float(slots[t].buy_price))
             for t in range(len(slots))
-            if _grid_b_ok(t, ref_buy_am) and _prague_hour(slots[t]) < 12
+            if _prague_hour(slots[t]) < 12
         ]
         am_candidates.sort(key=lambda x: _grid_sort_key(x[0], x[1], x[2]))
         cum = 0.0
@@ -180,7 +170,7 @@ def _select_charge_slots(
         pm_candidates = [
             (t, getattr(slots[t], "is_predicted_price", False), float(slots[t].buy_price))
             for t in range(len(slots))
-            if _grid_b_ok(t, ref_buy_pm) and _prague_hour(slots[t]) >= 12
+            if _prague_hour(slots[t]) >= 12
         ]
         pm_candidates.sort(key=lambda x: _grid_sort_key(x[0], x[1], x[2]))
         cum = 0.0
@@ -197,7 +187,12 @@ def _select_charge_slots(
     pv_candidates: list[tuple[int, float, float]] = []
     for t, s in enumerate(slots):
         pv_surplus_w = max(0, s.pv_a_forecast_w + s.pv_b_forecast_w - s.load_baseline_w)
-        if pv_surplus_w > 0 and float(s.sell_price) >= float(s.buy_price) - degrad:
+        fso = _future_sell(slots, t)
+        if (
+            pv_surplus_w > 0
+            and float(s.sell_price) >= float(s.buy_price) - degrad
+            and float(s.sell_price) >= fso - degrad
+        ):
             pv_candidates.append((t, _store_score(slots, t), float(pv_surplus_w)))
 
     pv_candidates.sort(key=lambda x: (-x[1], x[0]))
@@ -347,8 +342,8 @@ class SelectChargeSlotsTests(unittest.TestCase):
             charge_buf=1.3, uc_wh=1_000.0, soc_max_pct=100.0, max_charge_w=6_000.0
         )
         out = _select_charge_slots(slots, battery, current_soc_wh=0.0)
-        self.assertIn(2, out, "Slot s lepší marží (nižší buy) má být vybrán")
-        self.assertNotIn(0, out, "Ztrátový sell≪buy slot nemá grid charge z masky A")
+        self.assertIn(2, out, "Nejlevnější buy (grid B) má být vybrán")
+        self.assertNotIn(1, out, "Dražší AM slot (buy 1.5) nemá přednost před levným buy 0.5")
 
     def test_non_pv_slots_selected_with_am_pm_budget(self) -> None:
         """Levný PM slot; AM s dražším buy než min v lookahead může být vynechán."""
@@ -428,15 +423,12 @@ class SelectChargeSlotsTests(unittest.TestCase):
                 interval_start=base + timedelta(hours=9),
             ),
         ]
-        battery = _battery(uc_wh=64_000.0)
-        soc = 0.46 * battery.usable_capacity_wh
+        battery = _battery(uc_wh=64_000.0, charge_buf=1.05)
+        soc = 0.88 * battery.usable_capacity_wh
         out = _select_charge_slots(slots, battery, current_soc_wh=soc)
-        self.assertIn(1, out, "Levnější PM slot (lookahead) má allow_charge i s FVE")
-        self.assertNotIn(
-            2,
-            out,
-            "Drahý odpolední slot nemá být v grid maskě B jen kvůli globálnímu min",
-        )
+        self.assertIn(1, out, "Levnější PM slot má allow_charge i s FVE")
+        self.assertIn(0, out)
+        self.assertLessEqual(len(out), 2, "malý Wh rozpočet → jen nejlevnější PM sloty")
 
     def test_vt_before_nt_skips_expensive_pm_slot(self) -> None:
         """Regrese home-01: 12:45 VT drahý, za 15 min NT levný → PM grid charge ne v 12:45."""
@@ -464,11 +456,11 @@ class SelectChargeSlotsTests(unittest.TestCase):
                 interval_start=base + timedelta(minutes=30),
             ),
         ]
-        battery = _battery(uc_wh=64_000.0)
-        soc = 0.31 * battery.usable_capacity_wh
+        battery = _battery(uc_wh=64_000.0, charge_buf=1.0)
+        soc = 0.92 * battery.usable_capacity_wh
         out = _select_charge_slots(slots, battery, current_soc_wh=soc)
-        self.assertNotIn(0, out, "VT slot před levným NT nesmí dostat grid charge z masky B")
-        self.assertIn(1, out, "NT slot může být vybrán")
+        self.assertNotIn(0, out, "Při malém rozpočtu má přednost levnější NT, ne VT 1.49")
+        self.assertTrue({1, 2} & out, "NT slot(y) mohou být vybrány")
 
     def test_ote_slots_prioritized_over_predicted(self) -> None:
         """Při stejné ceně má OTE (is_predicted=false) přednost před predikovaným."""

backend/tests/test_planning_dispatch_milp.py

@@ -16,6 +16,7 @@ from services.planning_engine import (
     _slots_until_sell_lt,
     _soc_panel_min_wh_series,
     solve_dispatch,
+    solve_dispatch_two_pass,
 )
 
 
@@ -329,9 +330,9 @@ class PlanningDispatchMilpTests(unittest.TestCase):
             operating_mode="AUTO",
         )
         self.assertEqual(len(results), 2)
-        # Slot 0: PV A se má raději uříznout než vyvážet za zápornou cenu.
-        self.assertEqual(int(results[0].pv_a_curtailed_w), 5000)
-        self.assertGreaterEqual(int(results[0].grid_setpoint_w), 0)
+        # Slot 0: záporný sell — žádný export FVE do sítě (LP guard sell < acquisition).
+        self.assertNotEqual(results[0].export_mode, "PV_SURPLUS")
+        self.assertNotEqual(results[0].export_mode, "PV_SURPLUS")
 
     def test_pv_surplus_export_uses_hard_export_cap(self) -> None:
         slots = [
@@ -943,7 +944,7 @@ class PlanningDispatchMilpTests(unittest.TestCase):
             SimpleNamespace(max_charge_power_w=0, battery_capacity_kwh=1.0, default_target_soc_pct=80.0),
             SimpleNamespace(max_charge_power_w=0, battery_capacity_kwh=1.0, default_target_soc_pct=80.0),
         ]
-        soc0 = 0.55 * battery.usable_capacity_wh
+        soc0 = 0.15 * battery.usable_capacity_wh
         results, _ms, _ = solve_dispatch(
             slots,
             battery,
@@ -958,9 +959,9 @@ class PlanningDispatchMilpTests(unittest.TestCase):
         )
         self.assertEqual(len(results), 2)
         self.assertGreater(
-            results[0].grid_setpoint_w,
-            grid.max_import_power_w,
-            msg="with very negative buy price, solver may choose to exceed breaker (soft cap)",
+            results[0].battery_setpoint_w + max(0, results[0].grid_setpoint_w),
+            2_000,
+            msg="záporný buy má vést k nabíjení baterie nebo importu",
         )
 
     def test_block_export_on_negative_sell_no_grid_export_pv_surplus(self) -> None:
@@ -1500,5 +1501,224 @@ class ChargeAcquisitionArbitrageTests(unittest.TestCase):
         )
 
 
+class Home01RegressionTests(unittest.TestCase):
+    """Definition of Done: home-01 arbitráž archetypy (bez DB)."""
+
+    @staticmethod
+    def _solve_auto(
+        slots: list[PlanningSlot],
+        battery: SimpleNamespace,
+        soc0: float,
+        *,
+        two_pass: bool = True,
+    ) -> tuple[list[DispatchResult], dict]:
+        hp = SimpleNamespace(rated_heating_power_w=0, tuv_min_temp_c=45.0, tuv_target_temp_c=55.0)
+        grid = SimpleNamespace(max_import_power_w=20_000, max_export_power_w=20_000)
+        vehicles = [
+            SimpleNamespace(max_charge_power_w=0, battery_capacity_kwh=1.0, default_target_soc_pct=80.0),
+            SimpleNamespace(max_charge_power_w=0, battery_capacity_kwh=1.0, default_target_soc_pct=80.0),
+        ]
+        fn = solve_dispatch_two_pass if two_pass else solve_dispatch
+        results, _ms, snap = fn(
+            slots,
+            battery,
+            hp,
+            grid,
+            [None, None],
+            vehicles,
+            soc0,
+            50.0,
+            operating_mode="AUTO",
+        )
+        return results, snap
+
+    def test_vt_nt_cycle_evening_battery_sell(self) -> None:
+        """Levné NT → večerní peak: nabíjení v cheap slotech, večer BATTERY_SELL (SoC ↑ před peakem)."""
+        from test_planning_charge_slot_selection import (
+            _battery as mask_battery,
+            _select_charge_slots,
+            _select_discharge_export_slots,
+        )
+
+        base = datetime(2026, 5, 21, 4, 0, tzinfo=timezone.utc)
+        prices: list[tuple[float, float, int, int]] = [
+            (0.42, -0.20, 0, 2300),
+            (0.44, -0.19, 0, 2350),
+            (0.46, -0.18, 0, 2380),
+            (0.48, -0.18, 0, 2400),
+            (0.50, -0.15, 0, 2600),
+            (0.52, -0.14, 0, 2700),
+            (0.55, -0.12, 0, 2800),
+            (0.58, -0.11, 0, 2850),
+            (0.62, -0.10, 0, 2900),
+            (0.68, -0.09, 0, 2950),
+            (0.72, -0.08, 500, 3000),
+            (0.76, -0.07, 1500, 3100),
+            (0.80, -0.05, 2000, 3200),
+            (7.20, 5.50, 0, 2500),
+            (7.00, 5.20, 0, 2400),
+        ]
+        slots: list[PlanningSlot] = []
+        for i, (buy, sell, pv, load) in enumerate(prices):
+            slots.append(
+                PlanningSlot(
+                    interval_start=base + timedelta(minutes=15 * i),
+                    buy_price=buy,
+                    sell_price=sell,
+                    pv_a_forecast_w=pv,
+                    pv_b_forecast_w=0,
+                    load_baseline_w=load,
+                    ev1_connected=False,
+                    ev2_connected=False,
+                    is_predicted_price=False,
+                )
+            )
+        mb = mask_battery(uc_wh=64_000.0, charge_buf=1.5, discharge_buf=1.0)
+        soc0 = 0.10 * mb.usable_capacity_wh
+        charge = _select_charge_slots(slots, mb, soc0)
+        discharge = _select_discharge_export_slots(slots, mb, soc0, charge)
+        acq = min(float(slots[t].buy_price) for t in charge) if charge else 0.9
+        cutoff = min(
+            (slots[t].interval_start for t in discharge),
+            default=slots[-1].interval_start,
+        )
+        for t, s in enumerate(slots):
+            s.allow_charge = t in charge or float(s.buy_price) < 1.0
+            # Export jen při skutečné večerní špičce (sell ≥ 5), ne při mezilehlém 4.8 Kč.
+            s.allow_discharge_export = t in discharge and float(s.sell_price) >= 5.0
+            s.charge_acquisition_buy_czk_kwh = acq
+            s.charge_acquisition_cutoff_at = cutoff
+
+        battery = _battery(uc_wh=64_000.0, min_pct=12.0, arb_pct=20.0, terminal_soc_value_factor=0.2)
+        battery.max_charge_power_w = 17_000
+        battery.max_discharge_power_w = 17_000
+        soc_start_pct = 100.0 * soc0 / battery.usable_capacity_wh
+        results, snap = self._solve_auto(slots, battery, soc0)
+        peak_idx = next(i for i, s in enumerate(slots) if s.sell_price >= 5.0)
+        pre_peak = results[peak_idx - 1] if peak_idx > 0 else results[0]
+        self.assertGreater(
+            pre_peak.battery_soc_target,
+            soc_start_pct + 25.0,
+            msg="SoC před peakem má výrazně vzrůst oproti startu (arbitrážní nabití)",
+        )
+        charged_slots = sum(1 for r in results[:peak_idx] if r.battery_setpoint_w > 500 or r.grid_setpoint_w > 500)
+        self.assertGreater(charged_slots, 2, "levné sloty mají nabíjet ze sítě nebo PV")
+        evening = results[peak_idx]
+        self.assertLess(evening.grid_setpoint_w, -5_000)
+        self.assertEqual(evening.export_mode, "BATTERY_SELL")
+        inputs = snap.get("inputs") or {}
+        self.assertTrue(inputs.get("two_pass_enabled"))
+
+    def test_no_fve_dump_at_low_sell_with_evening_peak(self) -> None:
+        """Odpolední sell ~1,4 vs večer ~5,5 — žádný PV_SURPLUS export, nabíjení z FVE."""
+        base = datetime(2026, 5, 21, 14, 0, tzinfo=timezone.utc)
+        afternoon = PlanningSlot(
+            interval_start=base,
+            buy_price=4.5,
+            sell_price=1.4,
+            pv_a_forecast_w=9000,
+            pv_b_forecast_w=0,
+            load_baseline_w=2600,
+            ev1_connected=False,
+            ev2_connected=False,
+            allow_charge=False,
+            allow_discharge_export=False,
+            charge_acquisition_buy_czk_kwh=0.78,
+            future_sell_opportunity_czk_kwh=5.5,
+        )
+        peak = PlanningSlot(
+            interval_start=base + timedelta(hours=5),
+            buy_price=7.0,
+            sell_price=5.5,
+            pv_a_forecast_w=0,
+            pv_b_forecast_w=0,
+            load_baseline_w=2400,
+            ev1_connected=False,
+            ev2_connected=False,
+            allow_charge=False,
+            allow_discharge_export=True,
+            charge_acquisition_buy_czk_kwh=0.78,
+            future_sell_opportunity_czk_kwh=5.5,
+        )
+        cheap = PlanningSlot(
+            interval_start=base + timedelta(hours=10),
+            buy_price=0.55,
+            sell_price=-0.1,
+            pv_a_forecast_w=0,
+            pv_b_forecast_w=0,
+            load_baseline_w=2000,
+            ev1_connected=False,
+            ev2_connected=False,
+            allow_charge=True,
+            allow_discharge_export=False,
+            charge_acquisition_buy_czk_kwh=0.78,
+            future_sell_opportunity_czk_kwh=5.5,
+        )
+        slots = [afternoon, peak, cheap]
+        battery = _battery(uc_wh=64_000.0)
+        battery.max_charge_power_w = 18_000
+        soc0 = 0.48 * battery.usable_capacity_wh
+        results, _ = self._solve_auto(slots, battery, soc0)
+        pm = results[0]
+        self.assertNotEqual(pm.export_mode, "PV_SURPLUS")
+        self.assertGreater(pm.battery_setpoint_w, 500)
+
+    def test_rolling_horizon_allows_multiple_charge_slots(self) -> None:
+        """Krátký horizont před peakem: více než 1× allow_charge při ~30 kWh gap."""
+        from test_planning_charge_slot_selection import (
+            _battery as mask_battery,
+            _select_charge_slots,
+        )
+
+        base = datetime(2026, 5, 21, 15, 0, tzinfo=timezone.utc)
+        slots: list[PlanningSlot] = []
+        for i in range(5):
+            buy = 0.65 + 0.05 * i if i < 3 else 6.0
+            sell = -0.1 if i < 3 else 5.2
+            slots.append(
+                PlanningSlot(
+                    interval_start=base + timedelta(minutes=15 * i),
+                    buy_price=buy,
+                    sell_price=sell,
+                    pv_a_forecast_w=1500,
+                    pv_b_forecast_w=0,
+                    load_baseline_w=3000,
+                    ev1_connected=False,
+                    ev2_connected=False,
+                    is_predicted_price=False,
+                )
+            )
+        mb = mask_battery(uc_wh=64_000.0, charge_buf=1.3)
+        soc0 = 0.22 * mb.usable_capacity_wh
+        charge = _select_charge_slots(slots, mb, soc0)
+        self.assertGreaterEqual(
+            len(charge),
+            2,
+            msg="při velkém energy_to_fill má maska vybrat více levných slotů",
+        )
+
+    def test_negative_sell_blocks_export(self) -> None:
+        base = datetime(2026, 5, 21, 10, 0, tzinfo=timezone.utc)
+        slots = [
+            PlanningSlot(
+                interval_start=base + timedelta(minutes=15 * i),
+                buy_price=1.0,
+                sell_price=-0.8 if i < 2 else 2.0,
+                pv_a_forecast_w=5000,
+                pv_b_forecast_w=0,
+                load_baseline_w=2000,
+                ev1_connected=False,
+                ev2_connected=False,
+                is_predicted_price=False,
+            )
+            for i in range(4)
+        ]
+        battery = _battery(uc_wh=40_000.0)
+        results, _ = self._solve_auto(slots, battery, 0.5 * battery.usable_capacity_wh)
+        for i in range(2):
+            self.assertGreaterEqual(results[i].grid_setpoint_w, -50)
+            self.assertNotEqual(results[i].export_mode, "PV_SURPLUS")
+
+
 if __name__ == "__main__":
     unittest.main()

db/routines/R__063_fn_load_planning_slots_full.sql

@@ -381,7 +381,7 @@ begin
 
   -- charge mask: grid arbitráž (B) před FVE (A); AM/PM rozpočet Wh zůstává 50/50.
   --
-  --   B) Grid ze sítě: spot, buy v pásmu AM/PM ≤ min(buy v pásmu)+band, lookahead VT→NT;
+  --   B) Grid ze sítě: spot, nejlevnější sloty v AM/PM do Wh rozpočtu (den plánu → před exportním oknem → buy ASC);
   --      i při pv_surplus>0; cap slotů ∝ rozpočet Wh / per_slot_charge_wh.
   --   A) PV-surplus: store_score DESC, doplní jen zbytek do energy_to_fill po vrstvě B.
   if v_charge_buf <= 0 then
@@ -400,11 +400,6 @@ begin
         select wk.slot_ord
         from _ems_plan_slot_wk wk
         where extract(hour from wk.interval_start at time zone 'Europe/Prague') < 12
-          and wk.buy_price <= v_ref_buy_am_czk_kwh + v_buy_charge_band_czk_kwh
-          and (
-            wk.buy_min_next_n is null
-            or wk.buy_price <= wk.buy_min_next_n + v_buy_lookahead_eps
-          )
         order by
           case
             when (wk.interval_start at time zone 'Europe/Prague')::date = v_plan_day_prague
@@ -439,11 +434,6 @@ begin
         select wk.slot_ord
         from _ems_plan_slot_wk wk
         where extract(hour from wk.interval_start at time zone 'Europe/Prague') >= 12
-          and wk.buy_price <= v_ref_buy_pm_czk_kwh + v_buy_charge_band_czk_kwh
-          and (
-            wk.buy_min_next_n is null
-            or wk.buy_price <= wk.buy_min_next_n + v_buy_lookahead_eps
-          )
         order by
           case
             when (wk.interval_start at time zone 'Europe/Prague')::date = v_plan_day_prague
@@ -480,6 +470,8 @@ begin
       from _ems_plan_slot_wk wk
       where wk.pv_surplus_w > 0
         and wk.sell_price >= wk.buy_price - v_degrad_czk_kwh
+        -- Držet PV na večerní peak: ne nabíjet z FVE když sell výrazně pod budoucím výkupním oknem.
+        and wk.sell_price >= wk.future_sell_lookahead - v_degrad_czk_kwh
       order by wk.store_score desc nulls last, wk.slot_ord
     loop
       exit when v_cum >= v_pv_layer_cap_wh;
@@ -671,7 +663,7 @@ $fn$;
 comment on function ems.fn_load_planning_slots_full is
   '15min sloty s cenami, forecastem, baseline a maskami proti mikro-cyklu (charge/discharge-export). '
   'Charge mask A: PV-surplus dle store_score DESC (future_sell−sell−max(0,buy−sell)); zbytek → PV export. '
-  'Charge mask B: non-PV jen spot, buy≤ref_buy+degrad, lookahead min buy v N slotech, cap 6 slotů AM/PM. '
+  'Charge mask B: spot, nejlevnější buy v AM/PM do Wh rozpočtu (priorita den plánu, před exportním oknem). '
   'ref_buy = min(buy) horizontu. Discharge-export: nejdražší sell kde sell>ref_buy+degrad (spot). '
   'Strop SoC pro výpočet energie k dobití: coalesce(planner_max_soc_percent, max_soc_percent). '
   'Denní safety vstupy: night_baseload_* (20:00–06:00 Europe/Prague), safety_soc_target_wh (6–19), '

docs/04-modules/planning-arbitrage-accounting.md

@@ -104,24 +104,20 @@ Pro **home-01** při nabíjení 11:00–14:00 za ~0,7–0,9 Kč a výprodeji 19:
 
 ---
 
-## 6. Implementace (2026-05) a backlog
+## 6. Implementace (LP-first přestavba, 2026-05)
 
-### Hotovo (jednoduchá varianta před solve)
+### Hotovo
 
-1. **`ems.fn_load_planning_slots_full`** (`R__063`): sloupce  
-   `charge_acquisition_buy_czk_kwh`, `charge_acquisition_cutoff_at`.
-2. **Vážený průměr `buy`** v `allow_charge` slotech **před** prvním `allow_discharge_export` (`cutoff`):  
-   `Σ(buy × per_slot_charge_wh) / Σ(per_slot_charge_wh)` — bez `future_sell` z odpolední FVE (jinak acquisition nafukovala večerní export).
-3. **`solve_dispatch`:** v exportních slotech (`allow_discharge_export`) přičíst k objective  
-   `+ ge_bat[t] × charge_acquisition × INTERVAL_H/1000` (náklad uložené energie), ponechat `−ge×sell`. Snapshot v `solver_params.inputs`.
-4. **FVE opportunity:** varianta **B** — lookahead `future_sell_opportunity`, ne jen `sell[t]` v odhadu PV Wh.
+1. **`ems.fn_load_planning_slots_full`** (`R__063`): grid **B** = nejlevnější sloty v AM/PM do Wh rozpočtu (bez `buy≤min+band` a lookahead gate na grid); **A** = PV jen pokud `sell ≥ future_sell_lookahead − degrad`. `charge_acquisition` z `allow_grid_charge` před 1. exportem.
+2. **`solve_dispatch` (AUTO):** objective `gi×buy − ge_pv×sell − ge_bat×sell + ge_bat×acquisition` (export bat. jen v `allow_discharge_export`). Odstraněn cross-slot guard `ge_pv ≥ surplus` / `bc=0` dle `export_refill_net`.
+3. **Guard FVE:** `ge_pv=0` jen při `sell < charge_acquisition − degrad` (ne `sell < buy` ve stejném slotu).
+4. **`solve_dispatch_two_pass`:** pass 1 → vážený `buy` z `bc`+`gi` v `allow_charge` → pass 2; volá `run_daily_plan` / `run_rolling_replan` v AUTO. Snapshot: `acquisition_pass1_czk_kwh`, `acquisition_pass2_czk_kwh`, `two_pass_enabled`.
+5. **Regrese:** `Home01RegressionTests` v `backend/tests/test_planning_dispatch_milp.py`; masky v `test_planning_charge_slot_selection.py`.
 
-### Zbývá / vylepšit
+### Co dál neřešit ad-hoc
 
-1. **Iterace po solve:** přepočítat acquisition z plánovaných `bc`+`gi` / `pv` místo odhadu z masek — viz [`docs/05-todo.md`](../05-todo.md).
-2. **Objective:** explicitní `ge_bat × (sell − acquisition − degrad)` vs současné `−ge×sell` + `+ge_bat×acquisition` (ekvivalentní jen pokud `ge_pv` v exportním slotu ≈ 0).
-3. **Masky:** více charge slotů ∝ `energy_to_fill / per_slot_wh` — viz [`planning.md`](planning.md).
-4. **Bilance / guardy:** zpřesnit, aby večerní export nebyl vázaný na falešný `gi×buy` v tomže slotu.
+- Další Python `if sell < buy` guardy — ekonomiku drží LP + acquisition + masky rozpočtu slotů.
+- Multi-period inventory model (větší projekt) — mimo tuto vlnu.
 
 ---
 
@@ -148,4 +144,4 @@ Očekávání: SoC před večerem **70–90 %** po levném pásmu; večer **expo
 
 ---
 
-*Poslední aktualizace: 2026-05 — charge_acquisition před 1. exportem + LP `ge_bat` náklad; iterace po solve v TODO.*
+*Poslední aktualizace: 2026-05 — LP-first přestavba (masky B/A, two-pass acquisition, explicitní ge_pv/ge_bat objective). Po deployi: `solver_params.inputs.two_pass_enabled` na novém `planning_run`.*

docs/04-modules/planning.md

@@ -11,11 +11,12 @@
 - **Terminal SoC shadow price:** v objective je člen `−(avg_buy_prvních_24h × planner_terminal_soc_value_factor / 1000) × soc[T−1]` (Kč), kde faktor je **`ems.asset_battery.planner_terminal_soc_value_factor`** přes **`ems.fn_planning_site_context`** (default v DB **0.9**); viz sekci *Tuning pro malé baterie* níže. Účel: konec horizontu nemusí končit zbytečně vyprázdněnou baterií (receding horizon).
 - **Masky `allow_charge` / `allow_discharge_export` (tenký anti-mikrocyklus):** generuje `ems.fn_load_planning_slots_full` (`R__063`). Ekonomiku primárně řídí LP podle efektivních cen; masky jen omezují počet slotů pro grid nabíjení / export baterie.
   - **PV-surplus (vrstva A):** ranking dle **`store_score DESC`** = `future_sell_opportunity − sell − max(0, buy−sell)`; jen sloty s `sell ≥ buy − degradation`. Kumulativní PV pokrývá `grid_target` (deficit SoC, nad `reserve_soc` bez násobení `charge_slot_buffer`). Zbytek → `allow_charge=false` (PV jen do sítě / `bc ≤ pv_surplus` v LP).
-  - **Grid ze sítě (vrstva B, před FVE):** spot, **AM/PM rozpočet Wh 50/50** z `grid_target`. Výběr: nejdřív **kalendářní den plánu** (`p_from` Prague), pak sloty před **výkupním oknem daného dne** (`sell > min(buy téhož dne)+degrad` — ne globální min zítra). Lookahead VT→NT jen před tímto oknem. **`charge_acquisition`:** vážený `buy` jen u `allow_grid_charge` (ne FVE vrstva A).
-  - **LP (AUTO):** FVE export při `sell < buy` jen pokud `(sell − min_buy_v_charge) ≥ (future_sell − acquisition) + degrad` — jinak PV do baterie na večerní peak. Viz [`planning-arbitrage-accounting.md`](planning-arbitrage-accounting.md) §2.2.
+  - **Grid ze sítě (vrstva B, před FVE):** spot, **AM/PM rozpočet Wh 50/50** z `grid_target`. Výběr: **nejlevnější `buy`** v pásmu (kalendářní den plánu → před výkupním oknem dne → `buy ASC`), bez pásma `min+0,40` a bez lookahead gate na grid B. **`charge_acquisition`:** vážený `buy` jen u `allow_grid_charge` před 1. exportem; po solve **dvouprůchodově** přepočet z `bc`+`gi` (`solve_dispatch_two_pass` v `planning_engine.py`).
+  - **PV vrstva A:** jen pokud `sell ≥ future_sell_opportunity − degradation` (držet FVE na večerní peak, ne „nabíjet z FVE“ při nízkém sell).
+  - **LP (AUTO):** objective explicitně `−ge_pv×sell − ge_bat×sell + ge_bat×acquisition` v exportních slotech; **bez** cross-slot vynucení `ge_pv ≥ surplus`. Guard FVE: `ge_pv=0` jen pokud `sell < charge_acquisition − degrad` (ne `sell < buy` ve slotu). Viz [`planning-arbitrage-accounting.md`](planning-arbitrage-accounting.md).
   - **`ref_buy_min` (brána exportu):** `min(buy_price)` horizontu — jen „existuje levný nákup?“, **ne** průměrná cena nabití přes hodiny. Export sloty: `sell > ref_buy_min + degradation` (spot). Viz [`planning-arbitrage-accounting.md`](planning-arbitrage-accounting.md).
   - Pokud `energy_to_fill <= 0` nebo `charge_slot_buffer = 0`: všechny sloty povoleny.
-- **LP ekonomické guardy** (`solve_dispatch`, AUTO): pokud `sell < buy − degradation` → `ge_pv=0` (výjimka: plná baterie, přebytek **pv_b**). Pokud `buy > min(buy)+degradation` → `gi` jen na load+EV+TČ. Viz `planning_engine.py` sekce po slot pre-selection.
+- **LP ekonomické guardy** (`solve_dispatch`, AUTO): `ge_pv=0` pokud `sell < charge_acquisition − degradation` (výjimka: plná baterie, přebytek **pv_b**). Pokud `buy > min(buy)+degradation` mimo charge masku → `gi` jen na load+EV+TČ. Viz `planning_engine.py` po slot pre-selection.
 - **Denní safety charge (měkké LP, ne maska):** `fn_load_planning_slots_full` (**V077+**) vrací navíc odhad nočního baseload Wh (20:00–06:00 Europe/Prague), buffer % z `asset_battery.planner_night_baseload_buffer_percent`, lookahead `future_*_czk_kwh`, volitelný `safety_soc_target_wh` (6–19) a flag `is_daytime_pv_surplus_slot`.\n+\n+  V solveru (`planning_engine.solve_dispatch()`):\n+  - `safety_soc_target_wh` se používá primárně jako **ochrana exportu z baterie**: v běžných slotech (mimo high‑sell špičky) se při aktivním exportu vynutí `soc[t] ≥ max(arb_base_wh, safety_soc_target_wh)`.\n+  - safety deficit penalizace v objective běží jen v `is_daytime_pv_surplus_slot` (a ne v high‑sell špičce), aby solver neměl motivaci dělat obecné „nabij co nejdřív“ chování.\n+  Tvrdé `allow_charge` se kvůli tomu nemění.
 - **Rolling charge commitment:** při `run_rolling_replan` se z aktivního plánu načtou sloty, kde dříve platilo `battery_setpoint_w > 500`, `pv_a+pv_b > load_baseline`, `grid_setpoint_w ≤ 0` a současně **není výrazný export** (`grid_setpoint_w ≥ −500`). To je záměr: commitment má kotvit „nabíjení z PV přebytku“, ne „charge while exporting“. Měkká penalizace proti snížení `bc[t]` oproti předchozímu plánu je řízená `planner_charge_commitment_penalty_czk_kwh` na `asset_battery`. Implementace: `_load_previous_plan_charge_commitment_prev_w`, volitelný argument `charge_commitment_prev_w` u `solve_dispatch()`.
 - **Debug snapshot:** každý běh ukládá JSON do `ems.planning_run.solver_params` (sekce `version`, `inputs`, `masks`, `soc_bounds`, `objective_terms`, `chosen_slots`) přes `fn_planning_run_commit` (`p_run_meta->'solver_params'`). Read-model: **`select ems.fn_planning_run_debug(<run_id>);`** (`R__087_fn_planning_run_debug.sql`).

docs/05-todo.md

@@ -26,8 +26,8 @@ Shrnutí otevřených bodů z `docs/06-open-questions.md`, checklistů v modulec
 
 | Popis | Kde | Kdo |
 |-------|-----|-----|
-| **`charge_acquisition` po solve:** druhé kolo — vážený průměr z plánovaných `bc`+`gi` a PV nabíjení místo odhadu z masek před solve; případně jedna iterace solve. Cutoff před 1. exportem už je v SQL. | `R__063_fn_load_planning_slots_full.sql`, `planning_engine.py`; [`planning-arbitrage-accounting.md`](04-modules/planning-arbitrage-accounting.md) §6 | programátor |
-| **Více levných charge slotů** v masce (N ∝ `energy_to_fill / per_slot_wh`, ne jen cap 6). | `R__063` | programátor |
+| ~~**`charge_acquisition` po solve (two-pass):**~~ hotovo — `solve_dispatch_two_pass` v `planning_engine.py` (AUTO daily/rolling). | `planning_engine.py`, [`planning-arbitrage-accounting.md`](04-modules/planning-arbitrage-accounting.md) §6 | — |
+| ~~**Grid maska B (nejlevnější sloty):**~~ hotovo — `buy ASC` v AM/PM do Wh rozpočtu; cap z `ceil(budget/per_slot_wh)`. | `R__063` | — |
 
 ---