uz sem zaoufalej

backend/services/planning_engine.py

@@ -64,11 +64,7 @@ NEG_SELL_PV_B_VENT_PENALTY_CZK_KWH = 4.0
 # Výboj baterie při sell<0 jen těsně před extrémně záporným buy (round-trip arbitráž).
 EXTREME_BUY_DUMP_PREWINDOW_SLOTS = 12
 NEG_SELL_BAT_DUMP_SHORTFALL_PENALTY_CZK_KWH = 80.0
-# Měkký tlak: v buy<0 slotech max import ze sítě do baterie (zisk z OTE záporného nákupu).
-NEG_BUY_GRID_CHARGE_SHORTFALL_PENALTY_CZK_KWH = 120.0
-# Měkký tlak: v buy<0 okně dobít na soc_max (ne zastavit na ~94 %).
-NEG_BUY_SOC_UNDERFILL_PENALTY_CZK_PER_WH = 0.45
-PLANNER_BUILD_TAG = "2026-05-27-pre-neg-buy-strategy-v19c"
+PLANNER_BUILD_TAG = "2026-05-28-revert-v19-hard-v20"
 CORRECTION_WINDOW_H  = 1        # hodina zpět pro výpočet korekčního faktoru
 CORRECTION_MIN_CLAMP = 0.5      # spodní limit korekčního faktoru
 CORRECTION_MAX_CLAMP = 1.5      # horní limit korekčního faktoru
@@ -937,41 +933,6 @@ def _evening_battery_export_push_indices(
     return sorted(out)
 
 
-def _negative_buy_slot_indices(slots: list[PlanningSlot]) -> list[int]:
-    return [t for t, s in enumerate(slots) if float(s.buy_price) < 0.0]
-
-
-def _neg_buy_soc_pressure_slots(slots: list[PlanningSlot]) -> list[int]:
-    """Tlak na soc_max jen na konci buy<0 okna (ne každý 15min slot zvlášť)."""
-    neg = _negative_buy_slot_indices(slots)
-    return [neg[-1]] if neg else []
-
-
-def _pre_neg_buy_discharge_push_indices(
-    slots: list[PlanningSlot],
-    pre_neg_buy_discharge_ts: set[int],
-    *,
-    max_slots_per_day: int = 8,
-) -> list[int]:
-    """
-    Tvrdý push ge_bat jen u nejlepších sell slotů před buy<0.
-    Jinak součet max výbojů přes celou noc může překročit SoC → Infeasible.
-    """
-    by_day: dict = {}
-    for t in pre_neg_buy_discharge_ts:
-        d = _prague_calendar_date(slots[t])
-        by_day.setdefault(d, []).append(t)
-    out: list[int] = []
-    for d in sorted(by_day.keys()):
-        ranked = sorted(
-            by_day[d],
-            key=lambda i: float(slots[i].sell_price),
-            reverse=True,
-        )
-        out.extend(ranked[:max_slots_per_day])
-    return sorted(out)
-
-
 def _planner_soc_for_solver(
     current_soc_wh: float,
     battery,
@@ -1098,13 +1059,11 @@ def solve_dispatch(
     charge_commitment_prev_w: Optional[list[Optional[float]]] = None,
     planner_version: str | None = None,
     relaxed_expensive_import: bool = False,
-    relaxed_neg_buy_pressure: bool = False,
 ) -> tuple[list[DispatchResult], int, dict[str, Any]]:
     """
     LP solver pro dispatch optimalizaci.
     Vrátí (výsledky, solver_duration_ms, solver_debug_snapshot).
     relaxed_expensive_import: nouzový režim po Infeasible — síť smí krmit baseload v drahých slotech.
-    relaxed_neg_buy_pressure: vypne měkké v19 shortfall (pre-neg export, neg-buy soc/grid).
     """
     T = len(slots)
     if T < 1:
@@ -1226,7 +1185,6 @@ def solve_dispatch(
     om = (operating_mode or "AUTO").strip().upper()
     charge_slots: set[int] = set()
     discharge_export_slots: set[int] = set()
-    pre_neg_buy_discharge_ts: set[int] = set()
     if om == "AUTO":
         charge_slots = {t for t, s in enumerate(slots) if s.allow_charge}
         charge_slots |= {
@@ -1248,26 +1206,6 @@ def solve_dispatch(
         discharge_export_slots = {
             t for t, s in enumerate(slots) if s.allow_discharge_export
         }
-        # Vybití baterie před `buy<0` oknem: pokud je v horizontu buy<0, můžeme baterii
-        # vybít teď za `sell` a v buy<0 okně ji nabít za záporný buy (= příjem).
-        _neg_buy_for_disch = next(
-            (t for t, s in enumerate(slots) if float(s.buy_price) < 0), None
-        )
-        if _neg_buy_for_disch is not None and _neg_buy_for_disch > 0:
-            _neg_buy_prices = [
-                float(slots[t].buy_price)
-                for t in range(_neg_buy_for_disch, T)
-                if float(slots[t].buy_price) < 0
-            ]
-            _avg_neg_buy = sum(_neg_buy_prices) / len(_neg_buy_prices) if _neg_buy_prices else 0.0
-            _disch_sell_thr = max(_avg_neg_buy + float(degradation_cost_effective), 0.1)
-            for t in range(_neg_buy_for_disch):
-                st = slots[t]
-                if float(st.sell_price) < _disch_sell_thr:
-                    continue
-                # Jen kladný sell (sell<0 + z_export by vynutilo ge_bat≥1 zároveň s ge_bat=0).
-                if float(st.sell_price) >= 1.0:
-                    pre_neg_buy_discharge_ts.add(t)
     # SELF_SUSTAIN dřív vynucoval ge[t] == 0, což umí udělat MILP infeasible v okamžiku, kdy:
     # - baterie je na max SoC (nelze nabíjet),
     # - PV pole B není curtailable,
@@ -1445,9 +1383,6 @@ def solve_dispatch(
     pv_charge_shortfall: list[tuple[int, pulp.LpVariable, float]] = []
     neg_sell_bat_dump_shortfall: list[tuple[int, pulp.LpVariable, float]] = []
     neg_sell_soc_underfill: list[tuple[int, pulp.LpVariable]] = []
-    neg_buy_soc_underfill: list[tuple[int, pulp.LpVariable]] = []
-    neg_buy_grid_shortfall: list[tuple[int, pulp.LpVariable, float]] = []
-    pre_neg_buy_export_shortfall: list[tuple[int, pulp.LpVariable, float]] = []
     fixed_tariff_like = fixed_tariff_like_pre
     block_export_neg_sell = bool(getattr(grid, "block_export_on_negative_sell", False))
     if om == "AUTO":
@@ -1499,17 +1434,11 @@ def solve_dispatch(
             cap_w = float(min(pv_surplus_w, battery.max_charge_power_w))
             sf_pv = pulp.LpVariable(f"post_neg_pv_shortfall_{t}", 0, cap_w)
             pv_charge_shortfall.append((t, sf_pv, cap_w))
-        _neg_buy_idx_soc = next(
-            (t for t, s in enumerate(slots) if float(s.buy_price) < 0), None
-        )
         for t in range(T):
             if float(slots[t].sell_price) >= 0:
                 continue
             if t not in charge_slots:
                 continue
-            # Před buy<0 nehonit soc_max — kapacitu šetříme na záporný nákup.
-            if _neg_buy_idx_soc is not None and t < _neg_buy_idx_soc:
-                continue
             pv_surplus_w = max(
                 0.0,
                 float(slots[t].pv_a_forecast_w)
@@ -1524,35 +1453,6 @@ def solve_dispatch(
                 float(battery.usable_capacity_wh),
             )
             neg_sell_soc_underfill.append((t, us))
-        if not relaxed_neg_buy_pressure:
-            for t in _neg_buy_soc_pressure_slots(slots):
-                us_buy = pulp.LpVariable(
-                    f"neg_buy_soc_under_{t}",
-                    0,
-                    float(battery.usable_capacity_wh),
-                )
-                neg_buy_soc_underfill.append((t, us_buy))
-            for t in range(T):
-                if float(slots[t].buy_price) >= 0:
-                    continue
-                headroom_wh = float(battery.soc_max_wh) - float(soc_panel_min[t])
-                if headroom_wh < 500.0:
-                    continue
-                cap_gi = float(
-                    min(
-                        battery.max_charge_power_w,
-                        grid.max_import_power_w,
-                        headroom_wh / max(INTERVAL_H * battery.charge_efficiency, 1e-6),
-                    )
-                )
-                if cap_gi < 500.0:
-                    continue
-                sf_gi = pulp.LpVariable(f"neg_buy_gi_shortfall_{t}", 0, cap_gi)
-                neg_buy_grid_shortfall.append((t, sf_gi, cap_gi))
-            for t in pre_neg_buy_discharge_ts:
-                cap_pre = float(_battery_export_cap_w(battery, grid))
-                sf_pre = pulp.LpVariable(f"preneg_buy_disch_sf_{t}", 0, cap_pre)
-                pre_neg_buy_export_shortfall.append((t, sf_pre, cap_pre))
         for t in neg_sell_bat_dump_slots:
             dump_target_w = _battery_export_cap_w(battery, grid)
             sf_dump = pulp.LpVariable(f"neg_bat_dump_shortfall_{t}", 0, dump_target_w)
@@ -1662,18 +1562,6 @@ def solve_dispatch(
             us * NEG_SELL_SOC_UNDERFILL_PENALTY_CZK_PER_WH
             for _t, us in neg_sell_soc_underfill
         )
-        + pulp.lpSum(
-            us * NEG_BUY_SOC_UNDERFILL_PENALTY_CZK_PER_WH
-            for _t, us in neg_buy_soc_underfill
-        )
-        + pulp.lpSum(
-            sf * NEG_BUY_GRID_CHARGE_SHORTFALL_PENALTY_CZK_KWH * INTERVAL_H / 1000.0
-            for _t, sf, _cap in neg_buy_grid_shortfall
-        )
-        + pulp.lpSum(
-            sf * PEAK_EXPORT_SHORTFALL_PENALTY_CZK_KWH * INTERVAL_H / 1000.0
-            for _t, sf, _cap in pre_neg_buy_export_shortfall
-        )
         + pulp.lpSum(
             sf * NEG_SELL_BAT_DUMP_SHORTFALL_PENALTY_CZK_KWH * INTERVAL_H / 1000.0
             for _t, sf, _cap in neg_sell_bat_dump_shortfall
@@ -1683,10 +1571,6 @@ def solve_dispatch(
             for t in range(T)
             if t in discharge_export_slots and t in profitable_export_ts_pre
         )
-        + pulp.lpSum(
-            -35.0 * z_export[t]
-            for t in pre_neg_buy_discharge_ts
-        )
     )
 
     # --- Omezení ---
@@ -1698,12 +1582,6 @@ def solve_dispatch(
         prob += sf >= cap_w - ge_bat[t_sf]
     for t_us, us in neg_sell_soc_underfill:
         prob += us >= float(battery.soc_max_wh) - soc[t_us]
-    for t_us, us in neg_buy_soc_underfill:
-        prob += us >= float(battery.soc_max_wh) - soc[t_us]
-    for t_sf, sf, cap_w in neg_buy_grid_shortfall:
-        prob += sf >= cap_w - bc_gi[t_sf]
-    for t_sf, sf, cap_w in pre_neg_buy_export_shortfall:
-        prob += sf >= cap_w - ge_bat[t_sf]
     preneg_export_min_soc_wh = float(min_soc_wh) + max(
         float(battery.max_discharge_power_w)
         * float(battery.discharge_efficiency)
@@ -1727,7 +1605,6 @@ def solve_dispatch(
                 if t_peak not in discharge_export_slots:
                     continue
                 prob += ge_bat[t_peak] >= export_push_w * z_export[t_peak]
-        # Pre-neg-buy: jen shortfall (tvrdý push by kolidoval s kotvou SoC v krátkých testech).
         # Ostatní profitable sloty: shortfall penalizace (ne tvrdý push na celý horizont).
     if t_anchor is not None and soc_anchor_slack is not None:
         target_floor_wh = float(planner_floor_effective_wh)
@@ -1853,7 +1730,7 @@ def solve_dispatch(
             block_neg_sell_export_t = bool(
                 getattr(grid, "block_export_on_negative_sell", False)
             )
-            if t not in neg_sell_bat_dump_slots and t not in pre_neg_buy_discharge_ts:
+            if t not in neg_sell_bat_dump_slots:
                 prob += ge_bat[t] == 0
             ev_cap_neg = sum(
                 float(vehicles[e].max_charge_power_w)
@@ -1959,12 +1836,6 @@ def solve_dispatch(
         # Bez hluboké relaxace: export končí ≥ rezerva. Při hluboké relaxaci (soc_panel_min pod min_soc)
         # sladit s LP spodkem — jinak z_export vynutil arb_base a blokoval vývoz k planner floor.
         if (
-            om == "AUTO"
-            and t in pre_neg_buy_discharge_ts
-            and floor_pct is not None
-        ):
-            export_soc_floor_t = float(planner_floor_effective_wh)
-        elif (
             om == "AUTO"
             and first_neg_sell_idx is not None
             and t < first_neg_sell_idx
@@ -1995,7 +1866,6 @@ def solve_dispatch(
                 tgt_s is not None
                 and not high_sell_slot[t]
                 and t not in profitable_export_ts_pre
-                and t not in pre_neg_buy_discharge_ts
                 and not (
                     om == "AUTO"
                     and t in discharge_export_slots
@@ -2042,16 +1912,6 @@ def solve_dispatch(
             prob += bd[t] == 0
 
     # Slot pre-selection (z DB fn_load_planning_slots_full → allow_*)
-    # PŘED prvním buy<0 slotem v horizontu (= rezervační okno):
-    # - sell ≥ 0 → bc_pv = 0 (PV poteče do gridu / curtail, baterka se nenabíjí z PV
-    #   protože v buy<0 okně bude akvizice levnější — záporná).
-    # - sell < 0 → slot je v charge_slots (R__063), bc_pv ≤ pv_surplus (= nemůžeme
-    #   pole A vyhodit do mínusu, raději nabít baterii).
-    # JINDY (po buy<0 okně, nebo žádné buy<0 v horizontu): původní permissive
-    # bc_pv ≤ pv_surplus aby nedošlo k regresi normálních dnů.
-    _neg_buy_idx_main = next(
-        (t for t, s in enumerate(slots) if float(s.buy_price) < 0), None
-    )
     if om == "AUTO":
         for t in range(T):
             s = slots[t]
@@ -2062,12 +1922,6 @@ def solve_dispatch(
                 + int(s.pv_b_forecast_w)
                 - int(s.load_baseline_w),
             )
-            # Grid→bat (bc_gi): R__063 dává allow_charge=true ze dvou různých důvodů:
-            # (a) ekonomicky výhodný grid charge slot (nízký buy, výhodná arbitráž),
-            # (b) sell<0 + pv_surplus (= "povolit PV nabíjení aby pole A nešlo do mínusu").
-            # V druhém případě bc_gi NESMÍ být povoleno (home-01 run 16652: 09:15–09:45
-            # nabíjelo 18 kW ze sítě za buy 1,1–1,2 Kč jen proto, že sell=−0,2).
-            # Druhý případ poznáme přes `sell<0 + pv_surplus>0`.
             if (
                 t in charge_slots
                 and sell_t_pre < 0
@@ -2075,34 +1929,20 @@ def solve_dispatch(
                 and float(s.buy_price) >= 0.0
             ):
                 prob += bc_gi[t] == 0
+            if t not in charge_slots:
                 pv_surplus_w = max(
                     0,
                     int(s.pv_a_forecast_w)
                     + int(s.pv_b_forecast_w)
                     - int(s.load_baseline_w),
                 )
-            in_pre_neg_buy_window = (
-                _neg_buy_idx_main is not None and t < _neg_buy_idx_main
-            )
-            if (
-                in_pre_neg_buy_window
-                and t in charge_slots
-                and float(s.sell_price) < 0.0
-            ):
-                # sell<0+PV charge_slots před buy<0: neplnit z PV A (kapacita pro import).
-                prob += bc_pv[t] == 0
-            elif t not in charge_slots:
                 if float(s.buy_price) >= 0.0:
                     prob += bc_gi[t] == 0
                 if pv_surplus_w <= 0:
                     prob += bc_pv[t] == 0
                 else:
                     prob += bc_pv[t] <= float(pv_surplus_w)
-            if (
-                t not in discharge_export_slots
-                and t not in neg_sell_bat_dump_slots
-                and t not in pre_neg_buy_discharge_ts
-            ):
+            if t not in discharge_export_slots and t not in neg_sell_bat_dump_slots:
                 prob += ge_bat[t] == 0
                 prob += z_export[t] == 0
 
@@ -2285,28 +2125,6 @@ def solve_dispatch(
                 charge_commitment_prev_w=charge_commitment_prev_w,
                 planner_version=planner_version,
                 relaxed_expensive_import=True,
-                relaxed_neg_buy_pressure=relaxed_neg_buy_pressure,
-            )
-        if not relaxed_neg_buy_pressure:
-            logger.warning(
-                "solve_dispatch Infeasible, retry with relaxed_neg_buy_pressure "
-                "(skip v19 soft shortfalls)"
-            )
-            return 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,
-                relaxed_expensive_import=True,
-                relaxed_neg_buy_pressure=True,
             )
         raise RuntimeError(f"Solver: {pulp.LpStatus[status]}")
 
@@ -2538,7 +2356,6 @@ def solve_dispatch(
             },
             "load_first_enabled": om == "AUTO",
             "relaxed_expensive_import": relaxed_expensive_import,
-            "relaxed_neg_buy_pressure": relaxed_neg_buy_pressure,
             "charge_acquisition_buy_czk_kwh": charge_acquisition_czk_kwh,
             "charge_acquisition_cutoff_at": (
                 slots[0].charge_acquisition_cutoff_at.isoformat()

backend/tests/test_planning_dispatch_milp.py

@@ -1230,7 +1230,7 @@ class NegativeSellPvChargeTests(unittest.TestCase):
             50.0,
             operating_mode="AUTO",
         )
-        self.assertEqual(snap.get("planner_build_tag"), "2026-05-27-pre-neg-buy-strategy-v19c")
+        self.assertEqual(snap.get("planner_build_tag"), "2026-05-28-revert-v19-hard-v20")
         self.assertGreater(
             results[0].battery_setpoint_w,
             5_500,
@@ -1380,7 +1380,7 @@ class NegativeSellPvChargeTests(unittest.TestCase):
             50.0,
             operating_mode="AUTO",
         )
-        self.assertEqual(snap.get("planner_build_tag"), "2026-05-27-pre-neg-buy-strategy-v19c")
+        self.assertEqual(snap.get("planner_build_tag"), "2026-05-28-revert-v19-hard-v20")
         self.assertEqual(len(results), len(slots))
 
     def test_gen_cutoff_full_soc_neg_sell_with_pv_b_feasible(self) -> None:
@@ -1444,7 +1444,7 @@ class NegativeSellPvChargeTests(unittest.TestCase):
             55.0,
             operating_mode="AUTO",
         )
-        self.assertEqual(snap.get("planner_build_tag"), "2026-05-27-pre-neg-buy-strategy-v19c")
+        self.assertEqual(snap.get("planner_build_tag"), "2026-05-28-revert-v19-hard-v20")
         self.assertEqual(len(results), len(slots))
 
     def test_fixed_tariff_neg_sell_no_grid_export(self) -> None:

docs/04-modules/planning.md

@@ -45,7 +45,7 @@
     1. **Globální rozpočet Wh** (`discharge_slot_buffer × exportovatelná kapacita`): sloty podle `sell_price desc`. Před prvním `sell < 0` se z rozpočtu **vynechají** sloty, kde **později tentýž den** existuje `sell` vyšší o více než `degradation` (OTE, ne pevné hodiny 00–04).
     2. **Večerní špičky per den:** `sell ≥ max(sell) − degradation` jen pro hodiny **≥ 17** (Prague), ne globální max horizontu (jinak by vyhrála půlnoc 3,7 Kč místo večera).
     3. **Ranní pásmo před prvním `sell < 0`:** hodiny **5–11** téhož kalendářního dne — všechny sloty s `sell ≥ lokální_max_ráno − degradation`; ostatní sloty mezi ranním pásmem a prvním `sell < 0` s nižším sell mají export **zakázán** (žádný dump v 07:30 za 2 Kč). **`charge_acquisition`:** vážený `buy` před prvním exportem **téhož dne** jako záporné výkupní okno.
-    **Před oknem `buy < 0` (tag v19c, `solve_dispatch`):** sloty se **`sell < 0` + PV** v `charge_slots` mají **`bc_pv = 0`** (kapacita pro import); noční výboj přes **`pre_neg_buy_discharge_ts`** (`sell ≥ 1` nebo SQL `allow_discharge_export`) + shortfall **`ge_bat`** — **bez** přidání do **`discharge_export_slots`** (jinak Infeasible: `bd` k loadu). **`neg_sell_soc_underfill`** jen od **`first_neg_buy_idx`**; v **`buy < 0`** **`neg_buy_soc_underfill`** + **`neg_buy_grid_shortfall`**. Viz changelog v19/v19b.
+    **Planner tag v20:** revert experimentálních v19 Python constraintů (opakované Infeasible na home-01). Aktivní **v17** (`bc_gi=0` při sell&lt;0+PV+buy≥0, `ge_pv≤pv_b`) a **v18** (export push z DB limitů). Strategie před `buy<0` / noční výboj patří do **`R__063`** (`allow_*` masky), ne tvrdých LP — viz changelog v20.
     V `solve_dispatch` (AUTO): **`charge_slots`** = `allow_charge` z DB + **`buy < 0`** + všechny sloty **`sell < 0`** s PV přebytkem > 500 W (i bez `block_export_on_negative_sell`, BA81). **`pv_charge_shortfall`** / **`NEG_SELL_CURTAIL_PENALTY`** platí v těchto slotech. Při **`sell < 0`**: safety deficit cílí **`soc_max_wh`** (plný planner strop). Po posledním **`sell < 0`** tentýž den: **`post_neg_pv_topup`** dobije z FVE na `soc_max` před exportem (kladný sell, ne high-sell peak). U **fixního tarifu** s polem B: **`ge_pv ≤ pv_b`** (ne pv_store **`ge_pv = 0`**). Při **`deye_gen_microinverter_cutoff_enabled`**: **`ge == 0` jen** pokud **`block_export_on_negative_sell`** (KV1), ne kvůli samotnému `z_gen_cutoff` (BA81 musí moci exportovat B při plné baterii). Vstupní **`soc_wh`** z telemetrie se před MILP omezí přes **`_planner_soc_for_solver`** (rezerva ~650 Wh pod `soc_max`, jinak Infeasible při 100 % SoC a dlouhém záporném výkupu). **`planner_build_tag`** v `solver_params`. Changelog: [`docs/planning-changelog.md`](../planning-changelog.md).
 - **Záporná nákupní cena:**
   - horní mez `grid_import` zahrnuje `load_baseline_w` + nabíjení/EV/TČ (bez nekonečného importu).

docs/05-todo.md

@@ -29,7 +29,7 @@ Shrnutí otevřených bodů z `docs/06-open-questions.md`, checklistů v modulec
 | ~~**`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` | — |
 | **Self-konzistentní filtr B + acquisition bez `buy<0`:** iterativní filtr v `R__063` (v12); vážená acquisition pro filtr i `charge_acquisition_buy_czk_kwh` jen z `allow_grid_charge` s `buy>=0` (záporný OTE buy zůstává `allow_charge`, ale neřítí exportní marži). Two-pass `_recompute_charge_acquisition_from_results` také přeskočí `buy<0`. Ověřit po deploy: `two_pass_converged=true` na home-01. | `R__063`, `planning_engine.py` | programátor |
-| **Strategie buy&lt;0 / sell&lt;0 (home-01):** v19c — Infeasible fix (soc jen poslední buy&lt;0 slot). Deploy + replan, tag `…-v19c`. | `planning_engine.py`, `docs/planning-changelog.md` v19c | programátor |
+| **Strategie buy&lt;0 (home-01):** v20 revert v19 hard constraintů; další krok = SQL `R__063` + ověření MCP před Python LP. | `R__063`, `planning_engine.py` v20 | programátor |
 | **KV1 replan timeout (~120 s):** ruční/rolling replan občas spadne na timeout; 5. pokus prošel. Profilovat `fn_load_planning_slots_full` (iterativní filtr) + MILP délku horizontu; případně zkrátit horizont pro test nebo zvýšit limit API. | backend replan endpoint, APScheduler | programátor |
 | **home-01 export při `sell<0` (26 slotů):** záměrně **ne** `block_export_on_negative_sell` (neriditelné PV B + zelený bonus). Plán stále může dávat `PV_SURPLUS` ~6–7 kW od ~10:30 když je SoC ~97 %+ — jiná osa než noční grid 4,8 Kč. Review ventilu `w_pv_b_vent_neg` / nabíjení před exportem, ne stejný fix jako KV1. | `planning_engine.py`, `planning-arbitrage-accounting.md` | programátor |
 

docs/planning-changelog.md

@@ -5,6 +5,22 @@ Formát: **datum (ISO)** · stručný důvod · soubory · chování / ověřen
 
 ---
 
+## 2026-05-28 — revert tvrdých v19 constraintů (v20)
+
+**Problém:** v19–v19c opakovaně **Solver: Infeasible** na home-01 (ověřeno proti MCP run 16674 — `buy<0` od 11:00, ne 13:00). Vrstvené Python patch bez reprodukce na živých slotech.
+
+**Rozhodnutí:** **Revert** celé v19 Python vrstvy (pre-neg discharge, `bc_pv=0` před buy&lt;0, neg-buy shortfall). Zůstává stabilní základ:
+- **v17:** `bc_gi=0` při sell&lt;0+PV+buy≥0; `ge_pv ≤ pv_b` při sell&lt;0
+- **v18:** večerní export push z DB `min(discharge, export)` W
+
+Strategie před buy&lt;0 / import v buy&lt;0 patří do **SQL `R__063`** (masky `allow_*`), ne dalších tvrdých LP constraintů — až po feasibilitě na MCP datech.
+
+**Tag:** `2026-05-28-revert-v19-hard-v20`
+
+**Diagnostika:** `scripts/diagnose_home01_infeasible.py` + fixture z MCP `planning_interval` run 16674.
+
+---
+
 ## 2026-05-27 (k) — Infeasible: soc na každém buy&lt;0 slotu + sell&lt;0 v pre-neg (v19c)
 
 **Problém:** (1) **`neg_buy_soc_underfill`** na **každém** `buy<0` slotu vyžadoval `soc = soc_max` každých 15 min — při startu pod max fyzicky nemožné. (2) **`pre_neg_buy_discharge_ts`** mohlo zahrnout `sell<0` + `allow_discharge_export` → **`ge_bat=0`** (sell&lt;0) vs **`z_export` → ge_bat≥1** → Infeasible.

scripts/diagnose_home01_infeasible.py

@@ -0,0 +1,121 @@
+#!/usr/bin/env python3
+"""Bisect Infeasible na reálných slotech home-01 (MCP run 16674). PYTHONPATH=backend."""
+from __future__ import annotations
+
+import json
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+from types import SimpleNamespace
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "backend"))
+
+from services.planning_engine import PlanningSlot, solve_dispatch, solve_dispatch_two_pass, PLANNER_BUILD_TAG
+
+# Export z MCP: planning_interval run_id=16674 + fn_planning_site_context(2)
+SLOTS_JSON = Path(__file__).with_name("home01_run16674_slots.json")
+SOC_WH = 37120.0
+
+
+def _ctx() -> tuple[SimpleNamespace, SimpleNamespace, SimpleNamespace, list]:
+    battery = SimpleNamespace(
+        usable_capacity_wh=64000.0,
+        min_soc_wh=6400.0,
+        arb_floor_wh=12800.0,
+        reserve_soc_wh=12800.0,
+        soc_max_wh=64000.0,
+        charge_efficiency=0.95,
+        discharge_efficiency=0.95,
+        degradation_cost_czk_kwh=0.15,
+        max_charge_power_w=18000,
+        max_discharge_power_w=18000,
+        charge_slot_buffer=1.3,
+        discharge_slot_buffer=1.5,
+        planner_terminal_soc_value_factor=0.9,
+        planner_discharge_floor_percent=5.0,
+        planner_extreme_buy_threshold_czk_kwh=-2.0,
+        planner_daytime_charge_target_enabled=True,
+        planner_charge_commitment_penalty_czk_kwh=0.2,
+        planner_night_baseload_buffer_percent=20,
+    )
+    grid = SimpleNamespace(
+        max_import_power_w=17000,
+        max_export_power_w=13500,
+        block_export_on_negative_sell=False,
+        deye_gen_microinverter_cutoff_enabled=False,
+    )
+    hp = SimpleNamespace(rated_heating_power_w=0, tuv_min_temp_c=45.0, tuv_target_temp_c=55.0)
+    vehicles = [
+        SimpleNamespace(max_charge_power_w=11000, battery_capacity_kwh=75.0, default_target_soc_pct=80.0),
+        SimpleNamespace(max_charge_power_w=7400, battery_capacity_kwh=52.0, default_target_soc_pct=90.0),
+    ]
+    return battery, hp, grid, vehicles
+
+
+def load_slots(*, permissive_masks: bool) -> list[PlanningSlot]:
+    rows = json.loads(SLOTS_JSON.read_text())
+    out: list[PlanningSlot] = []
+    for r in rows:
+        ts = datetime.fromisoformat(r["interval_start"].replace("Z", "+00:00"))
+        pv_surplus = max(0, int(r["pv_a"]) + int(r["pv_b"]) - int(r["load"]))
+        out.append(
+            PlanningSlot(
+                interval_start=ts,
+                buy_price=float(r["buy"]),
+                sell_price=float(r["sell"]),
+                pv_a_forecast_w=int(r["pv_a"]),
+                pv_b_forecast_w=int(r["pv_b"]),
+                load_baseline_w=int(r["load"]),
+                ev1_connected=False,
+                ev2_connected=False,
+                allow_charge=True if permissive_masks else (float(r["buy"]) < 0 or (float(r["sell"]) < 0 and pv_surplus > 500)),
+                allow_discharge_export=permissive_masks,
+            )
+        )
+    return out
+
+
+def try_solve(label: str, slots: list[PlanningSlot], **kwargs) -> str:
+    battery, hp, grid, vehicles = _ctx()
+    try:
+        if kwargs.pop("two_pass", False):
+            solve_dispatch_two_pass(
+                slots, battery, hp, grid, [None, None], vehicles, SOC_WH, 55.0,
+                operating_mode="AUTO", **kwargs,
+            )
+        else:
+            solve_dispatch(
+                slots, battery, hp, grid, [None, None], vehicles, SOC_WH, 55.0,
+                operating_mode="AUTO", **kwargs,
+            )
+        return f"OK  {label}"
+    except Exception as e:
+        return f"FAIL {label}: {e}"
+
+
+def main() -> None:
+    if not SLOTS_JSON.exists():
+        print(f"Chybí {SLOTS_JSON} — spusť export z MCP (run 16674).", file=sys.stderr)
+        sys.exit(1)
+
+    print("tag", PLANNER_BUILD_TAG)
+    print("slots", len(json.loads(SLOTS_JSON.read_text())))
+    neg_buy = [r for r in json.loads(SLOTS_JSON.read_text()) if r["buy"] < 0]
+    print("neg_buy slots", len(neg_buy), "first", neg_buy[0]["interval_start"] if neg_buy else None)
+
+    cases = [
+        ("permissive masks, 1-pass", dict(permissive_masks=True, two_pass=False)),
+        ("permissive masks, 2-pass", dict(permissive_masks=True, two_pass=True)),
+        ("realistic masks, 1-pass", dict(permissive_masks=False, two_pass=False)),
+        ("realistic masks, 2-pass", dict(permissive_masks=False, two_pass=True)),
+        ("realistic + relaxed_expensive", dict(permissive_masks=False, two_pass=False, relaxed_expensive_import=True)),
+        ("realistic + both relaxed", dict(permissive_masks=False, two_pass=False, relaxed_expensive_import=True, relaxed_neg_buy_pressure=True)),
+    ]
+    for label, kw in cases:
+        masks = kw.pop("permissive_masks")
+        slots = load_slots(permissive_masks=masks)
+        print(try_solve(label, slots, **kw))
+
+
+if __name__ == "__main__":
+    main()

scripts/home01_run16674_slots.json

@@ -0,0 +1 @@
+[{"interval_start":"2026-05-24T23:45:00.000Z","buy":4.766958,"sell":2.9315,"load":579,"pv_a":0,"pv_b":0},{"interval_start":"2026-05-25T11:00:00.000Z","buy":-0.070392,"sell":-0.8225,"load":858,"pv_a":6306,"pv_b":7397},{"interval_start":"2026-05-25T12:00:00.000Z","buy":-0.337409,"sell":-1.065,"load":6267,"pv_a":5870,"pv_b":6971}]