Merge pull request 'refactor-control-monolith' (#5) from refactor-control-monolith into main

Reviewed-on: #5

.cursor/plans/planner-battery-tuning_ae42fae3.plan.md

@@ -0,0 +1,279 @@
+---
+name: planner-battery-tuning
+overview: Opravíme nesoulad mezi plánem a zápisem do Deye při nabíjení z FVE přebytku, doplníme SQL-first vstupy pro denní safety charge, aplikujeme je v LP jako soft penalty a uložíme debug snapshot každého běhu planneru.
+todos:
+  - id: fix-deye-passive-charge
+    content: Opravit Deye PASSIVE překlad tak, aby plánované nabíjení z FVE přebytku nezapsalo reg108=0.
+    status: completed
+  - id: add-planner-debug-snapshot
+    content: Ukládat ke každému planning_run kompaktní debug JSON do solver_params se sekcemi inputs, masks, soc_bounds, objective_terms a chosen_slots.
+    status: pending
+  - id: prevent-charge-deferral
+    content: Doplnit near-term commitment / soft target před drahým sell oknem, aby rolling replan neodkládal nabíjení bez ekonomické náhrady.
+    status: pending
+  - id: add-daytime-safety-charge
+    content: Spočítat safety-charge vstupy v SQL, předat je do LP a aplikovat jako měkkou penalizaci deficitu proti noční energii.
+    status: pending
+  - id: add-regression-test
+    content: Přidat regresní testy pro PV surplus charge + současný net export a pro neodkládání nabíjení při receding horizon.
+    status: completed
+  - id: tune-small-site-terminal-soc
+    content: Po debug ověření upravit parametry BA81/KV1 cíleně; nezačínat slepým přepsáním `planner_terminal_soc_value_factor` na 0.9.
+    status: cancelled
+  - id: update-docs
+    content: Aktualizovat dokumentaci control/planning a ověřovací MCP dotazy.
+    status: completed
+  - id: verify
+    content: Spustit testy/validaci a sepsat očekávané MCP ověření po deployi.
+    status: completed
+isProject: false
+---
+
+# Stabilizace plánovače baterie
+
+## Cíl
+Opravit tři související problémy:
+
+- Plán někdy chce nabíjet baterii z PV přebytku, ale Deye dostane `reg108 = 0`, takže fyzicky nenabíjí.
+- Rolling replan umí posouvat plánované nabíjení dál a dál, až levné PV okno uteče.
+- Malé baterie BA81/KV1 potřebují robustní denní nabití pro noc, ale zároveň nesmí ztratit schopnost ekonomicky cyklovat a prodávat v opravdu drahých sell oknech.
+
+## Datové zjištění
+- `BA81` = site `3`, `KV1` = site `4`, `home-01` = site `2`.
+- KV1 run `8101` pro slot 17:15 plánoval `battery_setpoint_w = 4737` W, `grid_setpoint_w = -13` W, `deye_physical_mode = PASSIVE`; `modbus_command` následně zapsal a ověřil Deye `register = 108`, `value_to_write = 0`. To je konkrétní bug v control exportu.
+- BA81 historie rolling runů ukazuje posun prvního charge slotu s časem. To je částečně normální receding-horizon efekt, ale nesmí prodat levný PV přebytek, který je potřeba pro pozdější sell peak nebo noční baseload.
+- `planner_terminal_soc_value_factor` není jediné řešení. BA81/KV1 mají `0.2`, home-01 má `0.9`; nezvyšovat BA81/KV1 plošně na `0.9`, protože to může vrátit starou neochotu malé baterie cyklovat.
+
+## Architektonické rozhodnutí
+- SQL-first zůstává: výpočet vstupů pro planner patří do SQL funkcí / view.
+- Safety charge nesmí být hard `allow_charge` maska. SQL má spočítat vstupní hodnoty, LP je použije jako soft penalty v objective.
+- Debug snapshot ukládat do existujícího `ems.planning_run.solver_params`. Samostatnou tabulku nezavádět v první iteraci.
+- Hodnota energie v baterii není jedna konstanta: `battery_value = max(future_avoided_buy, future_sell_opportunity) - degradation`, plus samostatný měkký noční buffer.
+
+## Implementace
+
+### 1. Oprava Deye exportéru
+Soubory:
+- [`backend/services/control/inverter.py`](backend/services/control/inverter.py)
+- [`backend/services/control/setpoints.py`](backend/services/control/setpoints.py)
+
+Požadované chování:
+- Pokud `ControlSetpoints.battery_w > 0`, Deye musí dostat nenulový nabíjecí proud podle `battery_w`, i když `grid_setpoint_w < 0`.
+- V tomto scénáři zůstává `deye_physical_mode = PASSIVE`, pokud plán explicitně neurčí `CHARGE`. Nejde o grid-charge režim; jde o nabíjení z PV přebytku a současný export zbytku.
+- `discharge_a` v tomto scénáři nastavit na `0` nebo jinak omezit tak, aby Deye současně nevybíjel baterii.
+- Existující SELL a PRESERVE chování neměnit.
+
+Konkrétní místo:
+- V `write_inverter_setpoints()` je problém v PASSIVE větvi, která přes `_deye_zero_export_amps_for_passive()` vrací `charge_a = 0`, když `grid_w < 0` a `bat_w >= 0`.
+- Přidej před tuto větev explicitní případ `bat_w > 0`: `charge_a = battery_watts_to_amps(bat_w, inv.max_charge_a)`, `discharge_a = 0`.
+
+### 2. SQL vstupy pro daytime safety charge
+Soubory:
+- [`db/routines/R__063_fn_load_planning_slots_full.sql`](db/routines/R__063_fn_load_planning_slots_full.sql)
+- případně nová repeatable funkce v [`db/routines`](db/routines)
+
+Neimplementovat jako hard masku. Nezakazovat / nepovolovat sloty natvrdo jen kvůli safety charge.
+
+Doplnit SQL výstupy, které Python LP použije:
+- `night_baseload_target_wh`: kolik Wh je potřeba od večera do dalšího ranního PV okna.
+- `night_baseload_buffer_wh`: bezpečnostní přirážka, např. procento z cíle.
+- `safety_soc_target_wh`: doporučený SoC cíl pro slot.
+- `future_avoided_buy_czk_kwh`: odhad ceny, kterou baterie ušetří, pokud energii necháme pro vlastní spotřebu.
+- `future_sell_opportunity_czk_kwh`: nejlepší relevantní budoucí sell příležitost v horizontu.
+- `is_daytime_pv_surplus_slot`: pomocný boolean pro debug a vážení cíle.
+
+Preferovaný způsob:
+- Rozšířit `ems.fn_load_planning_slots_full(...)`, protože už je hlavní zdroj slotových vstupů pro `_load_slots()`.
+- Pokud by rozšíření funkce bylo příliš velké, vytvořit samostatnou `ems.fn_planning_safety_charge_inputs(site_id, from, to, current_soc_wh)` a joinovat podle `interval_start` v SQL/Pythonu.
+
+Výpočet nočního okna:
+- Praktická první verze: noc = od lokálního západu / večerního konce PV surplus do dalšího rána, zjednodušeně `20:00-06:00 Europe/Prague`.
+- Přesnější verze později: od posledního dnešního slotu s významným PV forecastem do prvního zítřejšího slotu s významným PV forecastem.
+- Pro první implementaci stačí konzervativní a čitelná definice, hlavně ji uložit do debug snapshotu.
+
+### 3. Rozšíření Python datových tříd a načítání slotů
+Soubor:
+- [`backend/services/planning_engine.py`](backend/services/planning_engine.py)
+
+Upravit `PlanningSlot`:
+- Přidat volitelná pole pro SQL safety vstupy:
+  - `safety_soc_target_wh: float | None`
+  - `night_baseload_target_wh: float | None`
+  - `night_baseload_buffer_wh: float | None`
+  - `future_avoided_buy_czk_kwh: float | None`
+  - `future_sell_opportunity_czk_kwh: float | None`
+  - `is_daytime_pv_surplus_slot: bool = False`
+
+Upravit `_load_slots()`:
+- Načíst nové sloupce ze SQL.
+- Pokud SQL sloupce dočasně nejsou k dispozici, použít bezpečný fallback `None` / `False`, aby testy starších DB funkcí nespadly.
+- Nepočítat noční baseload ad-hoc v Pythonu, pokud už SQL funkce hodnotu vrací.
+
+### 4. LP objective: soft safety target
+Soubor:
+- [`backend/services/planning_engine.py`](backend/services/planning_engine.py)
+
+Přidat do `solve_dispatch()`:
+- Pro každý slot `t` s `safety_soc_target_wh is not None` vytvořit spojitou proměnnou `safety_deficit_wh[t] >= 0`.
+- Přidat omezení:
+  - `safety_deficit_wh[t] >= safety_soc_target_wh[t] - soc[t]`
+- Přidat do objective penalizaci:
+  - `safety_deficit_wh[t] * safety_penalty_czk_per_wh[t]`
+
+Výpočet penalty:
+- `battery_value_czk_kwh = max(future_avoided_buy_czk_kwh, future_sell_opportunity_czk_kwh) - degradation_cost_effective`
+- `safety_penalty_czk_per_wh = max(0, battery_value_czk_kwh) / 1000`
+- Přidat rozumný clamp, aby penalty nebyla extrémní kvůli vadné ceně.
+
+Chování:
+- Pokud je vysoký sell peak ekonomicky lepší než držet energii pro noc, LP smí target porušit a prodat.
+- Pokud je budoucí nákup drahý, typicky KV1, deficit bude drahý a LP bude energii spíš držet pro vlastní spotřebu.
+- Toto není hard constraint.
+
+### 5. Near-term commitment proti deferralu
+Soubory:
+- [`backend/services/planning_engine.py`](backend/services/planning_engine.py)
+- DB čtení z `ems.planning_run` / `ems.planning_interval` přes SQL funkci nebo jednoduchý read model
+
+Cíl:
+- Rolling replan nesmí bez náhrady odsunout nejbližší plánované nabíjení z PV přebytku, pokud předchozí aktivní plán pro stejný nebo nejbližší slot chtěl nabíjet.
+
+První jednoduchá implementace:
+- Při rolling replanu načíst předchozí aktivní plán pro stejné `site_id`.
+- Najít nejbližší 1-2 sloty od `replan_from`, kde předchozí plán měl:
+  - `battery_setpoint_w > 500`
+  - `pv_a_forecast_solver_w + pv_b_forecast_solver_w > load_baseline_w`
+  - ideálně `grid_setpoint_w <= 0`
+- V novém LP pro odpovídající slot přidat soft proměnnou `charge_commitment_shortfall_w[t] >= previous_battery_charge_w - bc[t]`.
+- Penalizace má být malá, ale nenulová: má zabránit bezdůvodnému odsunu, ne přebít skutečně lepší ekonomiku.
+- Uložit do debug snapshotu, kdy commitment vznikl a kolik stál.
+
+Neimplementovat jako hard constraint.
+
+### 6. Debug snapshot do solver_params
+Soubory:
+- [`backend/services/planning_engine.py`](backend/services/planning_engine.py)
+- [`db/routines/R__037_fn_planning_run_commit.sql`](db/routines/R__037_fn_planning_run_commit.sql)
+
+Upravit `_save_planning_run()`:
+- Rozšířit `run_meta` o `solver_params`.
+- `solver_params` bude JSON serializovatelný dict.
+
+Upravit `ems.fn_planning_run_commit(...)`:
+- Při insertu do `ems.planning_run` uložit `solver_params = p_run_meta->'solver_params'`.
+
+Minimální struktura JSON:
+
+```json
+{
+  "version": 1,
+  "inputs": {
+    "current_soc_wh": 0,
+    "operating_mode": "AUTO",
+    "battery": {
+      "usable_capacity_wh": 0,
+      "min_soc_wh": 0,
+      "reserve_soc_wh": 0,
+      "degradation_cost_czk_kwh": 0,
+      "planner_terminal_soc_value_factor": 0.2
+    }
+  },
+  "masks": [
+    {
+      "slot": "2026-05-04T15:45:00+00:00",
+      "allow_charge": true,
+      "allow_discharge_export": false
+    }
+  ],
+  "soc_bounds": [
+    {
+      "slot": "2026-05-04T15:45:00+00:00",
+      "soc_min_wh": 0,
+      "arb_floor_wh": 0,
+      "soc_panel_min_wh": 0,
+      "safety_soc_target_wh": 0
+    }
+  ],
+  "objective_terms": [
+    {
+      "slot": "2026-05-04T15:45:00+00:00",
+      "buy_price": 0,
+      "sell_price": 0,
+      "future_avoided_buy_czk_kwh": 0,
+      "future_sell_opportunity_czk_kwh": 0,
+      "battery_value_czk_kwh": 0,
+      "safety_deficit_penalty_czk_per_wh": 0,
+      "commitment_penalty_czk_per_w": 0
+    }
+  ],
+  "chosen_slots": {
+    "charge_commitment": [],
+    "high_sell_windows": [],
+    "night_window": {
+      "start": "2026-05-04T18:00:00+00:00",
+      "end": "2026-05-05T04:00:00+00:00",
+      "target_wh": 0
+    }
+  }
+}
+```
+
+### 7. Debug read model
+Soubor:
+- nová repeatable funkce v [`db/routines`](db/routines), např. `R__086_fn_planning_run_debug.sql`
+
+Vytvořit `ems.fn_planning_run_debug(p_run_id int)`:
+- Vrátí jeden `jsonb`.
+- Obsahuje:
+  - metadata z `planning_run`,
+  - `solver_params`,
+  - intervaly z `planning_interval` pro daný run,
+  - krátký souhrn: první charge slot, první battery export slot, nejdražší sell sloty, největší safety deficit.
+
+Použití přes MCP:
+
+```sql
+select ems.fn_planning_run_debug(8107);
+```
+
+### 8. Parametry
+Nepřepisovat plošně BA81/KV1 na `planner_terminal_soc_value_factor = 0.9`.
+
+Nové parametry preferovaně v `ems.asset_battery` přes novou migraci:
+- `planner_daytime_charge_target_enabled boolean default true`
+- `planner_night_baseload_buffer_percent numeric default 20`
+- `planner_daytime_charge_price_quantile numeric default 0.70`
+- `planner_charge_commitment_penalty_czk_kwh numeric default 0.20`
+
+Pokud je rozsah příliš velký, první iterace může mít konzervativní konstanty v Pythonu, ale plánovaná cílová podoba je DB parametrizace.
+
+### 9. Testy
+Najít existující testovací styl v repu a přidat testy co nejblíže dotčeným modulům.
+
+Povinné scénáře:
+- Control exporter: `battery_w > 0`, `grid_setpoint_w < 0`, `deye_physical_mode = PASSIVE` vede na `reg108 > 0`, `reg109 = 0`.
+- Control exporter: SELL režim se nezmění.
+- Planner safety: malá baterie, PV surplus přes den, noční baseload, pozdější drahý sell slot. LP má nabíjet v rozumně levném PV slotu a neodsunout charge donekonečna.
+- Planner economics: pokud `sell_now` převyšuje budoucí avoided buy plus degradaci, LP smí porušit safety target a prodat.
+- Planner economics KV1-like: pokud budoucí buy je drahý a sell není dost vysoký, LP má držet energii pro vlastní spotřebu.
+
+### 10. Dokumentace
+Aktualizovat:
+- [`docs/04-modules/control.md`](docs/04-modules/control.md)
+- [`docs/04-modules/planning.md`](docs/04-modules/planning.md)
+
+Dokumentace musí popsat:
+- rozdíl mezi plánem, Deye fyzickým režimem a registry `108/109`,
+- PV-surplus charging při současném exportu,
+- `solver_params` debug snapshot a `fn_planning_run_debug`,
+- rozdíl mezi hard maskami (`allow_charge`, `allow_discharge_export`) a soft LP penalizacemi,
+- že `planner_terminal_soc_value_factor` není jediný mechanismus ochrany malé baterie.
+
+## Ověření
+- Spustit backend testy pro control a planner.
+- Spustit Flyway validate lokálně.
+- Přes MCP ověřit po nasazení:
+  - pro BA81/KV1 sloty s `battery_setpoint_w > 0` a `grid_setpoint_w < 0` má následný `modbus_command.register = 108` hodnotu > 0,
+  - `planning_run.solver_params` není `NULL` a obsahuje `inputs`, `masks`, `soc_bounds`, `objective_terms`, `chosen_slots`,
+  - `select ems.fn_planning_run_debug(<run_id>)` vrací vysvětlitelný JSON,
+  - rolling replan neodkládá nabíjení z levného PV přebytku bez viditelného ekonomického důvodu v debug snapshotu.

backend/services/control/__init__.py

@@ -1,3 +1,3 @@
-"""Deye / Modbus control export (monolith v exporter_monolith.py – postupný split)."""
+"""Deye / Modbus control export modules."""
 
 from .exporter_monolith import *  # noqa: F401,F403

backend/services/control/deye_helpers.py

@@ -0,0 +1,233 @@
+"""Čisté Deye konstanty a helpery pro control export."""
+
+from __future__ import annotations
+
+from datetime import datetime, timedelta, timezone
+from zoneinfo import ZoneInfo
+
+from services.control.models import InverterConfig
+
+PRAGUE_TZ = ZoneInfo("Europe/Prague")
+
+# Hodiny Deye 62-64: po zápisu sekundy na zařízení dál běží, verify musí být toleranční.
+DEYE_CLOCK_VERIFY_MAX_DELTA_SEC = 120
+# Řidší zápis: bez zápisu, pokud čas na invertoru neodbočí od Prahy víc než o tolik sekund.
+DEYE_CLOCK_DRIFT_OK_SEC = 60
+# A zároveň neuplynul tento interval od posledního syncu / potvrzení driftu.
+DEYE_CLOCK_RESYNC_INTERVAL_HOURS = 24
+
+# Deye LV baterie: převod výkon -> proud pro registry 108/109.
+BATT_VOLTAGE_V = 51.2
+
+# Reg 178 - bitové pole: bity 4-5 (peak shaving switch) a bity 0-1 (MI export cutoff).
+REG178_SELL = 0b00100000
+REG178_PASSIVE = 0b00110000
+REG178_VERIFY_MASK = 0x0030
+REG178_MI_EXPORT_MASK = 0x0003
+REG178_MI_EXPORT_DISABLE = 0b10
+REG178_MI_EXPORT_ENABLE = 0b11
+REG178_VERIFY_MASK_COMBINED = REG178_VERIFY_MASK | REG178_MI_EXPORT_MASK
+
+DEYE_CRITICAL_REGS_SELF_SUSTAIN = frozenset({108, 109, 142, 143, 145})
+DEYE_TOU_POWER_REGS = frozenset(range(154, 160))
+DEYE_LV_BATTERY_MAX_CHARGE_DISCHARGE_A = 350
+
+# Neaktivní TOU bloky (3-6): Deye často 23:59 (2359) neuloží, 23:55 je stabilní.
+DEYE_TOU_INACTIVE_HHMM = 2355
+
+_DEYE_INACTIVE_TOU_REGISTERS: frozenset[int] = frozenset(
+    [
+        150,
+        151,
+        152,
+        153,
+        156,
+        157,
+        158,
+        159,
+        168,
+        169,
+        170,
+        171,
+        174,
+        175,
+        176,
+        177,
+    ]
+)
+
+DEYE_CLOCK_REGS: frozenset[int] = frozenset({62, 63, 64})
+
+DEYE_REGISTER_NAMES: dict[int, str] = {
+    108: "max_charge_a (max nabíjecí proud baterie)",
+    109: "max_discharge_a (max vybíjecí proud baterie)",
+    141: "energy_mode (0, EMS nemění)",
+    142: "limit_control (0=selling first, 1=zero export to load, 2=zero export to CT)",
+    143: "export_limit_w (max export do sítě)",
+    145: "solar_sell (0=disabled, 1=enabled)",
+    340: "max_solar_power_w (strop DC PV A v W; součet nominal_power_wp řiditelných polí)",
+    178: "control_board_special_1 (bits0-1: MI export cutoff disable=2 enable=3; bits4-5 peak shaving 32/48)",
+    148: "time_point_1_time",
+    149: "time_point_2_time",
+    154: "time_point_1_power_w",
+    155: "time_point_2_power_w",
+    166: "time_point_1_soc_min_pct",
+    167: "time_point_2_soc_min_pct",
+    172: "time_point_1_grid_charge",
+    173: "time_point_2_grid_charge",
+    62: "system_time_year_month",
+    63: "system_time_day_hour",
+    64: "system_time_min_sec",
+}
+for _tp_i in range(6):
+    _n = _tp_i + 1
+    DEYE_REGISTER_NAMES.setdefault(148 + _tp_i, f"time_point_{_n}_time")
+    DEYE_REGISTER_NAMES.setdefault(154 + _tp_i, f"time_point_{_n}_power_w")
+    DEYE_REGISTER_NAMES.setdefault(166 + _tp_i, f"time_point_{_n}_soc_min_pct")
+    DEYE_REGISTER_NAMES.setdefault(172 + _tp_i, f"time_point_{_n}_grid_charge")
+
+
+def _deye_reg178_verify_match(expected_i: int, actual_i: int) -> bool:
+    return (int(expected_i) & REG178_VERIFY_MASK_COMBINED) == (
+        int(actual_i) & REG178_VERIFY_MASK_COMBINED
+    )
+
+
+def deye_reg_triggers_self_sustain_after_verify_exhaust(reg: int) -> bool:
+    """True = po 3x mismatch přepnout lokalitu do SELF_SUSTAIN (kritický registr)."""
+    return int(reg) in DEYE_CRITICAL_REGS_SELF_SUSTAIN
+
+
+def _deye_tou_power_verify_match(
+    expected_i: int, actual_i: int, inv: InverterConfig
+) -> bool:
+    """Firmware často clampne TOU power W na max z reg. 108/109 x 51.2 V."""
+    if int(actual_i) == int(expected_i):
+        return True
+    max_w_charge = int(inv.max_charge_a * BATT_VOLTAGE_V)
+    max_w_discharge = int(inv.max_discharge_a * BATT_VOLTAGE_V)
+    a = int(actual_i)
+    return a == max_w_charge or a == max_w_discharge
+
+
+def _deye_reg178_verify_with_double_read(
+    expected_i: int, actual_first: int, actual_second: int | None
+) -> tuple[bool, int]:
+    """
+    Vrátí (shoda, hodnota_pro_journal).
+    Druhé čtení použít jen když první neprojde maskou (RS485 / glitch).
+    """
+    if _deye_reg178_verify_match(expected_i, actual_first):
+        return True, actual_first
+    if actual_second is not None and _deye_reg178_verify_match(expected_i, actual_second):
+        return True, int(actual_second)
+    return False, actual_first
+
+
+def watts_to_amps(power_w: int | None, phases: int = 3, voltage: int = 230) -> int:
+    if not power_w or power_w <= 0:
+        return 0
+    return min(32, max(0, int(power_w / (phases * voltage))))
+
+
+def battery_watts_to_amps(power_w: int, max_amps: int) -> int:
+    """Proud z |výkonu| baterie; max_amps z DB."""
+    derived = int(abs(power_w) / BATT_VOLTAGE_V)
+    return min(max(0, max_amps), max(0, derived))
+
+
+def current_slot_hhmm() -> int:
+    """Začátek probíhajícího 15min slotu v Europe/Prague, formát HHMM."""
+    now = datetime.now(PRAGUE_TZ)
+    slot_min = (now.minute // 15) * 15
+    return now.hour * 100 + slot_min
+
+
+def next_slot_hhmm() -> int:
+    """Začátek příštího 15min slotu v Europe/Prague, formát HHMM."""
+    now = datetime.now(PRAGUE_TZ)
+    minutes = now.minute
+    slot_minutes = ((minutes // 15) + 1) * 15
+    if slot_minutes >= 60:
+        next_hour = (now.hour + 1) % 24
+        next_min = 0
+    else:
+        next_hour = now.hour
+        next_min = slot_minutes
+    return next_hour * 100 + next_min
+
+
+def compute_pv_a_reg340_max_solar_w(cap_w: int, forecast_w: int, curtail_w: int) -> int:
+    """Hodnota pro Deye reg 340 (max solar power, W) z capu a plánovaného curtailmentu pole A."""
+    if curtail_w <= 0:
+        return int(cap_w)
+    return max(0, min(int(cap_w), int(forecast_w) - int(curtail_w)))
+
+
+def _prague_minute_start_utc() -> datetime:
+    """UTC okamžik odpovídající začátku aktuální kalendářní minuty v Europe/Prague."""
+    p = datetime.now(PRAGUE_TZ).replace(second=0, microsecond=0)
+    return p.astimezone(timezone.utc)
+
+
+def _deye_registers_to_prague_datetime(r62: int, r63: int, r64: int) -> datetime | None:
+    """Dekódování reg 62-64 (Deye system time v Europe/Prague)."""
+    try:
+        year = (int(r62) >> 8) + 2000
+        month = int(r62) & 0xFF
+        day = int(r63) >> 8
+        hour = int(r63) & 0xFF
+        minute = int(r64) >> 8
+        second = int(r64) & 0xFF
+        if not (1 <= month <= 12 and 1 <= day <= 31 and 0 <= hour <= 23):
+            return None
+        if not (0 <= minute <= 59 and 0 <= second <= 59):
+            return None
+        return datetime(year, month, day, hour, minute, second, tzinfo=PRAGUE_TZ)
+    except (ValueError, OverflowError):
+        return None
+
+
+def _deye_clock_registers_verify_match(
+    w62: int,
+    w63: int,
+    w64: int,
+    a62: int,
+    a63: int,
+    a64: int,
+) -> bool:
+    w_dt = _deye_registers_to_prague_datetime(w62, w63, w64)
+    a_dt = _deye_registers_to_prague_datetime(a62, a63, a64)
+    if w_dt is None or a_dt is None:
+        return False
+    return abs((a_dt - w_dt).total_seconds()) <= DEYE_CLOCK_VERIFY_MAX_DELTA_SEC
+
+
+def _deye_should_skip_time_sync_after_read(
+    inv: InverterConfig,
+    r62: int,
+    r63: int,
+    r64: int,
+) -> bool:
+    """
+    True = nezařazovat zápis 62-64: drift je malý a od posledního úspěšného zápisu
+    nebo tolerančního ověření neuplynulo 24h.
+    """
+    dev = _deye_registers_to_prague_datetime(r62, r63, r64)
+    if dev is None:
+        return False
+    wall = datetime.now(PRAGUE_TZ)
+    drift = abs((wall - dev).total_seconds())
+    if drift > DEYE_CLOCK_DRIFT_OK_SEC:
+        return False
+    last_write = inv.deye_last_system_time_sync_at
+    if last_write is None:
+        return False
+    if last_write.tzinfo is None:
+        last_write = last_write.replace(tzinfo=timezone.utc)
+    else:
+        last_write = last_write.astimezone(timezone.utc)
+    age = datetime.now(timezone.utc) - last_write
+    if age >= timedelta(hours=DEYE_CLOCK_RESYNC_INTERVAL_HOURS):
+        return False
+    return True

backend/services/control/inverter.py

@@ -0,0 +1,361 @@
+"""Deye inverter writer and live register reader."""
+
+from __future__ import annotations
+
+import logging
+from datetime import datetime, timezone
+from typing import Any
+
+import asyncpg
+
+from services.control.deye_helpers import (
+    BATT_VOLTAGE_V,
+    DEYE_CLOCK_DRIFT_OK_SEC,
+    DEYE_CLOCK_REGS,
+    DEYE_CLOCK_RESYNC_INTERVAL_HOURS,
+    DEYE_TOU_INACTIVE_HHMM,
+    PRAGUE_TZ,
+    REG178_MI_EXPORT_DISABLE,
+    REG178_MI_EXPORT_ENABLE,
+    REG178_MI_EXPORT_MASK,
+    REG178_PASSIVE,
+    REG178_SELL,
+    REG178_VERIFY_MASK,
+    REG178_VERIFY_MASK_COMBINED,
+    _DEYE_INACTIVE_TOU_REGISTERS,
+    _deye_should_skip_time_sync_after_read,
+    _prague_minute_start_utc,
+    current_slot_hhmm,
+    next_slot_hhmm,
+)
+from services.control.modbus_journal import (
+    _drop_registers_matching_last_verified,
+    _fetch_last_verified_inverter_registers,
+    create_modbus_commands,
+    execute_modbus_commands,
+)
+from services.control.models import ControlSetpoints
+from services.control.repository import _get_current_soc, _load_inverter_config
+from services.control.setpoints import (
+    _deye_reg143_export_w,
+    _deye_system_time_register_rows,
+    _deye_time_point_rows,
+    _deye_tou_min_soc_pct,
+    _deye_tou_params,
+    _deye_tou_reserve_soc_pct,
+    deye_battery_charge_discharge_amps,
+    get_deye_mode,
+)
+from services.modbus_client import get_modbus_client
+
+logger = logging.getLogger(__name__)
+
+
+async def write_inverter_setpoints(
+    site_id: int,
+    setpoints_now: ControlSetpoints,
+    setpoints_next: ControlSetpoints | None,
+    db: asyncpg.Connection,
+    planning_run_id: int | None = None,
+) -> str:
+    inv = await _load_inverter_config(site_id, db)
+    if inv is None:
+        return "FAIL inverter: no controllable Modbus endpoint"
+
+    unit_id = int(inv.unit_id if inv.unit_id is not None else 1)
+    raw_bat = setpoints_now.battery_w
+    grid_w = int(setpoints_now.grid_setpoint_w or 0)
+    no_export = inv.no_export
+    export_lim = _deye_reg143_export_w(no_export, inv.max_export_power_w)
+    max_batt_w_discharge = int(inv.max_discharge_a * BATT_VOLTAGE_V)
+    tp_discharge_w = 0 if setpoints_now.lock_battery else max_batt_w_discharge
+    tou_min_pct = _deye_tou_min_soc_pct(inv)
+    tou_reserve_pct = _deye_tou_reserve_soc_pct(inv)
+
+    try:
+        soc_telemetry = await _get_current_soc(site_id, db)
+        deye_mode = get_deye_mode(setpoints_now)
+
+        bat_w = int(raw_bat) if raw_bat is not None else 0
+        charge_a, discharge_a = deye_battery_charge_discharge_amps(
+            lock_battery=setpoints_now.lock_battery,
+            deye_mode=deye_mode,
+            self_sustain_local_use=setpoints_now.self_sustain_local_use,
+            bat_w=bat_w,
+            grid_w=grid_w,
+            max_charge_a=int(inv.max_charge_a),
+            max_discharge_a=int(inv.max_discharge_a),
+        )
+
+        zero_exp_mode = int(inv.deye_zero_export_mode or 1)
+        selling_mode = 0 if deye_mode == "SELL" else zero_exp_mode
+        solar_sell = 0 if (setpoints_now.export_ban and deye_mode != "SELL") else 1
+        export_limit = export_lim
+        reg178_val = REG178_SELL if deye_mode == "SELL" else REG178_PASSIVE
+
+        logger.info(
+            f"[control] site={site_id} fyzický režim Deye: {deye_mode} | "
+            f"battery_w={raw_bat!r} grid_w={grid_w} | "
+            f"charge_a={charge_a} discharge_a={discharge_a} | "
+            f"reg142={selling_mode} reg145={solar_sell} reg143={export_limit}W reg178={reg178_val}"
+        )
+
+        now_cet, time_rows = _deye_system_time_register_rows()
+        skip_time = False
+        try:
+            mb_clock = await get_modbus_client(inv.host, inv.port)
+            tvals = await mb_clock.read_holding_registers(
+                62, 3, int(inv.unit_id if inv.unit_id is not None else 1)
+            )
+            if len(tvals) == 3:
+                skip_time = _deye_should_skip_time_sync_after_read(
+                    inv, int(tvals[0]), int(tvals[1]), int(tvals[2])
+                )
+            else:
+                logger.warning(
+                    "Deye clock read: expected 3 registers, got %s; will sync 62-64",
+                    len(tvals),
+                )
+        except Exception as e:
+            logger.warning("Deye clock read failed (will sync 62-64): %s", e)
+
+        if skip_time:
+            logger.info(
+                "Deye clock 62-64 skipped (drift <= %ss, last sync < %sh ago): %s CET",
+                DEYE_CLOCK_DRIFT_OK_SEC,
+                DEYE_CLOCK_RESYNC_INTERVAL_HOURS,
+                now_cet.strftime("%Y-%m-%d %H:%M:%S"),
+            )
+        else:
+            logger.info("Deye time will sync: %s CET", now_cet.strftime("%Y-%m-%d %H:%M:%S"))
+
+        registers: list[tuple[int, str, int]] = [] if skip_time else list(time_rows)
+
+        sp_tp2 = setpoints_next if setpoints_next is not None else setpoints_now
+        hh_cur = current_slot_hhmm()
+        hh_nxt = next_slot_hhmm()
+        p1, s1, g1 = _deye_tou_params(setpoints_now, inv)
+        p2, s2, g2 = _deye_tou_params(sp_tp2, inv)
+        registers.extend(_deye_time_point_rows(0, hh_cur, p1, s1, g1))
+        registers.extend(_deye_time_point_rows(1, hh_nxt, p2, s2, g2))
+
+        prague_date = datetime.now(PRAGUE_TZ).date()
+        inactive_sig = (
+            f"{DEYE_TOU_INACTIVE_HHMM}|{tou_min_pct}|{tou_reserve_pct}|{tp_discharge_w}"
+        )
+        need_inactive_tou = (
+            inv.deye_last_tou_inactive_write_prague_date != prague_date
+            or inv.deye_tou_inactive_signature != inactive_sig
+        )
+        if need_inactive_tou:
+            for idx in range(2, 6):
+                registers.extend(
+                    _deye_time_point_rows(
+                        idx, DEYE_TOU_INACTIVE_HHMM, tp_discharge_w, tou_min_pct, False
+                    )
+                )
+        else:
+            logger.debug(
+                "Deye TOU rows 3-6 skipped (already written today, signature unchanged)"
+            )
+
+        registers.extend(
+            [
+                (108, "", charge_a),
+                (109, "", discharge_a),
+                (141, "energy_mode (0)", 0),
+                (142, "limit_control", selling_mode),
+                (143, "", export_limit),
+                (145, "solar_sell", solar_sell),
+            ]
+        )
+
+        if (
+            bool(inv.deye_reg340_pv_a_control_enabled)
+            and int(inv.pv_a_cap_w) > 0
+            and setpoints_now.pv_a_allowed_w is not None
+        ):
+            registers.append((340, "max_solar_power_w", int(setpoints_now.pv_a_allowed_w)))
+
+        try:
+            mb178 = await get_modbus_client(inv.host, inv.port)
+            r178 = await mb178.read_holding_registers(178, 1, unit_id)
+            if not r178 or len(r178) < 1:
+                raise OSError(f"reg178 read returned {len(r178) if r178 is not None else None} values")
+            current_178 = int(r178[0])
+            peak_bits = int(reg178_val) & int(REG178_VERIFY_MASK)
+            if inv.deye_gen_microinverter_cutoff_enabled:
+                want_cutoff = bool(setpoints_now.deye_gen_cutoff_enabled) and deye_mode != "SELL"
+                mi_bits = REG178_MI_EXPORT_ENABLE if want_cutoff else REG178_MI_EXPORT_DISABLE
+            else:
+                mi_bits = int(current_178) & int(REG178_MI_EXPORT_MASK)
+
+            new_178 = (
+                (int(current_178) & ~int(REG178_VERIFY_MASK_COMBINED))
+                | int(peak_bits)
+                | int(mi_bits)
+            )
+            registers.append((178, "control_board_special_1", int(new_178)))
+            logger.info(
+                "[control] %s: reg178 (control_board_special_1) old=%s new=%s peak_bits=0x%04X mi_bits=%s",
+                inv.code,
+                current_178,
+                new_178,
+                int(peak_bits),
+                int(mi_bits),
+            )
+        except Exception as e:
+            logger.warning("[control] %s: reg178 RMW failed (skip reg178 write): %s", inv.code, e)
+
+        logger.info(
+            "[control] %s: deye_mode=%s charge=%sA discharge=%sA "
+            "reg142=%s reg145=%s export=%sW "
+            "tp1=%s tp2=%s soc=%s%% (batt=%r grid=%sW)",
+            inv.code,
+            deye_mode,
+            charge_a,
+            discharge_a,
+            selling_mode,
+            solar_sell,
+            export_limit,
+            hh_cur,
+            hh_nxt,
+            soc_telemetry,
+            raw_bat,
+            grid_w,
+        )
+
+        last_verified = await _fetch_last_verified_inverter_registers(site_id, inv.id, db)
+        registers, skipped_unchanged = _drop_registers_matching_last_verified(
+            registers, last_verified
+        )
+        if skipped_unchanged:
+            logger.info(
+                "[control] %s: skip %s registers (value equals last verified): %s",
+                inv.code,
+                len(skipped_unchanged),
+                skipped_unchanged[:24],
+            )
+        if not registers:
+            logger.info(
+                "[control] %s: all Deye holding regs match last verified, no Modbus write",
+                inv.code,
+            )
+            if need_inactive_tou:
+                await db.execute(
+                    """
+                    UPDATE ems.asset_inverter
+                    SET deye_last_tou_inactive_write_prague_date = $1,
+                        deye_tou_inactive_signature = $2
+                    WHERE id = $3
+                    """,
+                    prague_date,
+                    inactive_sig,
+                    inv.id,
+                )
+            return (
+                f"OK inverter: batt_w={raw_bat!r} (no changes vs last verified Modbus snapshot)"
+            )
+
+        will_write_inactive = any(
+            int(r) in _DEYE_INACTIVE_TOU_REGISTERS for r, _, _ in registers
+        )
+
+        cmd_ids = await create_modbus_commands(
+            site_id,
+            planning_run_id,
+            "inverter",
+            inv.id,
+            inv.code,
+            inv.host,
+            inv.port,
+            inv.unit_id,
+            registers,
+            db,
+            deye_physical_mode=deye_mode,
+        )
+        if not await execute_modbus_commands(cmd_ids, db):
+            return f"FAIL inverter: {inv.code}: Modbus write failed (see modbus_command)"
+        logger.info("[control] Inverter %s journal write OK", inv.code)
+
+        will_write_time = any(int(r) in DEYE_CLOCK_REGS for r, _, _ in registers)
+        if will_write_time:
+            await db.execute(
+                """
+                UPDATE ems.asset_inverter
+                SET deye_last_system_time_sync_minute = $1,
+                    deye_last_system_time_sync_at = now()
+                WHERE id = $2
+                """,
+                _prague_minute_start_utc(),
+                inv.id,
+            )
+
+        if need_inactive_tou or will_write_inactive:
+            await db.execute(
+                """
+                UPDATE ems.asset_inverter
+                SET deye_last_tou_inactive_write_prague_date = $1,
+                    deye_tou_inactive_signature = $2
+                WHERE id = $3
+                """,
+                prague_date,
+                inactive_sig,
+                inv.id,
+            )
+    except Exception as e:
+        return f"FAIL inverter: {inv.code}: {e}"
+
+    return (
+        f"OK inverter: batt_w={raw_bat!r} "
+        f"(time points + FC 0x10: 108/109/141/142/178/143/145/340 dle plánu)"
+    )
+
+
+async def read_deye_registers_live(site_id: int, db: asyncpg.Connection) -> dict[str, Any]:
+    """
+    Živé čtení holding registrů Deye 108, 109, 141-145, 178, 191 a volitelně 340.
+    """
+    inv = await _load_inverter_config(site_id, db)
+    if inv is None:
+        raise ValueError("no controllable Modbus inverter for site")
+
+    uid = int(inv.unit_id)
+    client = await get_modbus_client(inv.host, inv.port)
+    read_at = datetime.now(timezone.utc)
+    try:
+        async with client.batch(uid) as mb:
+            b108 = await mb.read_holding_registers(108, 2)
+            b141 = await mb.read_holding_registers(141, 5)
+            r178 = await mb.read_holding_registers(178, 1)
+            r191 = await mb.read_holding_registers(191, 1)
+            if inv.deye_reg340_pv_a_control_enabled:
+                r340 = await mb.read_holding_registers(340, 1)
+            else:
+                r340 = None
+        r108, r109 = b108[0], b108[1]
+        r141, r142, r143 = b141[0], b141[1], b141[2]
+        r145 = b141[4]
+        r178 = r178[0]
+        r191 = r191[0]
+        r340v = int(r340[0]) if r340 is not None and len(r340) >= 1 else None
+    except Exception:
+        logger.exception("read_deye_registers_live site=%s failed", site_id)
+        raise
+
+    return {
+        "reg108_charge_a": int(r108),
+        "reg109_discharge_a": int(r109),
+        "reg141_energy_mode": int(r141),
+        "reg142_limit_control": int(r142),
+        "reg143_export_limit_w": int(r143),
+        "reg145_solar_sell": int(r145),
+        "reg178_peak_shaving_switch": int(r178),
+        "reg178_control_board_special_1": int(r178),
+        "reg178_mi_export_cutoff_bits": int(r178) & int(REG178_MI_EXPORT_MASK),
+        "reg178_mi_export_cutoff_is_on": (int(r178) & int(REG178_MI_EXPORT_MASK))
+        == int(REG178_MI_EXPORT_ENABLE),
+        "reg191_peak_shaving_w": int(r191),
+        "reg340_max_solar_power_w": r340v,
+        "read_at": read_at.isoformat(),
+    }

backend/services/control/modbus_journal.py

@@ -0,0 +1,243 @@
+"""Modbus command journal helpers pro control export."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+from collections import defaultdict
+
+import asyncpg
+
+from services.control.deye_helpers import DEYE_REGISTER_NAMES, _deye_reg178_verify_match
+from services.modbus_client import get_modbus_client
+
+logger = logging.getLogger(__name__)
+
+
+async def _fetch_written_deye_clock_commands(
+    site_id: int,
+    asset_id: int,
+    host: str,
+    port: int,
+    unit_id: int,
+    db: asyncpg.Connection,
+) -> list[asyncpg.Record]:
+    """Všechny řádky journalu 62-64 ve stavu written pro daný invertor/endpoint."""
+    rows = await db.fetch(
+        """
+        SELECT * FROM ems.modbus_command
+        WHERE site_id = $1
+          AND asset_type = 'inverter'
+          AND asset_id = $2
+          AND device_host = $3
+          AND device_port = $4
+          AND device_unit_id = $5
+          AND register IN (62, 63, 64)
+          AND status = 'written'
+        ORDER BY register
+        """,
+        site_id,
+        asset_id,
+        host,
+        port,
+        unit_id,
+    )
+    return list(rows)
+
+
+async def _fetch_last_verified_inverter_registers(
+    site_id: int, inverter_asset_id: int, db: asyncpg.Connection
+) -> dict[int, int]:
+    """
+    Poslední hodnota na zařízení podle journalu (jen status verified).
+    Slouží k přeskočení duplicitního zápisu stejné hodnoty.
+    """
+    raw = await db.fetchval(
+        """
+        select ems.fn_modbus_last_verified_map($1::int, $2::int)
+        """,
+        site_id,
+        inverter_asset_id,
+    )
+    data = raw if isinstance(raw, dict) else json.loads(raw)
+    return {int(k): int(v) for k, v in data.items()}
+
+
+def _drop_registers_matching_last_verified(
+    registers: list[tuple[int, str, int]],
+    last_verified: dict[int, int],
+) -> tuple[list[tuple[int, str, int]], list[int]]:
+    """Vynechá položky s hodnotou shodnou s posledním ověřeným stavem."""
+    out: list[tuple[int, str, int]] = []
+    skipped: list[int] = []
+    for reg, meta, val in registers:
+        lv = last_verified.get(int(reg))
+        if lv is not None:
+            if int(reg) == 178 and _deye_reg178_verify_match(int(val), int(lv)):
+                skipped.append(int(reg))
+                continue
+            if int(lv) == int(val):
+                skipped.append(int(reg))
+                continue
+        out.append((reg, meta, val))
+    return out, skipped
+
+
+async def create_modbus_commands(
+    site_id: int,
+    planning_run_id: int | None,
+    asset_type: str,
+    asset_id: int,
+    asset_code: str,
+    host: str,
+    port: int,
+    unit_id: int,
+    registers: list[tuple[int, str, int]],
+    db: asyncpg.Connection,
+    deye_physical_mode: str | None = None,
+) -> list[int]:
+    """
+    Vytvoří záznamy v modbus_command pro sadu zápisů.
+    Vrátí list command IDs.
+    """
+    ids: list[int] = []
+    for reg, _ignored_name, val in registers:
+        register_name = DEYE_REGISTER_NAMES.get(reg, f"reg_{reg}")
+        cmd_id = await db.fetchval(
+            """
+            INSERT INTO ems.modbus_command
+                (site_id, asset_type, asset_id, asset_code,
+                 device_host, device_port, device_unit_id,
+                 register, register_name, value_to_write,
+                 planning_run_id, status, deye_physical_mode)
+            VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,'pending',$12)
+            RETURNING id
+            """,
+            site_id,
+            asset_type,
+            asset_id,
+            asset_code,
+            host,
+            port,
+            unit_id,
+            reg,
+            register_name,
+            val,
+            planning_run_id,
+            deye_physical_mode,
+        )
+        if cmd_id is not None:
+            ids.append(int(cmd_id))
+    return ids
+
+
+def _modbus_command_contiguous_runs(cmds: list[asyncpg.Record]) -> list[list[asyncpg.Record]]:
+    """Seřadí podle adresy registru a rozdělí na souvislé úseky pro FC 0x10 / FC 3."""
+    if not cmds:
+        return []
+    sorted_cmds = sorted(cmds, key=lambda c: int(c["register"]))
+    runs: list[list[asyncpg.Record]] = []
+    cur: list[asyncpg.Record] = [sorted_cmds[0]]
+    for c in sorted_cmds[1:]:
+        if int(c["register"]) == int(cur[-1]["register"]) + 1:
+            cur.append(c)
+        else:
+            runs.append(cur)
+            cur = [c]
+    runs.append(cur)
+    return runs
+
+
+async def execute_modbus_commands(
+    command_ids: list[int],
+    db: asyncpg.Connection,
+) -> bool:
+    """
+    Zapíše příkazy z modbus_command do zařízení (FC 0x10 po souvislých blocích).
+    Aktualizuje status na 'written' nebo 'failed'.
+    """
+    max_retries = 3
+    retry_delay = 0.5
+
+    rows: list[asyncpg.Record] = []
+    for cmd_id in command_ids:
+        cmd = await db.fetchrow(
+            "SELECT * FROM ems.modbus_command WHERE id=$1", cmd_id
+        )
+        if cmd is not None:
+            rows.append(cmd)
+
+    if not rows:
+        return True
+
+    by_gw: dict[tuple[str, int, int], list[asyncpg.Record]] = defaultdict(list)
+    for cmd in rows:
+        by_gw[
+            (cmd["device_host"], int(cmd["device_port"]), int(cmd["device_unit_id"]))
+        ].append(cmd)
+
+    all_ok = True
+    for (host, port, unit), group in by_gw.items():
+        client = await get_modbus_client(host, port)
+        for run in _modbus_command_contiguous_runs(group):
+            start_reg = int(run[0]["register"])
+            values = [int(c["value_to_write"]) for c in run]
+            for attempt in range(max_retries):
+                try:
+                    await client.write_registers(start_reg, values, unit)
+                    for cmd, val in zip(run, values):
+                        cid = int(cmd["id"])
+                        await db.execute(
+                            """
+                            UPDATE ems.modbus_command
+                            SET status='written', value_written=$1, written_at=now(),
+                                attempt_count=attempt_count+1, error_msg=NULL
+                            WHERE id=$2
+                            """,
+                            val,
+                            cid,
+                        )
+                        logger.info(
+                            "[cmd %s] %s 0x%04X=%s OK batch@%s (attempt %s)",
+                            cid,
+                            cmd["asset_code"],
+                            int(cmd["register"]),
+                            val,
+                            start_reg,
+                            attempt + 1,
+                        )
+                    break
+                except Exception as e:
+                    if attempt < max_retries - 1:
+                        logger.warning(
+                            "Modbus batch write 0x%04X count=%s attempt %s failed: %s, retrying...",
+                            start_reg,
+                            len(values),
+                            attempt + 1,
+                            e,
+                        )
+                        await asyncio.sleep(retry_delay)
+                        await client.force_disconnect()
+                    else:
+                        for cmd in run:
+                            await db.execute(
+                                """
+                                UPDATE ems.modbus_command
+                                SET status='failed', error_msg=$1,
+                                    attempt_count=attempt_count+1
+                                WHERE id=$2
+                                """,
+                                str(e),
+                                int(cmd["id"]),
+                            )
+                        logger.error(
+                            "Modbus batch 0x%04X count=%s all %s attempts failed: %s",
+                            start_reg,
+                            len(values),
+                            max_retries,
+                            e,
+                        )
+                        all_ok = False
+
+    return all_ok

backend/services/control/models.py

@@ -0,0 +1,74 @@
+"""Datové modely pro control export."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import date, datetime
+
+
+@dataclass
+class InverterConfig:
+    id: int
+    code: str
+    host: str
+    port: int
+    unit_id: int
+    max_export_power_w: int | None
+    max_import_power_w: int | None
+    no_export: bool
+    max_battery_charge_w: int | None
+    max_battery_discharge_w: int | None
+    min_soc_percent: int | None
+    reserve_soc_percent: int | None
+    max_soc_percent: int | None
+    usable_capacity_wh: int | None
+    max_charge_a: int
+    max_discharge_a: int
+    deye_last_system_time_sync_minute: datetime | None = None
+    deye_last_system_time_sync_at: datetime | None = None
+    deye_last_tou_inactive_write_prague_date: date | None = None
+    deye_tou_inactive_signature: str | None = None
+    deye_zero_export_mode: int = 1
+    deye_gen_microinverter_cutoff_enabled: bool = False
+    #: Součet nominal_power_wp controllable PV na invertoru; 0 = EMS nezapisuje reg 340.
+    pv_a_cap_w: int = 0
+    #: True = EMS smí řídit Deye reg 340 (max solar power); z SQL `fn_site_has_active_green_bonus_pv(site_id)`.
+    deye_reg340_pv_a_control_enabled: bool = False
+
+
+@dataclass
+class ControlSetpoints:
+    battery_w: int | None
+    #: Tvrdý limit exportu do sítě v daném slotu (W), ne forecastová cílová hodnota.
+    grid_export_limit: int
+    ev1_current_a: int
+    ev2_current_a: int
+    heat_pump_enable: bool
+    grid_setpoint_w: int
+    ev1_power_w: int
+    ev2_power_w: int
+    target_soc_pct: int | None = None
+    #: Explicitní fyzický režim z plánu (PASSIVE/SELL/CHARGE).
+    deye_physical_mode: str | None = None
+    #: True = zákaz exportu (BLOCK_EXPORT) pro daný slot.
+    export_ban: bool = False
+    #: True = odpojit GEN port (MI export cutoff) v tomto slotu dle plánu (reg 178 bits0-1).
+    deye_gen_cutoff_enabled: bool = False
+    #: Efektivní vykupní cena slotu (Kč/kWh z plánu).
+    effective_sell_price_czk_kwh: float | None = None
+    #: True = reg 108/109 na 0 (PRESERVE - Deye baterii nepoužívá).
+    lock_battery: bool = False
+    #: Režim SELF_SUSTAIN.
+    self_sustain_local_use: bool = False
+    #: Deye reg 340 (max solar power, W). None = EMS reg 340 v tomto ticku neřeší.
+    pv_a_allowed_w: int | None = None
+
+
+@dataclass
+class OperatingModeInfo:
+    mode_code: str
+    battery_mode: str
+    grid_mode: str
+    ev_enabled: bool
+    heat_pump_enabled_def: bool
+    loxone_mode_value: int

backend/services/control/orchestrator.py

@@ -0,0 +1,156 @@
+"""Top-level control export orchestration."""
+
+from __future__ import annotations
+
+import logging
+
+import asyncpg
+
+from services.control.inverter import write_inverter_setpoints
+from services.control.models import ControlSetpoints
+from services.control.outputs import (
+    send_loxone_setpoints,
+    write_ev_setpoints,
+    write_heat_pump_setpoint,
+)
+from services.control.repository import (
+    _fetch_max_charge_power_w,
+    _fetch_operating_mode,
+    _fetch_plan_row_for_slot_offset,
+    _load_inverter_config,
+)
+from services.control.setpoints import _apply_price_failsafe_guard, _build_setpoints
+from services.signal_service import enqueue_site_signals
+
+logger = logging.getLogger(__name__)
+
+
+async def export_setpoints(site_id: int, db: asyncpg.Connection) -> None:
+    mode = await _fetch_operating_mode(site_id, db)
+    if mode is None:
+        logger.warning("control export site=%s: no operating mode row", site_id)
+        return
+
+    if mode.mode_code == "MANUAL":
+        logger.info("control export site=%s: MANUAL, skip writes", site_id)
+        return
+
+    try:
+        inv_for_pv = await _load_inverter_config(site_id, db)
+        cap_pv = int(inv_for_pv.pv_a_cap_w) if inv_for_pv is not None else 0
+        reg340_en = (
+            bool(inv_for_pv.deye_reg340_pv_a_control_enabled)
+            if inv_for_pv is not None
+            else False
+        )
+        pi_now = await _fetch_plan_row_for_slot_offset(site_id, db, 0)
+        pi_next = await _fetch_plan_row_for_slot_offset(site_id, db, 1)
+        sp_now = _build_setpoints(
+            mode,
+            pi_now,
+            pv_a_cap_w=cap_pv,
+            reg340_pv_a_control_enabled=reg340_en,
+        )
+        sp_next = _build_setpoints(
+            mode,
+            pi_next,
+            pv_a_cap_w=cap_pv,
+            reg340_pv_a_control_enabled=reg340_en,
+        )
+
+        if mode.mode_code == "AUTO" and sp_now is None:
+            if pi_now is None:
+                logger.warning(
+                    "control export site=%s: AUTO but no planning_interval for current slot, skip",
+                    site_id,
+                )
+            return
+
+        if sp_now is None:
+            logger.warning(
+                "control export site=%s: no setpoints for mode %s, skip",
+                site_id,
+                mode.mode_code,
+            )
+            return
+
+        if mode.mode_code == "CHARGE_CHEAP":
+            max_ch = await _fetch_max_charge_power_w(site_id, db)
+            pw = max(1, int(max_ch))
+            sp_now = ControlSetpoints(
+                battery_w=pw,
+                grid_export_limit=0,
+                ev1_current_a=0,
+                ev2_current_a=0,
+                heat_pump_enable=False,
+                grid_setpoint_w=pw,
+                ev1_power_w=0,
+                ev2_power_w=0,
+                target_soc_pct=None,
+                effective_sell_price_czk_kwh=None,
+            )
+            sp_next = sp_now
+        else:
+            sp_now = _apply_price_failsafe_guard(site_id, mode, pi_now, sp_now)
+            if sp_next is not None:
+                sp_next = _apply_price_failsafe_guard(site_id, mode, pi_next, sp_next)
+
+        planning_run_id = await db.fetchval(
+            """
+            SELECT id FROM ems.planning_run
+            WHERE site_id = $1 AND status = 'active'
+            ORDER BY created_at DESC
+            LIMIT 1
+            """,
+            site_id,
+        )
+        if planning_run_id is not None:
+            planning_run_id = int(planning_run_id)
+
+        try:
+            inv_res = await write_inverter_setpoints(
+                site_id, sp_now, sp_next, db, planning_run_id=planning_run_id
+            )
+        except Exception as e:
+            logger.error("inverter write failed: %s", e)
+            inv_res = f"FAIL inverter: {e}"
+
+        try:
+            ev_res = await write_ev_setpoints(site_id, sp_now, db)
+        except Exception as e:
+            logger.error("ev write failed: %s", e)
+            ev_res = f"FAIL ev: {e}"
+
+        try:
+            hp_res = await write_heat_pump_setpoint(site_id, sp_now, db)
+        except Exception as e:
+            logger.error("hp write failed: %s", e)
+            hp_res = f"FAIL heat pump: {e}"
+
+        try:
+            lox_res = await send_loxone_setpoints(site_id, sp_now, mode, db)
+        except Exception as e:
+            logger.error("loxone write failed: %s", e)
+            lox_res = f"FAIL Loxone: {e}"
+
+        results = list(
+            zip(
+                ("inverter", "ev", "heat_pump", "loxone"),
+                (inv_res, ev_res, hp_res, lox_res),
+            )
+        )
+
+        for name, res in results:
+            if isinstance(res, Exception):
+                logger.error("control export site=%s %s: FAIL %s", site_id, name, res)
+            elif isinstance(res, str) and res.startswith("FAIL"):
+                logger.error("control export site=%s %s: %s", site_id, name, res)
+            else:
+                logger.info("control export site=%s %s: %s", site_id, name, res)
+    finally:
+        try:
+            await enqueue_site_signals(site_id, db)
+        except Exception as e:
+            logger.warning(
+                "control export site=%s: signal enqueue failed: %s", site_id, e
+            )

backend/services/control/outputs.py

@@ -0,0 +1,149 @@
+"""Non-Deye output writers for control export."""
+
+from __future__ import annotations
+
+import logging
+import os
+
+import asyncpg
+import httpx
+
+from app.config import get_settings
+from services.control.models import ControlSetpoints, OperatingModeInfo
+
+logger = logging.getLogger(__name__)
+
+
+def _current_limit_for_charger(charger_code: str, sp: ControlSetpoints) -> int:
+    c = (charger_code or "").strip().lower()
+    if c == "ev-charger-1":
+        a = sp.ev1_current_a
+    elif c == "ev-charger-2":
+        a = sp.ev2_current_a
+    elif c.endswith("-1") or c == "ev1":
+        a = sp.ev1_current_a
+    elif c.endswith("-2") or c == "ev2":
+        a = sp.ev2_current_a
+    else:
+        a = 0
+    if a < 6:
+        a = 0
+    return a
+
+
+async def write_ev_setpoints(
+    site_id: int, setpoints: ControlSetpoints, db: asyncpg.Connection
+) -> str:
+    rows = await db.fetch(
+        """
+        SELECT ec.code, se.host, se.port, se.unit_id
+        FROM ems.asset_ev_charger ec
+        JOIN ems.site_endpoint se ON se.id = ec.endpoint_id
+        WHERE ec.site_id = $1
+          AND ec.schedulable = true
+          AND se.enabled = true
+          AND se.endpoint_type = 'modbus_tcp'
+        ORDER BY ec.code
+        """,
+        site_id,
+    )
+    if not rows:
+        return "OK EV: no schedulable chargers"
+
+    for row in rows:
+        code = row["code"]
+        current_a = _current_limit_for_charger(code, setpoints)
+        logger.info(
+            "EV setpoint [%s]: %sA (TODO: Modbus registers)",
+            code,
+            current_a,
+        )
+    return f"OK EV: logged {len(rows)} charger(s) (Modbus TODO)"
+
+
+async def write_heat_pump_setpoint(
+    site_id: int, setpoints: ControlSetpoints, db: asyncpg.Connection
+) -> str:
+    rows = await db.fetch(
+        """
+        SELECT hp.code, se.host, se.port, se.unit_id
+        FROM ems.asset_heat_pump hp
+        JOIN ems.site_endpoint se ON se.id = hp.endpoint_id
+        WHERE hp.site_id = $1
+          AND hp.schedulable = true
+          AND se.enabled = true
+          AND se.endpoint_type = 'modbus_tcp'
+        """,
+        site_id,
+    )
+    if not rows:
+        return "OK heat pump: no schedulable unit"
+    for row in rows:
+        logger.info(
+            "HP setpoint [%s]: enable=%s (TODO: Modbus registers)",
+            row["code"],
+            setpoints.heat_pump_enable,
+        )
+    return "OK heat pump: logged (Modbus TODO)"
+
+
+async def send_loxone_setpoints(
+    site_id: int,
+    setpoints: ControlSetpoints,
+    mode: OperatingModeInfo,
+    db: asyncpg.Connection,
+) -> str:
+    endpoint = await db.fetchrow(
+        """
+        SELECT host, port, protocol
+        FROM ems.site_endpoint
+        WHERE site_id = $1 AND endpoint_type = 'loxone_http' AND enabled = true
+        ORDER BY id
+        LIMIT 1
+        """,
+        site_id,
+    )
+    if not endpoint:
+        return "OK Loxone: no endpoint, skipped"
+
+    proto = (endpoint["protocol"] or "http").lower()
+    if proto not in ("http", "https"):
+        proto = "http"
+    host = endpoint["host"]
+    port = int(endpoint["port"] or (443 if proto == "https" else 80))
+    base = f"{proto}://{host}:{port}/dev/sps/io"
+
+    settings = get_settings()
+    user = settings.loxone_user or os.getenv("LOXONE_USER") or ""
+    password = settings.loxone_password or os.getenv("LOXONE_PASSWORD") or ""
+    auth = (user, password) if user else None
+
+    batt_display = 0 if setpoints.battery_w is None else int(setpoints.battery_w)
+
+    paths: list[tuple[str, int]] = [
+        (f"{base}/EMS_Mode/{mode.loxone_mode_value}", mode.loxone_mode_value),
+        (f"{base}/EMS_Battery_Setpoint_W/{batt_display}", batt_display),
+        (f"{base}/EMS_Grid_Setpoint_W/{setpoints.grid_setpoint_w}", setpoints.grid_setpoint_w),
+        (f"{base}/EMS_EV1_Power_W/{setpoints.ev1_power_w}", setpoints.ev1_power_w),
+        (f"{base}/EMS_EV2_Power_W/{setpoints.ev2_power_w}", setpoints.ev2_power_w),
+        (
+            f"{base}/EMS_HeatPump_Enable/{1 if setpoints.heat_pump_enable else 0}",
+            1 if setpoints.heat_pump_enable else 0,
+        ),
+    ]
+
+    errs: list[str] = []
+    try:
+        async with httpx.AsyncClient(timeout=5.0) as client:
+            for url, _ in paths:
+                try:
+                    r = await client.get(url, auth=auth)
+                    r.raise_for_status()
+                except Exception as e:
+                    errs.append(f"{url!s}: {e}")
+    except Exception as e:
+        return f"FAIL Loxone: client {e}"
+
+    if errs:
+        return "FAIL Loxone: " + "; ".join(errs[:3])
+    return "OK Loxone: all virtual inputs updated"

backend/services/control/repository.py

@@ -0,0 +1,215 @@
+"""DB načítání pro control export."""
+
+from __future__ import annotations
+
+import json
+from datetime import datetime, timezone
+
+import asyncpg
+
+from services.control.deye_helpers import DEYE_LV_BATTERY_MAX_CHARGE_DISCHARGE_A
+from services.control.models import InverterConfig, OperatingModeInfo
+from services.control.setpoints import _DictRecord
+
+
+async def _fetch_operating_mode(
+    site_id: int, db: asyncpg.Connection
+) -> OperatingModeInfo | None:
+    sql = """
+        SELECT som.mode_code, omd.battery_mode, omd.grid_mode,
+               omd.ev_enabled, omd.heat_pump_enabled, omd.loxone_mode_value,
+               som.valid_until
+        FROM ems.site_operating_mode som
+        JOIN ems.operating_mode_def omd ON omd.code = som.mode_code
+        WHERE som.site_id = $1
+        """
+    row = await db.fetchrow(sql, site_id)
+    if row is None:
+        return None
+    vu = row["valid_until"]
+    if vu is not None:
+        now_utc = datetime.now(timezone.utc)
+        if vu.tzinfo is None:
+            vu = vu.replace(tzinfo=timezone.utc)
+        if vu <= now_utc:
+            exp_rows = await db.fetch("SELECT * FROM ems.fn_expire_modes()")
+            from services.notification_service import notify_operating_mode_changed
+
+            for er in exp_rows:
+                await notify_operating_mode_changed(
+                    str(er["site_code"]),
+                    str(er["old_mode"]),
+                    str(er["new_mode"]),
+                    "system:expiry",
+                    "Automatické vypršení dočasného režimu",
+                )
+            row = await db.fetchrow(sql, site_id)
+            if row is None:
+                return None
+    return OperatingModeInfo(
+        mode_code=row["mode_code"],
+        battery_mode=row["battery_mode"],
+        grid_mode=row["grid_mode"],
+        ev_enabled=bool(row["ev_enabled"]),
+        heat_pump_enabled_def=bool(row["heat_pump_enabled"]),
+        loxone_mode_value=int(row["loxone_mode_value"]),
+    )
+
+
+async def _get_current_soc(site_id: int, db: asyncpg.Connection) -> int:
+    soc = await db.fetchval(
+        """
+        SELECT battery_soc_percent
+        FROM ems.telemetry_inverter
+        WHERE site_id = $1 AND battery_soc_percent IS NOT NULL
+        ORDER BY measured_at DESC
+        LIMIT 1
+        """,
+        site_id,
+    )
+    return int(soc) if soc is not None else 50
+
+
+async def _load_inverter_config(
+    site_id: int, db: asyncpg.Connection
+) -> InverterConfig | None:
+    row = await db.fetchrow(
+        """
+        SELECT
+            ai.id, ai.code,
+            coalesce(ems.fn_inverter_pv_a_max_w(ai.id), 0) AS pv_a_cap_w,
+            se.host, se.port, se.unit_id,
+            sgc.max_export_power_w,
+            sgc.max_import_power_w,
+            sgc.no_export,
+            ai.max_battery_charge_w,
+            ai.max_battery_discharge_w,
+            ab.min_soc_percent,
+            ab.reserve_soc_percent,
+            ab.max_soc_percent,
+            ab.usable_capacity_wh,
+            ai.deye_last_system_time_sync_minute,
+            ai.deye_last_system_time_sync_at,
+            ai.deye_last_tou_inactive_write_prague_date,
+            ai.deye_tou_inactive_signature,
+            COALESCE(ai.deye_zero_export_mode, 1) AS deye_zero_export_mode,
+            COALESCE(ai.deye_gen_microinverter_cutoff_enabled, false) AS deye_gen_microinverter_cutoff_enabled,
+            coalesce(ems.fn_site_has_active_green_bonus_pv(ai.site_id), false)
+              AS deye_reg340_pv_a_control_enabled,
+            COALESCE(
+                ai.deye_register_max_charge_a,
+                FLOOR(
+                    LEAST(
+                        COALESCE(ab.bms_max_charge_w, ai.max_battery_charge_w),
+                        ai.max_battery_charge_w
+                    )::numeric / 51.2
+                )::int
+            ) AS max_charge_a,
+            COALESCE(
+                ai.deye_register_max_discharge_a,
+                FLOOR(
+                    LEAST(
+                        COALESCE(ab.bms_max_discharge_w, ai.max_battery_discharge_w),
+                        ai.max_battery_discharge_w
+                    )::numeric / 51.2
+                )::int
+            ) AS max_discharge_a
+        FROM ems.asset_inverter ai
+        JOIN ems.site_endpoint se ON se.id = ai.endpoint_id
+        JOIN ems.asset_battery ab ON ab.inverter_id = ai.id
+        LEFT JOIN ems.site_grid_connection sgc ON sgc.site_id = ai.site_id
+        WHERE ai.site_id = $1
+          AND ai.active = true
+          AND ai.controllable = true
+          AND se.enabled = true
+          AND se.endpoint_type = 'modbus_tcp'
+        ORDER BY ai.id
+        LIMIT 1
+        """,
+        site_id,
+    )
+    if row is None:
+        return None
+    mc = row["max_charge_a"]
+    md = row["max_discharge_a"]
+    max_charge_a = int(mc) if mc is not None else 0
+    max_discharge_a = int(md) if md is not None else 0
+    max_charge_a = min(max_charge_a, DEYE_LV_BATTERY_MAX_CHARGE_DISCHARGE_A)
+    max_discharge_a = min(max_discharge_a, DEYE_LV_BATTERY_MAX_CHARGE_DISCHARGE_A)
+    port = int(row["port"] or 502)
+    uid = int(row["unit_id"] if row["unit_id"] is not None else 1)
+    return InverterConfig(
+        id=int(row["id"]),
+        code=row["code"],
+        host=row["host"],
+        port=port,
+        unit_id=uid,
+        max_export_power_w=int(row["max_export_power_w"])
+        if row["max_export_power_w"] is not None
+        else None,
+        max_import_power_w=int(row["max_import_power_w"])
+        if row["max_import_power_w"] is not None
+        else None,
+        no_export=bool(row["no_export"] or False),
+        max_battery_charge_w=int(row["max_battery_charge_w"])
+        if row["max_battery_charge_w"] is not None
+        else None,
+        max_battery_discharge_w=int(row["max_battery_discharge_w"])
+        if row["max_battery_discharge_w"] is not None
+        else None,
+        min_soc_percent=int(round(float(row["min_soc_percent"])))
+        if row["min_soc_percent"] is not None
+        else None,
+        reserve_soc_percent=int(row["reserve_soc_percent"])
+        if row["reserve_soc_percent"] is not None
+        else None,
+        max_soc_percent=int(row["max_soc_percent"])
+        if row["max_soc_percent"] is not None
+        else None,
+        usable_capacity_wh=int(row["usable_capacity_wh"])
+        if row["usable_capacity_wh"] is not None
+        else None,
+        max_charge_a=max_charge_a,
+        max_discharge_a=max_discharge_a,
+        deye_last_system_time_sync_minute=row["deye_last_system_time_sync_minute"],
+        deye_last_system_time_sync_at=row["deye_last_system_time_sync_at"],
+        deye_last_tou_inactive_write_prague_date=row[
+            "deye_last_tou_inactive_write_prague_date"
+        ],
+        deye_tou_inactive_signature=row["deye_tou_inactive_signature"],
+        deye_zero_export_mode=int(row["deye_zero_export_mode"]),
+        deye_gen_microinverter_cutoff_enabled=bool(
+            row["deye_gen_microinverter_cutoff_enabled"] or False
+        ),
+        pv_a_cap_w=int(row["pv_a_cap_w"] or 0),
+        deye_reg340_pv_a_control_enabled=bool(
+            row["deye_reg340_pv_a_control_enabled"] or False
+        ),
+    )
+
+
+async def _fetch_plan_row_for_slot_offset(
+    site_id: int, db: asyncpg.Connection, slot_offset: int
+) -> asyncpg.Record | None:
+    """Řádek plánu pro slot z ems.fn_planning_interval_at_offset (jsonb -> Record-like dict)."""
+    raw = await db.fetchval(
+        """
+        select ems.fn_planning_interval_at_offset($1::int, $2::int)
+        """,
+        site_id,
+        slot_offset,
+    )
+    if raw is None:
+        return None
+    data = raw if isinstance(raw, dict) else json.loads(raw)
+    if not data:
+        return None
+    return _DictRecord(data)
+
+
+async def _fetch_max_charge_power_w(site_id: int, db: asyncpg.Connection) -> int:
+    v = await db.fetchval(
+        "select ems.fn_planning_max_effective_charge_w($1::int)",
+        site_id,
+    )
+    return int(v or 0)

backend/services/control/setpoints.py

@@ -0,0 +1,330 @@
+"""Výpočet control setpointů a Deye TOU parametrů."""
+
+from __future__ import annotations
+
+import logging
+from datetime import datetime
+from typing import Any
+
+from services.control.deye_helpers import (
+    BATT_VOLTAGE_V,
+    PRAGUE_TZ,
+    battery_watts_to_amps,
+    compute_pv_a_reg340_max_solar_w,
+    watts_to_amps,
+)
+from services.control.models import ControlSetpoints, InverterConfig, OperatingModeInfo
+
+logger = logging.getLogger(__name__)
+
+
+def _deye_system_time_register_rows() -> tuple[datetime, list[tuple[int, str, int]]]:
+    """Hodnoty pro reg 62-64 (Europe/Prague); sekundy v reg 64 = 0 (stabilnější zápis)."""
+    now = datetime.now(PRAGUE_TZ).replace(second=0, microsecond=0)
+    reg62 = ((now.year - 2000) << 8) | now.month
+    reg63 = (now.day << 8) | now.hour
+    reg64 = (now.minute << 8) | 0
+    rows = [
+        (62, "", reg62),
+        (63, "", reg63),
+        (64, "", reg64),
+    ]
+    return now, rows
+
+
+def _deye_time_point_rows(
+    slot_index: int,
+    time_hhmm: int,
+    power_w: int,
+    soc_pct: int,
+    grid_charge: bool,
+) -> list[tuple[int, str, int]]:
+    g = 1 if grid_charge else 0
+    return [
+        (148 + slot_index, "", time_hhmm),
+        (154 + slot_index, "", power_w),
+        (166 + slot_index, "", soc_pct),
+        (172 + slot_index, "", g),
+    ]
+
+
+class _DictRecord:
+    """Minimální asyncpg Record kompatibilita pro dict z jsonb."""
+
+    __slots__ = ("_d",)
+
+    def __init__(self, d: dict[str, Any]) -> None:
+        self._d = d
+
+    def __getitem__(self, k: str) -> Any:
+        return self._d[k]
+
+    def get(self, k: str, default: Any = None) -> Any:
+        return self._d.get(k, default)
+
+    def __contains__(self, k: str) -> bool:
+        return k in self._d
+
+
+def _build_setpoints(
+    mode: OperatingModeInfo,
+    pi: Any | None,
+    *,
+    pv_a_cap_w: int = 0,
+    reg340_pv_a_control_enabled: bool = False,
+) -> ControlSetpoints | None:
+    code = mode.mode_code
+    if code == "MANUAL":
+        return None
+
+    if code == "AUTO":
+        if pi is None:
+            return None
+        grid_sp = int(pi["grid_setpoint_w"] or 0)
+        export_limit_raw = pi.get("export_limit_w")
+        export_limit = int(export_limit_raw) if export_limit_raw is not None else abs(min(grid_sp, 0))
+        ev1_w = int(pi["ev1_setpoint_w"] or 0) if "ev1_setpoint_w" in pi else 0
+        ev2_w = int(pi["ev2_setpoint_w"] or 0) if "ev2_setpoint_w" in pi else 0
+        hp_en = bool(pi["heat_pump_enabled"])
+        tgt = pi["battery_soc_target_pct"]
+        target_soc = int(round(float(tgt))) if tgt is not None else None
+        pm_raw = pi.get("deye_physical_mode")
+        pm: str | None = str(pm_raw).strip().upper() if pm_raw is not None else None
+        sell_raw = pi.get("effective_sell_price")
+        sell_f: float | None = float(sell_raw) if sell_raw is not None else None
+        export_mode_raw = pi.get("export_mode")
+        export_mode = str(export_mode_raw).strip().upper() if export_mode_raw is not None else None
+        if export_mode == "NONE":
+            export_limit = 0
+        # Záporný výkup sám o sobě neblokuje export, pokud plán export explicitně žádá.
+        export_ban = sell_f is not None and float(sell_f) < 0 and grid_sp >= 0
+        gen_cutoff_raw = pi.get("deye_gen_cutoff_enabled")
+        gen_cutoff = bool(gen_cutoff_raw) if gen_cutoff_raw is not None else False
+        pv_a_allowed: int | None = None
+        if bool(reg340_pv_a_control_enabled) and int(pv_a_cap_w) > 0:
+            forecast = int(pi.get("pv_a_forecast_solver_w") or 0)
+            curtail = int(pi.get("pv_a_curtailed_w") or 0)
+            pv_a_allowed = compute_pv_a_reg340_max_solar_w(int(pv_a_cap_w), forecast, curtail)
+            buy_raw = pi.get("effective_buy_price")
+            buy_f: float | None = float(buy_raw) if buy_raw is not None else None
+            pv_b = int(pi.get("pv_b_forecast_solver_w") or 0)
+            if (
+                buy_f is not None
+                and sell_f is not None
+                and float(buy_f) < 0.0
+                and float(sell_f) < 0.0
+                and pv_b > 0
+            ):
+                pv_a_allowed = 0
+        return ControlSetpoints(
+            battery_w=int(pi["battery_setpoint_w"] or 0),
+            grid_export_limit=max(0, export_limit),
+            ev1_current_a=watts_to_amps(ev1_w, phases=3),
+            ev2_current_a=watts_to_amps(ev2_w, phases=1),
+            heat_pump_enable=hp_en,
+            grid_setpoint_w=grid_sp,
+            ev1_power_w=ev1_w,
+            ev2_power_w=ev2_w,
+            target_soc_pct=target_soc,
+            deye_physical_mode=pm,
+            export_ban=bool(export_ban),
+            deye_gen_cutoff_enabled=bool(gen_cutoff),
+            effective_sell_price_czk_kwh=sell_f,
+            pv_a_allowed_w=pv_a_allowed,
+        )
+
+    if code == "SELF_SUSTAIN":
+        return ControlSetpoints(
+            battery_w=None,
+            grid_export_limit=0,
+            ev1_current_a=0,
+            ev2_current_a=0,
+            heat_pump_enable=False,
+            grid_setpoint_w=0,
+            ev1_power_w=0,
+            ev2_power_w=0,
+            target_soc_pct=None,
+            self_sustain_local_use=True,
+        )
+
+    if code == "CHARGE_CHEAP":
+        return ControlSetpoints(
+            battery_w=0,
+            grid_export_limit=0,
+            ev1_current_a=0,
+            ev2_current_a=0,
+            heat_pump_enable=False,
+            grid_setpoint_w=0,
+            ev1_power_w=0,
+            ev2_power_w=0,
+            target_soc_pct=None,
+        )
+
+    if code == "PRESERVE":
+        return ControlSetpoints(
+            battery_w=0,
+            grid_export_limit=0,
+            ev1_current_a=0,
+            ev2_current_a=0,
+            heat_pump_enable=False,
+            grid_setpoint_w=0,
+            ev1_power_w=0,
+            ev2_power_w=0,
+            target_soc_pct=None,
+            lock_battery=True,
+        )
+
+    logger.warning("Unknown mode_code %s for site export, skipping", code)
+    return None
+
+
+def _apply_price_failsafe_guard(
+    site_id: int,
+    mode: OperatingModeInfo,
+    pi: Any | None,
+    sp: ControlSetpoints,
+) -> ControlSetpoints:
+    if mode.mode_code != "AUTO" or pi is None:
+        return sp
+    if "is_predicted_price" not in pi or not bool(pi["is_predicted_price"]):
+        return sp
+    logger.warning(
+        "control export site=%s: AUTO slot uses predicted price -> forcing PASSIVE no-export guard",
+        site_id,
+    )
+    return ControlSetpoints(
+        battery_w=0,
+        grid_export_limit=0,
+        ev1_current_a=sp.ev1_current_a,
+        ev2_current_a=sp.ev2_current_a,
+        heat_pump_enable=sp.heat_pump_enable,
+        grid_setpoint_w=max(0, int(sp.grid_setpoint_w or 0)),
+        ev1_power_w=sp.ev1_power_w,
+        ev2_power_w=sp.ev2_power_w,
+        target_soc_pct=sp.target_soc_pct,
+        effective_sell_price_czk_kwh=sp.effective_sell_price_czk_kwh,
+        pv_a_allowed_w=sp.pv_a_allowed_w,
+    )
+
+
+def _deye_reg143_export_w(no_export: bool, max_export_power_w: int | None) -> int:
+    """Reg 143 - max export W z DB (např. SUN-20K / home-01 = 13 500 W)."""
+    if no_export:
+        return 0
+    return max(0, int(max_export_power_w or 0))
+
+
+def _clamp_deye_tou_soc_pct(pct: int) -> int:
+    return max(5, min(95, pct))
+
+
+def _deye_tou_min_soc_pct(inv: InverterConfig) -> int:
+    if inv.min_soc_percent is not None:
+        return _clamp_deye_tou_soc_pct(int(inv.min_soc_percent))
+    return 10
+
+
+def _deye_tou_reserve_soc_pct(inv: InverterConfig) -> int:
+    if inv.reserve_soc_percent is not None:
+        return _clamp_deye_tou_soc_pct(int(inv.reserve_soc_percent))
+    return 20
+
+
+def _deye_passive_tou_battery_soc_pct(
+    inv: InverterConfig, _setpoints: ControlSetpoints
+) -> int:
+    """Hodnota SOC u Deye TOU řádku (reg 166+) ve fyzickém PASSIVE."""
+    return _deye_tou_min_soc_pct(inv)
+
+
+def _deye_zero_export_amps_for_passive(
+    grid_w: int,
+    bat_w: int,
+    max_charge_a: int,
+    max_discharge_a: int,
+) -> tuple[int, int]:
+    """
+    PASSIVE (zero export k CT/zátěži): výchozí plné 108/109.
+
+    Export v plánu bez vybíjení baterie vypne charge A; import bez nabíjení vypne discharge A.
+    """
+    if grid_w < 0 and bat_w >= 0:
+        return 0, max_discharge_a
+    if grid_w > 0 and bat_w <= 0:
+        return max_charge_a, 0
+    return max_charge_a, max_discharge_a
+
+
+def deye_battery_charge_discharge_amps(
+    *,
+    lock_battery: bool,
+    deye_mode: str,
+    self_sustain_local_use: bool,
+    bat_w: int,
+    grid_w: int,
+    max_charge_a: int,
+    max_discharge_a: int,
+) -> tuple[int, int]:
+    """
+    Proud nabíjení / vybíjení (reg 108 / 109) pro zápis Deye.
+
+    PASSIVE + plán chce nabíjet z PV přebytku i při exportu do sítě: nenulový charge, discharge 0.
+    """
+    if lock_battery:
+        return 0, 0
+    if deye_mode == "CHARGE":
+        return battery_watts_to_amps(bat_w, max_charge_a), 0
+    if deye_mode == "SELL":
+        return 0, int(max_discharge_a)
+    if self_sustain_local_use:
+        return int(max_charge_a), int(max_discharge_a)
+    if bat_w > 0:
+        return battery_watts_to_amps(bat_w, max_charge_a), 0
+    return _deye_zero_export_amps_for_passive(
+        grid_w, bat_w, int(max_charge_a), int(max_discharge_a)
+    )
+
+
+def get_deye_mode(setpoints: ControlSetpoints) -> str:
+    """Fyzický režim Deye: SELL | CHARGE | PASSIVE."""
+    pm = (setpoints.deye_physical_mode or "").strip().upper()
+    if pm in {"PASSIVE", "SELL", "CHARGE"}:
+        return pm
+
+    grid_w = int(setpoints.grid_setpoint_w or 0)
+    bat_w = 0 if setpoints.battery_w is None else int(setpoints.battery_w)
+
+    if bat_w > 0 and grid_w > 0:
+        return "CHARGE"
+
+    if grid_w < 0 and bat_w < 0:
+        return "SELL"
+
+    return "PASSIVE"
+
+
+def _deye_tou_params(
+    setpoints: ControlSetpoints,
+    inv: InverterConfig,
+) -> tuple[int, int, bool]:
+    """Parametry jednoho Deye time pointu: výkon W, SOC % (TOU reg 166+), grid_charge."""
+    max_batt_w_discharge = int(inv.max_discharge_a * BATT_VOLTAGE_V)
+    tp_discharge_w = 0 if setpoints.lock_battery else max_batt_w_discharge
+    tou_min = _deye_tou_min_soc_pct(inv)
+    tou_reserve = _deye_tou_reserve_soc_pct(inv)
+    if setpoints.lock_battery:
+        return tp_discharge_w, tou_min, False
+    deye_mode = get_deye_mode(setpoints)
+    if deye_mode == "CHARGE":
+        raw_bat = setpoints.battery_w
+        battery_w = int(raw_bat) if raw_bat is not None else 0
+        cap = int(inv.max_soc_percent) if inv.max_soc_percent is not None else 95
+        target_soc = max(10, min(100, cap))
+        tp_charge_w = (
+            battery_watts_to_amps(battery_w, int(inv.max_charge_a)) * int(BATT_VOLTAGE_V)
+        )
+        return tp_charge_w, target_soc, True
+    if deye_mode == "SELL":
+        return tp_discharge_w, tou_reserve, False
+    tou_soc = _deye_passive_tou_battery_soc_pct(inv, setpoints)
+    return tp_discharge_w, tou_soc, False

backend/services/control/verify.py

@@ -0,0 +1,476 @@
+"""Modbus verify workflow pro control export."""
+
+from __future__ import annotations
+
+import logging
+from collections import defaultdict
+from typing import Any
+
+import asyncpg
+
+from services.control.deye_helpers import (
+    DEYE_CLOCK_REGS,
+    DEYE_TOU_POWER_REGS,
+    REG178_VERIFY_MASK,
+    _deye_clock_registers_verify_match,
+    _deye_reg178_verify_match,
+    _deye_reg178_verify_with_double_read,
+    _deye_tou_power_verify_match,
+    _prague_minute_start_utc,
+    deye_reg_triggers_self_sustain_after_verify_exhaust,
+)
+from services.control.modbus_journal import (
+    _fetch_last_verified_inverter_registers,
+    _fetch_written_deye_clock_commands,
+    _modbus_command_contiguous_runs,
+    execute_modbus_commands,
+)
+from services.control.repository import _load_inverter_config
+from services.modbus_client import get_modbus_client
+
+logger = logging.getLogger(__name__)
+
+
+async def _switch_to_self_sustain(site_id: int, db: asyncpg.Connection, reason: str) -> None:
+    """Přepne lokalitu na SELF_SUSTAIN, zaloguje důvod a při změně pošle Discord."""
+    from services.notification_service import run_fn_set_mode_with_discord
+
+    await run_fn_set_mode_with_discord(
+        db,
+        site_id,
+        "SELF_SUSTAIN",
+        "system:mismatch",
+        None,
+        reason,
+    )
+    logger.critical("Site %s switched to SELF_SUSTAIN: %s", site_id, reason)
+
+
+def _modbus_cmd_register(cmd: Any) -> int:
+    """asyncpg.Record má __getitem__; objekty s atributem .register též (testy)."""
+    try:
+        return int(cmd["register"])
+    except (KeyError, TypeError):
+        return int(cmd.register)
+
+
+def _deye_expected_clock_triplet_for_verify(
+    bundle: list[asyncpg.Record],
+    last_verified: dict[int, int],
+    a62: int,
+    a63: int,
+    a64: int,
+) -> tuple[int, int, int]:
+    """
+    Sestaví očekávané (w62,w63,w64) pro toleranční verify.
+    Chybějící registry doplní poslední verified nebo aktuálním přečtením ze zařízení.
+    """
+    by_reg = {_modbus_cmd_register(c): c for c in bundle}
+
+    def _vtw(c: Any) -> int:
+        try:
+            return int(c["value_to_write"])
+        except (KeyError, TypeError):
+            return int(c.value_to_write)
+
+    w62 = _vtw(by_reg[62]) if 62 in by_reg else last_verified.get(62, a62)
+    w63 = _vtw(by_reg[63]) if 63 in by_reg else last_verified.get(63, a63)
+    w64 = _vtw(by_reg[64]) if 64 in by_reg else last_verified.get(64, a64)
+    return (int(w62), int(w63), int(w64))
+
+
+async def _verify_deye_clock_written_bundle(
+    site_id: int,
+    bundle: list[asyncpg.Record],
+    a62: int,
+    a63: int,
+    a64: int,
+    db: asyncpg.Connection,
+) -> bool:
+    """
+    Toleranční ověření pro jeden až tři řádky journalu 62-64 ve stavu written.
+    Při mismatch retry společně; bez přepnutí do SELF_SUSTAIN po 3 pokusech.
+    """
+    from services.notification_service import (
+        notify_modbus_clock_verify_exhausted,
+        notify_modbus_mismatch,
+    )
+
+    cmds_s = sorted(bundle, key=_modbus_cmd_register)
+    try:
+        asset_id = int(cmds_s[0]["asset_id"])
+    except (KeyError, TypeError):
+        asset_id = int(cmds_s[0].asset_id)
+    last_v = await _fetch_last_verified_inverter_registers(site_id, asset_id, db)
+    w62, w63, w64 = _deye_expected_clock_triplet_for_verify(bundle, last_v, a62, a63, a64)
+    clock_ok = _deye_clock_registers_verify_match(w62, w63, w64, a62, a63, a64)
+    actual_by_reg = {62: a62, 63: a63, 64: a64}
+
+    for cmd in cmds_s:
+        try:
+            cid = int(cmd["id"])
+        except (KeyError, TypeError):
+            cid = int(cmd.id)
+        r = _modbus_cmd_register(cmd)
+        await db.execute(
+            """
+            UPDATE ems.modbus_command
+            SET value_verified=$1::int, verified_at=now(),
+                status=CASE WHEN $2::boolean THEN 'verified' ELSE 'mismatch' END
+            WHERE id=$3::int
+            """,
+            actual_by_reg[r],
+            clock_ok,
+            cid,
+        )
+
+    if clock_ok:
+        await db.execute(
+            """
+            UPDATE ems.asset_inverter
+            SET deye_last_system_time_sync_minute = $1,
+                deye_last_system_time_sync_at = now()
+            WHERE id = $2
+            """,
+            _prague_minute_start_utc(),
+            asset_id,
+        )
+        for cmd in cmds_s:
+            try:
+                cid_l = int(cmd["id"])
+            except (KeyError, TypeError):
+                cid_l = int(cmd.id)
+            try:
+                code_l = str(cmd["asset_code"])
+            except (KeyError, TypeError):
+                code_l = str(cmd.asset_code)
+            rr = _modbus_cmd_register(cmd)
+            logger.info(
+                "[cmd %s] verified OK (clock tolerant): %s 0x%04X=%s",
+                cid_l,
+                code_l,
+                rr,
+                actual_by_reg[rr],
+            )
+        return True
+
+    cmd0 = cmds_s[0]
+    try:
+        ac0 = str(cmd0["asset_code"])
+    except (KeyError, TypeError):
+        ac0 = str(cmd0.asset_code)
+    logger.error(
+        "[cmd clock] MISMATCH %s 62-64: written=(%s,%s,%s) actual=(%s,%s,%s)",
+        ac0,
+        w62,
+        w63,
+        w64,
+        a62,
+        a63,
+        a64,
+    )
+
+    attempts = 0
+    for cmd in cmds_s:
+        try:
+            cid_q = int(cmd["id"])
+        except (KeyError, TypeError):
+            cid_q = int(cmd.id)
+        row_ac = await db.fetchrow(
+            "SELECT attempt_count FROM ems.modbus_command WHERE id=$1", cid_q
+        )
+        ac = int(row_ac["attempt_count"] or 0) if row_ac else 0
+        attempts = max(attempts, ac)
+
+    await notify_modbus_mismatch(
+        db,
+        site_id,
+        ac0,
+        62,
+        "system_time_62_64",
+        w62,
+        a62,
+        attempts,
+    )
+
+    ids_ordered = []
+    for c in cmds_s:
+        try:
+            ids_ordered.append(int(c["id"]))
+        except (KeyError, TypeError):
+            ids_ordered.append(int(c.id))
+    if attempts < 3:
+        for cid in ids_ordered:
+            await db.execute(
+                "UPDATE ems.modbus_command SET status='retrying' WHERE id=$1",
+                cid,
+            )
+        await execute_modbus_commands(ids_ordered, db)
+        await verify_modbus_commands(ids_ordered, db, site_id)
+    else:
+        logger.critical(
+            "[cmd clock] 3 failed verify attempts (62-64); režim se nemění automaticky"
+        )
+        site = await db.fetchrow("SELECT code FROM ems.site WHERE id=$1", site_id)
+        await notify_modbus_clock_verify_exhausted(
+            db,
+            site_id,
+            site["code"] if site else str(site_id),
+            ac0,
+            (w62, w63, w64),
+            (a62, a63, a64),
+        )
+    return False
+
+
+async def verify_modbus_commands(
+    command_ids: list[int],
+    db: asyncpg.Connection,
+    site_id: int,
+) -> bool:
+    """
+    Přečte registry zpět (FC 3 po souvislých blocích) a porovná s value_to_write.
+    Při mismatch řeší retry a po vyčerpání kritických registrů SELF_SUSTAIN.
+    """
+    from services.notification_service import notify_modbus_mismatch
+
+    inv_cfg = await _load_inverter_config(site_id, db)
+
+    async def _apply_verify_result(
+        cmd: asyncpg.Record,
+        actual_i: int,
+        *,
+        client: Any,
+        unit: int,
+    ) -> bool:
+        reg = int(cmd["register"])
+        cmd_id = int(cmd["id"])
+
+        if reg in DEYE_CLOCK_REGS:
+            asset_id = int(cmd["asset_id"])
+            host = str(cmd["device_host"])
+            port_i = int(cmd["device_port"])
+            uid = int(cmd["device_unit_id"])
+            bundle = await _fetch_written_deye_clock_commands(
+                site_id, asset_id, host, port_i, uid, db
+            )
+            if not bundle:
+                bundle = [cmd]
+            try:
+                cvals = await client.read_holding_registers(62, 3, uid)
+            except Exception as e:
+                logger.error(
+                    "verify clock guard read 62-64 failed (reg 0x%04X): %s", reg, e
+                )
+                return False
+            if len(cvals) != 3:
+                logger.error("verify clock guard: expected 3 regs, got %s", len(cvals))
+                return False
+            logger.warning(
+                "Clock register 0x%04X reached strict verify path; using tolerant 62-64 bundle",
+                reg,
+            )
+            return await _verify_deye_clock_written_bundle(
+                site_id,
+                bundle,
+                int(cvals[0]),
+                int(cvals[1]),
+                int(cvals[2]),
+                db,
+            )
+
+        expected_i = int(cmd["value_to_write"])
+        matches = actual_i == expected_i
+        if reg == 178:
+            first_178 = int(actual_i)
+            second_178: int | None = None
+            if not _deye_reg178_verify_match(expected_i, first_178):
+                try:
+                    r178 = await client.read_holding_registers(178, 1, unit)
+                    if r178 and len(r178) >= 1:
+                        second_178 = int(r178[0])
+                except Exception as e:
+                    logger.warning("[cmd %s] reg178 double-read failed: %s", cmd_id, e)
+            matches, actual_i = _deye_reg178_verify_with_double_read(
+                expected_i, first_178, second_178
+            )
+            if (
+                matches
+                and second_178 is not None
+                and not _deye_reg178_verify_match(expected_i, first_178)
+            ):
+                logger.info(
+                    "[cmd %s] reg178 double-read recovered: first=%s second=%s",
+                    cmd_id,
+                    first_178,
+                    second_178,
+                )
+        if not matches and reg in DEYE_TOU_POWER_REGS and inv_cfg is not None:
+            matches = _deye_tou_power_verify_match(expected_i, actual_i, inv_cfg)
+
+        await db.execute(
+            """
+            UPDATE ems.modbus_command
+            SET value_verified=$1::int, verified_at=now(),
+                status=CASE WHEN $2::boolean THEN 'verified' ELSE 'mismatch' END
+            WHERE id=$3::int
+            """,
+            actual_i,
+            matches,
+            cmd_id,
+        )
+
+        if not matches:
+            logger.error(
+                "[cmd %s] MISMATCH %s 0x%04X: expected=%s actual=%s%s",
+                cmd_id,
+                cmd["asset_code"],
+                reg,
+                expected_i,
+                actual_i,
+                " (reg178 mask 0x%04X)" % REG178_VERIFY_MASK if reg == 178 else "",
+            )
+            row_ac = await db.fetchrow(
+                "SELECT attempt_count FROM ems.modbus_command WHERE id=$1", cmd_id
+            )
+            attempts = int(row_ac["attempt_count"] or 0) if row_ac else 0
+            await notify_modbus_mismatch(
+                db,
+                site_id,
+                cmd["asset_code"],
+                reg,
+                cmd["register_name"] or "",
+                expected_i,
+                actual_i,
+                attempts,
+            )
+
+            if attempts < 3:
+                await db.execute(
+                    "UPDATE ems.modbus_command SET status='retrying' WHERE id=$1",
+                    cmd_id,
+                )
+                await execute_modbus_commands([cmd_id], db)
+                await verify_modbus_commands([cmd_id], db, site_id)
+            else:
+                if deye_reg_triggers_self_sustain_after_verify_exhaust(reg):
+                    logger.critical(
+                        "[cmd %s] 3 failed attempts, switching to SELF_SUSTAIN",
+                        cmd_id,
+                    )
+                    await _switch_to_self_sustain(
+                        site_id,
+                        db,
+                        reason=(
+                            f"Modbus mismatch po 3 pokusech: {cmd['asset_code']} "
+                            f"reg 0x{reg:04X}"
+                        ),
+                    )
+                else:
+                    logger.warning(
+                        "[cmd %s] 3 failed verify attempts on non-critical reg 0x%04X "
+                        "(no mode change): %s",
+                        cmd_id,
+                        reg,
+                        cmd["asset_code"],
+                    )
+            return False
+
+        if reg == 178 and actual_i != expected_i:
+            logger.info(
+                "[cmd %s] verified OK (reg178 masked): %s 0x%04X value_to_write=%s actual=%s",
+                cmd_id,
+                cmd["asset_code"],
+                reg,
+                expected_i,
+                actual_i,
+            )
+        else:
+            logger.info(
+                "[cmd %s] verified OK: %s 0x%04X=%s",
+                cmd_id,
+                cmd["asset_code"],
+                reg,
+                actual_i,
+            )
+        return True
+
+    cmds: list[asyncpg.Record] = []
+    for cmd_id in command_ids:
+        cmd = await db.fetchrow(
+            "SELECT * FROM ems.modbus_command WHERE id=$1", cmd_id
+        )
+        if cmd is not None and cmd["status"] == "written":
+            cmds.append(cmd)
+
+    if not cmds:
+        return True
+
+    by_gw: dict[tuple[str, int, int], list[asyncpg.Record]] = defaultdict(list)
+    for cmd in cmds:
+        by_gw[
+            (cmd["device_host"], int(cmd["device_port"]), int(cmd["device_unit_id"]))
+        ].append(cmd)
+
+    all_ok = True
+    for (host, port, unit), group in by_gw.items():
+        client = await get_modbus_client(host, port)
+        clock_cmds = [c for c in group if int(c["register"]) in DEYE_CLOCK_REGS]
+        rest = [c for c in group if int(c["register"]) not in DEYE_CLOCK_REGS]
+
+        if clock_cmds:
+            asset_id = int(clock_cmds[0]["asset_id"])
+            bundle = await _fetch_written_deye_clock_commands(
+                site_id, asset_id, host, port, unit, db
+            )
+            if not bundle:
+                bundle = clock_cmds
+            try:
+                cvals = await client.read_holding_registers(62, 3, unit)
+            except Exception as e:
+                logger.error("verify clock read 62-64 failed: %s", e)
+                all_ok = False
+            else:
+                if len(cvals) != 3:
+                    logger.error("verify clock read: expected 3 regs, got %s", len(cvals))
+                    all_ok = False
+                else:
+                    matched = await _verify_deye_clock_written_bundle(
+                        site_id,
+                        bundle,
+                        int(cvals[0]),
+                        int(cvals[1]),
+                        int(cvals[2]),
+                        db,
+                    )
+                    if not matched:
+                        all_ok = False
+
+        for run in _modbus_command_contiguous_runs(rest):
+            start_reg = int(run[0]["register"])
+            n = len(run)
+            try:
+                values = await client.read_holding_registers(start_reg, n, unit)
+            except Exception as e:
+                logger.error(
+                    "verify batch read 0x%04X count=%s failed: %s", start_reg, n, e
+                )
+                all_ok = False
+                continue
+            if len(values) != n:
+                logger.error(
+                    "verify read 0x%04X: expected %s regs, got %s",
+                    start_reg,
+                    n,
+                    len(values),
+                )
+                all_ok = False
+                continue
+            for cmd, actual in zip(run, values):
+                matched = await _apply_verify_result(
+                    cmd, int(actual), client=client, unit=unit
+                )
+                if not matched:
+                    all_ok = False
+
+    return all_ok

backend/services/planning_engine.py

@@ -14,7 +14,7 @@ import time
 from dataclasses import dataclass, replace
 from datetime import datetime, timezone, timedelta
 from types import SimpleNamespace
-from typing import Optional
+from typing import Any, Optional
 from zoneinfo import ZoneInfo
 
 import pulp
@@ -159,6 +159,13 @@ def _soc_security_profile(slots: list["PlanningSlot"], battery) -> tuple[float,
     return target_wh, penalty_czk_kwh
 
 
+def _slot_float_nullable(d: dict[str, Any], key: str) -> float | None:
+    v = d.get(key)
+    if v is None:
+        return None
+    return float(v)
+
+
 def _prague_dow_hour(interval_start: datetime) -> tuple[int, int]:
     """DOW v konvenci PostgreSQL EXTRACT(DOW, Europe/Prague): 0=Ne … 6=So."""
     dt = interval_start
@@ -185,6 +192,13 @@ class PlanningSlot:
     is_predicted_price: bool = False
     allow_charge: bool = True
     allow_discharge_export: bool = True
+    #: Měkké LP vstupy z `ems.fn_load_planning_slots_full` (mimo masky allow_*).
+    night_baseload_target_wh: float | None = None
+    night_baseload_buffer_wh: float | None = None
+    safety_soc_target_wh: float | None = None
+    future_avoided_buy_czk_kwh: float | None = None
+    future_sell_opportunity_czk_kwh: float | None = None
+    is_daytime_pv_surplus_slot: bool = False
 
 
 # Lookahead pro relax spodní meze SoC: až 36 h od indexu slotu (pevné OTE ceny v horizontu).
@@ -319,6 +333,8 @@ class DispatchResult:
     battery_setpoint_w: int  # kladné = nabíjení, záporné = vybíjení
     battery_soc_target: float  # % SoC na konci intervalu
     grid_setpoint_w: int  # kladné = import, záporné = export
+    export_limit_w: int  # tvrdý limit exportu do sítě; 0 = bez exportu
+    export_mode: str  # NONE / PV_SURPLUS / BATTERY_SELL
     #: Explicitní fyzický režim Deye pro control exporter (PASSIVE / SELL / CHARGE).
     #: Cíl: odstranit heuristiky z exporteru a nést záměr přímo v plánu.
     deye_physical_mode: str
@@ -436,10 +452,11 @@ def solve_dispatch(
     *,
     tuv_delta_stats: Optional[dict[tuple[int, int], float]] = None,
     operating_mode: str = "AUTO",
-) -> tuple[list[DispatchResult], int]:
+    charge_commitment_prev_w: Optional[list[Optional[float]]] = None,
+) -> tuple[list[DispatchResult], int, dict[str, Any]]:
     """
     LP solver pro dispatch optimalizaci.
-    Vrátí (výsledky, solver_duration_ms).
+    Vrátí (výsledky, solver_duration_ms, solver_debug_snapshot).
     """
     T = len(slots)
     if T < 1:
@@ -601,6 +618,33 @@ def solve_dispatch(
         t_anchor = first_neg_sell_idx - 1
         soc_anchor_slack = pulp.LpVariable("soc_anchor_slack_wh", 0, float(battery.usable_capacity_wh))
 
+    daytime_en = bool(getattr(battery, "planner_daytime_charge_target_enabled", True))
+    safety_pen_czk_per_wh: list[float] = []
+    safety_vars: list[Optional[pulp.LpVariable]] = []
+    for t in range(T):
+        sft = slots[t].safety_soc_target_wh if daytime_en else None
+        fb = float(slots[t].future_avoided_buy_czk_kwh or slots[t].buy_price)
+        fs = float(slots[t].future_sell_opportunity_czk_kwh or slots[t].sell_price)
+        bv = max(fb, fs) - float(degradation_cost_effective)
+        bv = max(0.0, min(5.0, bv))
+        safety_pen_czk_per_wh.append(bv / 1000.0 if sft is not None else 0.0)
+        if sft is not None:
+            safety_vars.append(
+                pulp.LpVariable(f"safety_def_{t}", 0, float(battery.usable_capacity_wh))
+            )
+        else:
+            safety_vars.append(None)
+
+    commit_pen = float(getattr(battery, "planner_charge_commitment_penalty_czk_kwh", 0.2))
+    commit_lp: list[tuple[int, pulp.LpVariable, float]] = []
+    if charge_commitment_prev_w is not None and len(charge_commitment_prev_w) == T:
+        for t in range(T):
+            prev = charge_commitment_prev_w[t]
+            if prev is not None and prev > 500:
+                cap_prev = float(prev)
+                cv = pulp.LpVariable(f"ccommit_{t}", 0, cap_prev)
+                commit_lp.append((t, cv, cap_prev))
+
     # --- Účelová funkce (jen OTE sloty; terminal SoC shadow price na konci horizontu) ---
     prob += (
         pulp.lpSum(
@@ -642,6 +686,12 @@ def solve_dispatch(
             if soc_anchor_slack is not None
             else 0
         )
+        + pulp.lpSum(
+            safety_vars[t] * safety_pen_czk_per_wh[t]
+            for t in range(T)
+            if safety_vars[t] is not None
+        )
+        + pulp.lpSum(cv * INTERVAL_H / 1000.0 * commit_pen for _t, cv, _p in commit_lp)
     )
 
     # --- Omezení ---
@@ -678,6 +728,11 @@ def solve_dispatch(
             - bd[t] / battery.discharge_efficiency  * INTERVAL_H
         )
 
+        sv = safety_vars[t]
+        tgt_s = slots[t].safety_soc_target_wh if daytime_en else None
+        if sv is not None and tgt_s is not None:
+            prob += sv >= float(tgt_s) - soc[t]
+
         # ev_via_bat kryto z discharge
         prob += pulp.lpSum(ev_via_bat[e][t] for e in range(EV)) <= bd[t]
 
@@ -760,6 +815,9 @@ def solve_dispatch(
             else:
                 prob += ev_direct[e][t] + ev_via_bat[e][t] <= vehicles[e].max_charge_power_w
 
+    for tt, cv, prev in commit_lp:
+        prob += cv >= prev - bc[tt]
+
     if om == "SELF_SUSTAIN":
         for t in range(T):
             prob += gi[t] <= slots[t].load_baseline_w
@@ -851,6 +909,10 @@ def solve_dispatch(
         batt_w     = round(pulp.value(bc[t]) - pulp.value(bd[t]))
         grid_w     = round(pulp.value(gi[t]) - pulp.value(ge[t]))
         soc_pct    = round(pulp.value(soc[t]) / battery.usable_capacity_wh * 100, 1)
+        export_limit_w = int(grid.max_export_power_w) if grid_w < 0 else 0
+        export_mode = "NONE"
+        if grid_w < 0:
+            export_mode = "BATTERY_SELL" if batt_w < 0 else "PV_SURPLUS"
 
         # Primární klasifikace fyzického režimu pro Deye: explicitně do plánu (Variant A).
         # Default PASSIVE; SELL při export+vybíjení; CHARGE při import+nabíjení.
@@ -874,6 +936,8 @@ def solve_dispatch(
             battery_setpoint_w   = batt_w,
             battery_soc_target   = soc_pct,
             grid_setpoint_w      = grid_w,
+            export_limit_w       = export_limit_w,
+            export_mode          = export_mode,
             deye_physical_mode   = deye_mode,
             deye_gen_cutoff_enabled = deye_gen_cutoff,
             ev1_setpoint_w       = round(pulp.value(ev_direct[0][t]) + pulp.value(ev_via_bat[0][t]))
@@ -891,7 +955,91 @@ def solve_dispatch(
             is_predicted_price   = bool(slots[t].is_predicted_price),
         ))
 
-    return results, duration_ms
+    sell_rank = sorted(range(T), key=lambda i: float(slots[i].sell_price), reverse=True)[: min(3, T)]
+    charge_commit_snapshot = [
+        {
+            "slot": slots[tt].interval_start.isoformat(),
+            "previous_charge_w": prev,
+            "shortfall_w": float(pulp.value(cv) or 0.0),
+        }
+        for tt, cv, prev in commit_lp
+    ]
+    masks_snap: list[dict[str, Any]] = []
+    soc_bounds_snap: list[dict[str, Any]] = []
+    objective_terms_snap: list[dict[str, Any]] = []
+    for t in range(T):
+        st = slots[t]
+        masks_snap.append(
+            {
+                "slot": st.interval_start.isoformat(),
+                "allow_charge": bool(st.allow_charge),
+                "allow_discharge_export": bool(st.allow_discharge_export),
+            }
+        )
+        tgt_s = st.safety_soc_target_wh if daytime_en else None
+        soc_bounds_snap.append(
+            {
+                "slot": st.interval_start.isoformat(),
+                "soc_min_wh": float(soc_panel_min[t]),
+                "arb_floor_wh": float(arb_floor_series[t]),
+                "soc_panel_min_wh": float(soc_panel_min[t]),
+                "safety_soc_target_wh": float(tgt_s) if tgt_s is not None else None,
+            }
+        )
+        fb = float(st.future_avoided_buy_czk_kwh or st.buy_price)
+        fs = float(st.future_sell_opportunity_czk_kwh or st.sell_price)
+        bv = max(fb, fs) - float(degradation_cost_effective)
+        bv = max(0.0, min(5.0, bv))
+        pen_wh = bv / 1000.0 if tgt_s is not None else 0.0
+        sv = safety_vars[t]
+        sdv = float(pulp.value(sv) or 0.0) if sv is not None else None
+        cshort = next((float(pulp.value(cv) or 0.0) for tt, cv, _p in commit_lp if tt == t), None)
+        objective_terms_snap.append(
+            {
+                "slot": st.interval_start.isoformat(),
+                "buy_price": float(st.buy_price),
+                "sell_price": float(st.sell_price),
+                "future_avoided_buy_czk_kwh": float(st.future_avoided_buy_czk_kwh or st.buy_price),
+                "future_sell_opportunity_czk_kwh": float(
+                    st.future_sell_opportunity_czk_kwh or st.sell_price
+                ),
+                "battery_value_czk_kwh": float(bv),
+                "safety_deficit_penalty_czk_per_wh": float(pen_wh),
+                "safety_deficit_wh": sdv,
+                "commitment_shortfall_w": cshort,
+                "commitment_penalty_czk_kwh": float(commit_pen) if cshort is not None else None,
+            }
+        )
+    night0 = slots[0]
+    solver_snapshot: dict[str, Any] = {
+        "version": 1,
+        "inputs": {
+            "current_soc_wh": float(current_soc_wh),
+            "operating_mode": operating_mode,
+            "battery": {
+                "usable_capacity_wh": float(battery.usable_capacity_wh),
+                "min_soc_wh": float(battery.min_soc_wh),
+                "reserve_soc_wh": float(getattr(battery, "reserve_soc_wh", 0.0)),
+                "degradation_cost_czk_kwh": float(battery.degradation_cost_czk_kwh),
+                "planner_terminal_soc_value_factor": float(battery.planner_terminal_soc_value_factor),
+                "planner_daytime_charge_target_enabled": daytime_en,
+                "planner_charge_commitment_penalty_czk_kwh": float(commit_pen),
+            },
+        },
+        "masks": masks_snap,
+        "soc_bounds": soc_bounds_snap,
+        "objective_terms": objective_terms_snap,
+        "chosen_slots": {
+            "charge_commitment": charge_commit_snapshot,
+            "high_sell_windows": [slots[i].interval_start.isoformat() for i in sell_rank],
+            "night_window": {
+                "definition": "Europe/Prague 20:00–06:00 projected baseload Wh (fn_load_planning_slots_full)",
+                "target_wh": night0.night_baseload_target_wh,
+                "buffer_wh": night0.night_baseload_buffer_wh,
+            },
+        },
+    }
+    return results, duration_ms, solver_snapshot
 
 
 # ============================================================
@@ -922,7 +1070,7 @@ async def run_daily_plan(site_id: int, db, triggered_by: str = "scheduler:daily"
     )
     slots = await _load_slots(site_id, horizon_from, horizon_to, db, soc_wh=soc_wh)
 
-    results, duration_ms = solve_dispatch(
+    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",
@@ -942,6 +1090,7 @@ async def run_daily_plan(site_id: int, db, triggered_by: str = "scheduler:daily"
         correction=1.0,
         db=db,
         slot_inputs=slot_inputs,
+        solver_snapshot=solver_snapshot,
     )
     logger.info(f"[site={site_id}] Daily plan done in {duration_ms} ms")
     return run_id, duration_ms
@@ -1015,10 +1164,13 @@ async def run_rolling_replan(
 
     slots = apply_forecast_correction(slots, now, correction_factor)
 
-    results, duration_ms = solve_dispatch(
+    commitment_prev = await _load_previous_plan_charge_commitment_prev_w(site_id, slots, db)
+
+    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",
+        charge_commitment_prev_w=commitment_prev,
     )
 
     slot_inputs = _build_slot_inputs(slots_before_pv_correction, slots)
@@ -1035,6 +1187,7 @@ async def run_rolling_replan(
         correction=correction_factor,
         db=db,
         slot_inputs=slot_inputs,
+        solver_snapshot=solver_snapshot,
     )
 
     await db.execute(
@@ -1157,6 +1310,18 @@ async def _load_site_context(site_id: int, db):
         if relax_prewin is not None
         else DEFAULT_PLANNER_DISCHARGE_RELAX_PREWINDOW_SLOTS,
         planner_terminal_soc_value_factor=float(b["planner_terminal_soc_value_factor"]),
+        planner_daytime_charge_target_enabled=bool(
+            b.get("planner_daytime_charge_target_enabled", True)
+        ),
+        planner_night_baseload_buffer_percent=float(
+            b.get("planner_night_baseload_buffer_percent") or 20.0
+        ),
+        planner_daytime_charge_price_quantile=float(
+            b.get("planner_daytime_charge_price_quantile") or 0.70
+        ),
+        planner_charge_commitment_penalty_czk_kwh=float(
+            b.get("planner_charge_commitment_penalty_czk_kwh") or 0.20
+        ),
     )
 
     hpj = ctx["heat_pump"]
@@ -1219,6 +1384,51 @@ async def _load_site_context(site_id: int, db):
     )
 
 
+async def _load_previous_plan_charge_commitment_prev_w(
+    site_id: int,
+    slots: list[PlanningSlot],
+    db,
+) -> list[Optional[float]]:
+    """
+    Pro rolling replan: z aktivního plánu načte battery_setpoint_w pro shodné sloty.
+    Kotva měkkého commitmentu jen když předchozí plán chtěl nabíjet z PV přebytku (viz podmínky).
+    """
+    if not slots:
+        return []
+    rows = await db.fetch(
+        """
+        select pi.interval_start,
+               pi.battery_setpoint_w,
+               pi.grid_setpoint_w,
+               coalesce(pi.pv_a_forecast_solver_w, 0) as pva,
+               coalesce(pi.pv_b_forecast_solver_w, 0) as pvb,
+               coalesce(pi.load_baseline_w, 0) as lb
+        from ems.planning_interval pi
+        inner join ems.planning_run pr on pr.id = pi.run_id
+        where pr.site_id = $1::int
+          and pr.status = 'active'
+        """,
+        site_id,
+    )
+    by_start = {r["interval_start"]: r for r in rows}
+    out: list[Optional[float]] = []
+    for s in slots:
+        r = by_start.get(s.interval_start)
+        if r is None:
+            out.append(None)
+            continue
+        bw = int(r["battery_setpoint_w"] or 0)
+        gw = int(r["grid_setpoint_w"] or 0)
+        pva = int(r["pva"] or 0)
+        pvb = int(r["pvb"] or 0)
+        lb = int(r["lb"] or 0)
+        if bw > 500 and (pva + pvb) > lb and gw <= 0:
+            out.append(float(bw))
+        else:
+            out.append(None)
+    return out
+
+
 async def _load_slots(
     site_id: int,
     from_dt: datetime,
@@ -1232,7 +1442,10 @@ async def _load_slots(
         """
         select slot_ord, interval_start, buy_price, sell_price, is_predicted_price,
                pv_a_forecast_w, pv_b_forecast_w, load_baseline_w,
-               ev1_connected, ev2_connected, allow_charge, allow_discharge_export
+               ev1_connected, ev2_connected, allow_charge, allow_discharge_export,
+               night_baseload_target_wh, night_baseload_buffer_wh, safety_soc_target_wh,
+               future_avoided_buy_czk_kwh, future_sell_opportunity_czk_kwh,
+               is_daytime_pv_surplus_slot
         from ems.fn_load_planning_slots_full(
           $1::int, $2::timestamptz, $3::timestamptz, $4::numeric
         )
@@ -1258,6 +1471,14 @@ async def _load_slots(
                 is_predicted_price=bool(d.get("is_predicted_price")),
                 allow_charge=bool(d.get("allow_charge", True)),
                 allow_discharge_export=bool(d.get("allow_discharge_export", True)),
+                night_baseload_target_wh=_slot_float_nullable(d, "night_baseload_target_wh"),
+                night_baseload_buffer_wh=_slot_float_nullable(d, "night_baseload_buffer_wh"),
+                safety_soc_target_wh=_slot_float_nullable(d, "safety_soc_target_wh"),
+                future_avoided_buy_czk_kwh=_slot_float_nullable(d, "future_avoided_buy_czk_kwh"),
+                future_sell_opportunity_czk_kwh=_slot_float_nullable(
+                    d, "future_sell_opportunity_czk_kwh"
+                ),
+                is_daytime_pv_surplus_slot=bool(d.get("is_daytime_pv_surplus_slot", False)),
             )
         )
     if not out:
@@ -1298,11 +1519,13 @@ async def _save_planning_run(
     run_type, triggered_by, replan_from,
     soc_wh, duration_ms, correction, db,
     slot_inputs: Optional[list[tuple[int, int, int, int, int]]] = None,
+    *,
+    solver_snapshot: Optional[dict[str, Any]] = None,
 ) -> int:
     """Uloží výsledky solveru přes ems.fn_planning_run_commit."""
     if slot_inputs is not None and len(slot_inputs) != len(results):
         raise ValueError("slot_inputs and results length mismatch")
-    run_meta = {
+    run_meta: dict[str, Any] = {
         "run_type": run_type,
         "triggered_by": triggered_by,
         "replan_from": replan_from.isoformat() if replan_from else None,
@@ -1310,6 +1533,8 @@ async def _save_planning_run(
         "solver_duration_ms": duration_ms,
         "forecast_correction_factor": correction,
     }
+    if solver_snapshot is not None:
+        run_meta["solver_params"] = solver_snapshot
     intervals: list[dict] = []
     for i, r in enumerate(results):
         row: dict = {
@@ -1319,6 +1544,8 @@ async def _save_planning_run(
             "battery_setpoint_w": r.battery_setpoint_w,
             "battery_soc_target_pct": r.battery_soc_target,
             "grid_setpoint_w": r.grid_setpoint_w,
+            "export_limit_w": r.export_limit_w,
+            "export_mode": r.export_mode,
             "deye_physical_mode": r.deye_physical_mode,
             "deye_gen_cutoff_enabled": r.deye_gen_cutoff_enabled,
             "ev1_setpoint_w": r.ev1_setpoint_w,

backend/services/signal_service.py

@@ -178,6 +178,10 @@ async def compute_export_ban_active(site_id: int, conn: asyncpg.Connection) -> b
     if bool(pi.get("is_predicted_price")):
         return True
 
+    export_mode = str(pi.get("export_mode") or "").upper()
+    if export_mode in ("PV_SURPLUS", "BATTERY_SELL"):
+        return False
+
     sell_raw = pi.get("effective_sell_price")
     grid_sp = int(pi.get("grid_setpoint_w") or 0)
     if sell_raw is None:

backend/tests/test_control_deye_passive_pv_charge.py

@@ -0,0 +1,52 @@
+"""PASSIVE + nabíjení z PV přebytku při současném exportu → nenulový nabíjecí proud."""
+
+from __future__ import annotations
+
+import unittest
+
+from services.control.setpoints import deye_battery_charge_discharge_amps
+
+
+class PassivePvSurplusChargeAmpsTests(unittest.TestCase):
+    def test_passive_charge_while_exporting_grid_negative(self) -> None:
+        ch, dis = deye_battery_charge_discharge_amps(
+            lock_battery=False,
+            deye_mode="PASSIVE",
+            self_sustain_local_use=False,
+            bat_w=5000,
+            grid_w=-2000,
+            max_charge_a=100,
+            max_discharge_a=100,
+        )
+        self.assertGreater(ch, 0)
+        self.assertEqual(dis, 0)
+
+    def test_passive_zero_export_still_zero_charge_when_no_battery_charge(self) -> None:
+        ch, dis = deye_battery_charge_discharge_amps(
+            lock_battery=False,
+            deye_mode="PASSIVE",
+            self_sustain_local_use=False,
+            bat_w=0,
+            grid_w=-2000,
+            max_charge_a=100,
+            max_discharge_a=100,
+        )
+        self.assertEqual(ch, 0)
+        self.assertEqual(dis, 100)
+
+    def test_sell_unchanged(self) -> None:
+        ch, dis = deye_battery_charge_discharge_amps(
+            lock_battery=False,
+            deye_mode="SELL",
+            self_sustain_local_use=False,
+            bat_w=-3000,
+            grid_w=-2000,
+            max_charge_a=100,
+            max_discharge_a=80,
+        )
+        self.assertEqual(ch, 0)
+        self.assertEqual(dis, 80)
+
+
+if __name__ == "__main__":
+    unittest.main()

backend/tests/test_control_exporter_tou.py

@@ -15,6 +15,8 @@ from services.control.exporter_monolith import (
     deye_reg_triggers_self_sustain_after_verify_exhaust,
     get_deye_mode,
 )
+from services.control.models import OperatingModeInfo
+from services.control.setpoints import _build_setpoints
 
 
 def _inv(*, min_soc: int | None = 12, reserve_soc: int | None = 20) -> InverterConfig:
@@ -110,6 +112,30 @@ class DeyeTouParamsTests(unittest.TestCase):
         )
         self.assertEqual(get_deye_mode(sp), "PASSIVE")
 
+    def test_build_setpoints_uses_explicit_export_limit(self) -> None:
+        mode = OperatingModeInfo(
+            mode_code="AUTO",
+            battery_mode="AUTO",
+            grid_mode="AUTO",
+            ev_enabled=False,
+            heat_pump_enabled_def=False,
+            loxone_mode_value=1,
+        )
+        pi = {
+            "battery_setpoint_w": 0,
+            "grid_setpoint_w": -3000,
+            "export_limit_w": 13_500,
+            "export_mode": "PV_SURPLUS",
+            "ev1_setpoint_w": 0,
+            "ev2_setpoint_w": 0,
+            "heat_pump_enabled": False,
+            "battery_soc_target_pct": 50,
+            "effective_sell_price": 1.0,
+        }
+        sp = _build_setpoints(mode, pi)
+        self.assertIsNotNone(sp)
+        self.assertEqual(sp.grid_export_limit, 13_500)
+
     def test_pv_led_export_with_small_battery_is_sell(self) -> None:
         """Obě záporné → SELL (bez porovnání |bat| vs |grid|)."""
         sp = ControlSetpoints(

backend/tests/test_planning_dispatch_milp.py

@@ -237,7 +237,7 @@ class PlanningDispatchMilpTests(unittest.TestCase):
             ),
         ]
         soc0 = 0.50 * battery.usable_capacity_wh
-        results, _ms = solve_dispatch(
+        results, _ms, _ = solve_dispatch(
             slots,
             battery,
             hp,
@@ -254,6 +254,47 @@ class PlanningDispatchMilpTests(unittest.TestCase):
         self.assertEqual(int(results[0].pv_a_curtailed_w), 5000)
         self.assertGreaterEqual(int(results[0].grid_setpoint_w), 0)
 
+    def test_pv_surplus_export_uses_hard_export_cap(self) -> None:
+        slots = [
+            _slot(load=0, buy=3.0, sell=2.5, pv_a=20_000, pv_b=0),
+        ]
+        battery = _battery()
+        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=13_500)
+        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,
+            ),
+        ]
+        soc0 = battery.soc_max_wh
+        results, _ms, _ = solve_dispatch(
+            slots,
+            battery,
+            hp,
+            grid,
+            [None, None],
+            vehicles,
+            soc0,
+            50.0,
+            tuv_delta_stats=None,
+            operating_mode="AUTO",
+        )
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0].export_mode, "PV_SURPLUS")
+        self.assertEqual(results[0].export_limit_w, 13_500)
+        self.assertGreater(results[0].pv_a_curtailed_w, 0)
+
     def test_two_tier_soc_solves_optimal(self) -> None:
         slots = [_slot()]
         battery = _battery()
@@ -276,7 +317,7 @@ class PlanningDispatchMilpTests(unittest.TestCase):
             ),
         ]
         soc0 = 0.15 * battery.usable_capacity_wh
-        results, ms = solve_dispatch(
+        results, ms, _ = solve_dispatch(
             slots,
             battery,
             hp,
@@ -316,7 +357,7 @@ class PlanningDispatchMilpTests(unittest.TestCase):
             ),
         ]
         soc0 = 0.12 * battery.usable_capacity_wh
-        results, _ms = solve_dispatch(
+        results, _ms, _ = solve_dispatch(
             slots,
             battery,
             hp,
@@ -352,7 +393,7 @@ class PlanningDispatchMilpTests(unittest.TestCase):
             ),
         ]
         soc0 = 0.5 * battery.usable_capacity_wh
-        results, _ms = solve_dispatch(
+        results, _ms, _ = solve_dispatch(
             slots,
             battery,
             hp,
@@ -392,7 +433,7 @@ class PlanningDispatchMilpTests(unittest.TestCase):
             ),
         ]
         soc0 = 0.22 * battery.usable_capacity_wh
-        results, _ms = solve_dispatch(
+        results, _ms, _ = solve_dispatch(
             slots,
             battery,
             hp,
@@ -470,7 +511,7 @@ class PlanningDispatchMilpTests(unittest.TestCase):
             ),
         ]
         soc0 = 0.88 * battery.usable_capacity_wh
-        results, _ms = solve_dispatch(
+        results, _ms, _ = solve_dispatch(
             slots,
             battery,
             hp,
@@ -552,7 +593,7 @@ class PlanningDispatchMilpTests(unittest.TestCase):
             SimpleNamespace(max_charge_power_w=0, battery_capacity_kwh=1.0, default_target_soc_pct=80.0),
         ]
         soc0 = 0.9 * battery.usable_capacity_wh
-        results, _ms = solve_dispatch(
+        results, _ms, _ = solve_dispatch(
             slots,
             battery,
             hp,
@@ -639,7 +680,7 @@ class PlanningDispatchMilpTests(unittest.TestCase):
             SimpleNamespace(max_charge_power_w=0, battery_capacity_kwh=1.0, default_target_soc_pct=80.0),
         ]
         soc0 = 0.9 * battery.usable_capacity_wh
-        results, _ms = solve_dispatch(
+        results, _ms, _ = solve_dispatch(
             slots,
             battery,
             hp,
@@ -714,7 +755,7 @@ class PlanningDispatchMilpTests(unittest.TestCase):
             SimpleNamespace(max_charge_power_w=0, battery_capacity_kwh=1.0, default_target_soc_pct=80.0),
         ]
         soc0 = 0.9 * battery.usable_capacity_wh
-        results, _ms = solve_dispatch(
+        results, _ms, _ = solve_dispatch(
             slots,
             battery,
             hp,
@@ -757,7 +798,7 @@ class PlanningDispatchMilpTests(unittest.TestCase):
             ),
         ]
         soc0 = 0.55 * battery.usable_capacity_wh
-        results, _ms = solve_dispatch(
+        results, _ms, _ = solve_dispatch(
             slots,
             battery,
             hp,
@@ -812,7 +853,7 @@ class PlanningDispatchMilpTests(unittest.TestCase):
             SimpleNamespace(max_charge_power_w=0, battery_capacity_kwh=1.0, default_target_soc_pct=80.0),
         ]
         soc0 = 0.55 * battery.usable_capacity_wh
-        results, _ms = solve_dispatch(
+        results, _ms, _ = solve_dispatch(
             slots,
             battery,
             hp,
@@ -872,7 +913,7 @@ class PlanningDispatchMilpTests(unittest.TestCase):
             ),
         ]
         soc0 = 0.34 * battery.usable_capacity_wh
-        results, _ms = solve_dispatch(
+        results, _ms, _ = solve_dispatch(
             slots,
             battery,
             hp,
@@ -942,7 +983,7 @@ class TerminalSocShadowTests(unittest.TestCase):
             ),
         ]
         soc0 = 0.5 * battery.usable_capacity_wh
-        results, _ms = solve_dispatch(
+        results, _ms, _ = solve_dispatch(
             slots,
             battery,
             hp,

backend/tests/test_planning_safety_commitment.py

@@ -0,0 +1,140 @@
+"""Měkké safety SoC a rolling charge commitment v solve_dispatch."""
+
+from __future__ import annotations
+
+import unittest
+from datetime import datetime, timedelta, timezone
+from types import SimpleNamespace
+
+from services.planning_engine import PlanningSlot, solve_dispatch
+
+
+def _bat(**kwargs: object) -> SimpleNamespace:
+    base = dict(
+        usable_capacity_wh=20_000.0,
+        min_soc_wh=2000.0,
+        arb_floor_wh=4000.0,
+        reserve_soc_wh=4000.0,
+        soc_max_wh=19_000.0,
+        charge_efficiency=0.95,
+        discharge_efficiency=0.95,
+        degradation_cost_czk_kwh=0.1,
+        max_charge_power_w=5000,
+        max_discharge_power_w=5000,
+        planner_terminal_soc_value_factor=0.2,
+        planner_extreme_buy_threshold_czk_kwh=-5.0,
+        planner_discharge_floor_percent=None,
+        planner_discharge_relax_prewindow_slots=8,
+        planner_daytime_charge_target_enabled=True,
+        planner_charge_commitment_penalty_czk_kwh=0.5,
+    )
+    base.update(kwargs)
+    return SimpleNamespace(**base)
+
+
+def _grid() -> SimpleNamespace:
+    return SimpleNamespace(
+        max_import_power_w=11_000,
+        max_export_power_w=11_000,
+        block_export_on_negative_sell=False,
+        deye_gen_microinverter_cutoff_enabled=False,
+    )
+
+
+def _hp() -> SimpleNamespace:
+    return SimpleNamespace(rated_heating_power_w=0, tuv_min_temp_c=45.0, tuv_target_temp_c=55.0)
+
+
+def _slot(
+    t0: datetime,
+    idx: int,
+    *,
+    buy: float = 3.0,
+    sell: float = 2.5,
+    pv_a: int = 0,
+    load: int = 1500,
+    safety: float | None = None,
+    fut_buy: float | None = None,
+    fut_sell: float | None = None,
+) -> PlanningSlot:
+    return PlanningSlot(
+        interval_start=t0 + timedelta(minutes=15 * idx),
+        buy_price=buy,
+        sell_price=sell,
+        pv_a_forecast_w=pv_a,
+        pv_b_forecast_w=0,
+        load_baseline_w=load,
+        ev1_connected=False,
+        ev2_connected=False,
+        allow_charge=True,
+        allow_discharge_export=True,
+        safety_soc_target_wh=safety,
+        future_avoided_buy_czk_kwh=fut_buy,
+        future_sell_opportunity_czk_kwh=fut_sell,
+    )
+
+
+class PlanningSafetyCommitmentTests(unittest.TestCase):
+    def test_solver_snapshot_has_version_and_masks(self) -> None:
+        t0 = datetime(2026, 5, 4, 8, 0, tzinfo=timezone.utc)
+        slots = [_slot(t0, i, buy=2.0, sell=2.0, pv_a=6000, load=1500) for i in range(8)]
+        hp, grid = _hp(), _grid()
+        vehicles = [
+            SimpleNamespace(max_charge_power_w=0, battery_capacity_kwh=1.0, default_target_soc_pct=80.0)
+        ] * 2
+        res, _ms, snap = solve_dispatch(
+            slots,
+            _bat(),
+            hp,
+            grid,
+            [None, None],
+            vehicles,
+            current_soc_wh=5000.0,
+            current_tuv_temp_c=50.0,
+            operating_mode="AUTO",
+        )
+        self.assertEqual(len(res), 8)
+        self.assertEqual(snap.get("version"), 1)
+        self.assertIn("masks", snap)
+        self.assertEqual(len(snap["masks"]), 8)
+
+    def test_charge_commitment_snapshot_populated(self) -> None:
+        """Rolling kotva: při předchozím nabíjení z PV se do snapshotu zapíše commitment."""
+        t0 = datetime(2026, 5, 4, 10, 0, tzinfo=timezone.utc)
+        slots = [_slot(t0, i, buy=1.5, sell=1.2, pv_a=8000, load=1000) for i in range(12)]
+        hp, grid = _hp(), _grid()
+        vehicles = [
+            SimpleNamespace(max_charge_power_w=0, battery_capacity_kwh=1.0, default_target_soc_pct=80.0)
+        ] * 2
+        prev = [None] * 12
+        prev[0] = 4000.0
+        _res1, _, snap1 = solve_dispatch(
+            slots,
+            _bat(),
+            hp,
+            grid,
+            [None, None],
+            vehicles,
+            current_soc_wh=4000.0,
+            current_tuv_temp_c=50.0,
+            operating_mode="AUTO",
+            charge_commitment_prev_w=prev,
+        )
+        self.assertTrue(snap1["chosen_slots"]["charge_commitment"])
+        _res2, _, snap2 = solve_dispatch(
+            slots,
+            _bat(),
+            hp,
+            grid,
+            [None, None],
+            vehicles,
+            current_soc_wh=4000.0,
+            current_tuv_temp_c=50.0,
+            operating_mode="AUTO",
+            charge_commitment_prev_w=None,
+        )
+        self.assertEqual(snap2["chosen_slots"]["charge_commitment"], [])
+
+
+if __name__ == "__main__":
+    unittest.main()

db/migration/V077__planner_safety_charge_asset_battery.sql

@@ -0,0 +1,25 @@
+-- Parametry pro denní „safety charge“ (měkké LP penalizace) a kotvu rolling replanu.
+
+alter table ems.asset_battery
+  add column if not exists planner_daytime_charge_target_enabled boolean not null default true;
+
+alter table ems.asset_battery
+  add column if not exists planner_night_baseload_buffer_percent numeric not null default 20;
+
+alter table ems.asset_battery
+  add column if not exists planner_daytime_charge_price_quantile numeric not null default 0.70;
+
+alter table ems.asset_battery
+  add column if not exists planner_charge_commitment_penalty_czk_kwh numeric not null default 0.20;
+
+comment on column ems.asset_battery.planner_daytime_charge_target_enabled is
+  'Zapíná SQL/LP měkké denní cíle SoC (safety) z fn_load_planning_slots_full; ne tvrdé allow_charge masky.';
+
+comment on column ems.asset_battery.planner_night_baseload_buffer_percent is
+  'Procentní přirážka k odhadu nočního baseload Wh (20 = +20 % k night_baseload_target_wh).';
+
+comment on column ems.asset_battery.planner_daytime_charge_price_quantile is
+  'Rezervováno pro budoucí výběr „drahých“ oken z cenové distribuce; v1 se v LP nepoužívá.';
+
+comment on column ems.asset_battery.planner_charge_commitment_penalty_czk_kwh is
+  'Koeficient měkké penalizace (Kč/kWh krátkého nedodržení) proti předchozímu plánu při rolling replanu.';

db/routines/R__037_fn_planning_run_commit.sql

@@ -23,7 +23,8 @@ begin
   insert into ems.planning_run (
     site_id, horizon_start, horizon_end, status,
     run_type, triggered_by, replan_from,
-    soc_at_replan_wh, solver_duration_ms, forecast_correction_factor
+    soc_at_replan_wh, solver_duration_ms, forecast_correction_factor,
+    solver_params
   ) values (
     p_site_id,
     p_horizon_start,
@@ -39,7 +40,12 @@ begin
     end,
     (p_run_meta->>'soc_at_replan_wh')::numeric,
     (p_run_meta->>'solver_duration_ms')::int,
-    (p_run_meta->>'forecast_correction_factor')::numeric
+    (p_run_meta->>'forecast_correction_factor')::numeric,
+    case
+      when p_run_meta ? 'solver_params' and jsonb_typeof(p_run_meta->'solver_params') = 'object'
+      then p_run_meta->'solver_params'
+      else null::jsonb
+    end
   )
   returning id into v_run_id;
 

db/routines/R__039_fn_planning_site_context.sql

@@ -67,7 +67,11 @@ begin
     )::int,
     'charge_slot_buffer', ab.charge_slot_buffer,
     'discharge_slot_buffer', ab.discharge_slot_buffer,
-    'planner_terminal_soc_value_factor', ab.planner_terminal_soc_value_factor
+    'planner_terminal_soc_value_factor', ab.planner_terminal_soc_value_factor,
+    'planner_daytime_charge_target_enabled', coalesce(ab.planner_daytime_charge_target_enabled, true),
+    'planner_night_baseload_buffer_percent', coalesce(ab.planner_night_baseload_buffer_percent, 20::numeric),
+    'planner_daytime_charge_price_quantile', coalesce(ab.planner_daytime_charge_price_quantile, 0.70::numeric),
+    'planner_charge_commitment_penalty_czk_kwh', coalesce(ab.planner_charge_commitment_penalty_czk_kwh, 0.20::numeric)
   )
   into v_b
   from ems.asset_battery ab

db/routines/R__063_fn_load_planning_slots_full.sql

@@ -1,4 +1,10 @@
 -- sloty pro LP: ceny, forecast, baseline, EV připojení + masky allow_charge / allow_discharge_export
+-- DROP: změna RETURNS TABLE (nové sloupce) — CREATE OR REPLACE na rozdílný row type v PG neprojde.
+-- Musí být plná signatura (pg_proc ukládá int jako integer); DROP bez () funkci se směrem nemaže.
+
+drop function if exists ems.fn_load_planning_slots_full(
+  integer, timestamp with time zone, timestamp with time zone, numeric
+);
 
 create or replace function ems.fn_load_planning_slots_full(
   p_site_id int,
@@ -18,7 +24,13 @@ returns table (
   ev1_connected boolean,
   ev2_connected boolean,
   allow_charge boolean,
-  allow_discharge_export boolean
+  allow_discharge_export boolean,
+  night_baseload_target_wh numeric,
+  night_baseload_buffer_wh numeric,
+  safety_soc_target_wh numeric,
+  future_avoided_buy_czk_kwh numeric,
+  future_sell_opportunity_czk_kwh numeric,
+  is_daytime_pv_surplus_slot boolean
 )
 language plpgsql
 volatile
@@ -47,6 +59,9 @@ declare
   v_chg_pm_wh numeric;
   v_dis_am_wh numeric;
   v_dis_pm_wh numeric;
+  v_reserve_wh numeric;
+  v_daytime_en boolean;
+  v_night_buf_pct numeric;
 begin
   drop table if exists _ems_plan_slot_wk;
   create temp table _ems_plan_slot_wk on commit drop as
@@ -280,7 +295,10 @@ begin
         coalesce(ai.max_battery_discharge_w, ai.max_discharge_power_w)
       )
     )::numeric,
-    greatest(coalesce(ab.discharge_efficiency, 1::numeric), 0.0001::numeric)
+    greatest(coalesce(ab.discharge_efficiency, 1::numeric), 0.0001::numeric),
+    (ab.reserve_soc_percent / 100.0 * ab.usable_capacity_wh)::numeric,
+    coalesce(ab.planner_daytime_charge_target_enabled, true),
+    coalesce(ab.planner_night_baseload_buffer_percent, 20::numeric)
   into
     v_charge_buf,
     v_discharge_buf,
@@ -290,7 +308,10 @@ begin
     v_charge_eff,
     v_max_charge_w,
     v_max_discharge_w,
-    v_discharge_eff
+    v_discharge_eff,
+    v_reserve_wh,
+    v_daytime_en,
+    v_night_buf_pct
   from ems.asset_battery ab
   join ems.asset_inverter ai on ai.id = ab.inverter_id and ai.site_id = ab.site_id
   where ab.site_id = p_site_id
@@ -395,25 +416,97 @@ begin
   end if;
 
   return query
+  with night_tot as (
+    select coalesce(sum(w2.load_baseline_w), 0) * 0.25 as night_wh
+    from _ems_plan_slot_wk w2
+    where extract(hour from w2.interval_start at time zone 'Europe/Prague') >= 20
+       or extract(hour from w2.interval_start at time zone 'Europe/Prague') < 6
+  ),
+  enriched as (
+    select
+      w.slot_ord,
+      w.interval_start,
+      w.buy_price,
+      w.sell_price,
+      w.is_predicted_price,
+      w.pv_a_forecast_w,
+      w.pv_b_forecast_w,
+      w.load_baseline_w,
+      w.ev1_connected,
+      w.ev2_connected,
+      w.allow_charge,
+      w.allow_discharge_export,
+      nt.night_wh as night_baseload_target_wh,
+      nt.night_wh * (v_night_buf_pct / 100.0) as night_baseload_buffer_wh,
+      case
+        when not v_daytime_en then null::numeric
+        when extract(hour from w.interval_start at time zone 'Europe/Prague') between 6 and 19 then
+          least(
+            v_soc_max_wh,
+            v_reserve_wh + (nt.night_wh + nt.night_wh * (v_night_buf_pct / 100.0))
+              * greatest(
+                0::numeric,
+                least(
+                  1::numeric,
+                  (
+                    extract(hour from w.interval_start at time zone 'Europe/Prague')::numeric
+                    + (
+                      extract(minute from w.interval_start at time zone 'Europe/Prague')::numeric
+                      / 60.0
+                    )
+                    - 6.0
+                  ) / 14.0
+                )
+              )
+          )
+        else null::numeric
+      end as safety_soc_target_wh,
+      coalesce(
+        max(w.buy_price) over (
+          order by w.slot_ord rows between 1 following and unbounded following
+        ),
+        w.buy_price
+      ) as future_avoided_buy_czk_kwh,
+      coalesce(
+        max(w.sell_price) over (
+          order by w.slot_ord rows between 1 following and unbounded following
+        ),
+        w.sell_price
+      ) as future_sell_opportunity_czk_kwh,
+      (
+        extract(hour from w.interval_start at time zone 'Europe/Prague') between 6 and 18
+        and w.pv_surplus_w > 0
+      ) as is_daytime_pv_surplus_slot
+    from _ems_plan_slot_wk w
+    cross join night_tot nt
+  )
   select
-    w.slot_ord,
-    w.interval_start,
-    w.buy_price,
-    w.sell_price,
-    w.is_predicted_price,
-    w.pv_a_forecast_w,
-    w.pv_b_forecast_w,
-    w.load_baseline_w,
-    w.ev1_connected,
-    w.ev2_connected,
-    w.allow_charge,
-    w.allow_discharge_export
-  from _ems_plan_slot_wk w
-  order by w.slot_ord;
+    e.slot_ord,
+    e.interval_start,
+    e.buy_price,
+    e.sell_price,
+    e.is_predicted_price,
+    e.pv_a_forecast_w,
+    e.pv_b_forecast_w,
+    e.load_baseline_w,
+    e.ev1_connected,
+    e.ev2_connected,
+    e.allow_charge,
+    e.allow_discharge_export,
+    e.night_baseload_target_wh,
+    e.night_baseload_buffer_wh,
+    e.safety_soc_target_wh,
+    e.future_avoided_buy_czk_kwh,
+    e.future_sell_opportunity_czk_kwh,
+    e.is_daytime_pv_surplus_slot
+  from enriched e
+  order by e.slot_ord;
 end;
 $fn$;
 
-comment on function ems.fn_load_planning_slots_full(int, timestamptz, timestamptz, numeric) is
+comment on function ems.fn_load_planning_slots_full is
   '15min sloty s cenami, forecastem, baseline a maskami proti mikro-cyklu (charge/discharge-export). '
   'Masky charge/discharge-export se berou zvlášť pro 00–12 a 12–24 Europe/Prague (polovina budgetu na segment). '
-  'Strop SoC pro výpočet energie k dobití: coalesce(planner_max_soc_percent, max_soc_percent).';
+  '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), '
+  'lookahead max buy/sell pro měkké LP penalizace.';

db/routines/R__087_fn_planning_run_debug.sql

@@ -0,0 +1,76 @@
+-- Kompaktní JSON pro diagnostiku jednoho planning_run (MCP / UI).
+
+create or replace function ems.fn_planning_run_debug(p_run_id int)
+returns jsonb
+language plpgsql
+stable
+as $fn$
+declare
+  r_run ems.planning_run%rowtype;
+  v_intervals jsonb;
+  v_first_charge timestamptz;
+  v_first_bat_export timestamptz;
+  v_top_sell jsonb;
+begin
+  select * into r_run from ems.planning_run where id = p_run_id;
+  if not found then
+    return null::jsonb;
+  end if;
+
+  select coalesce(jsonb_agg(to_jsonb(pi.*) order by pi.interval_start), '[]'::jsonb)
+  into v_intervals
+  from ems.planning_interval pi
+  where pi.run_id = p_run_id;
+
+  select pi.interval_start
+  into v_first_charge
+  from ems.planning_interval pi
+  where pi.run_id = p_run_id
+    and coalesce(pi.battery_setpoint_w, 0) > 500
+  order by pi.interval_start
+  limit 1;
+
+  select pi.interval_start
+  into v_first_bat_export
+  from ems.planning_interval pi
+  where pi.run_id = p_run_id
+    and coalesce(pi.battery_setpoint_w, 0) < -500
+    and coalesce(pi.grid_setpoint_w, 0) < 0
+  order by pi.interval_start
+  limit 1;
+
+  select coalesce(
+    jsonb_agg(
+      jsonb_build_object(
+        'interval_start', x.interval_start,
+        'effective_sell_price', x.effective_sell_price
+      )
+      order by x.effective_sell_price desc nulls last
+    ),
+    '[]'::jsonb
+  )
+  into v_top_sell
+  from (
+    select pi.interval_start, pi.effective_sell_price
+    from ems.planning_interval pi
+    where pi.run_id = p_run_id
+    order by pi.effective_sell_price desc nulls last
+    limit 3
+  ) x;
+
+  return jsonb_build_object(
+    'planning_run', to_jsonb(r_run),
+    'solver_params', r_run.solver_params,
+    'intervals', v_intervals,
+    'summary', jsonb_build_object(
+      'first_charge_slot', to_jsonb(v_first_charge),
+      'first_battery_export_slot', to_jsonb(v_first_bat_export),
+      'top_sell_slots', v_top_sell,
+      'solver_params_version', r_run.solver_params->'version'
+    )
+  );
+end;
+$fn$;
+
+comment on function ems.fn_planning_run_debug(int) is
+  'Jeden jsonb: metadata planning_run, solver_params, všechny planning_interval řádky a krátký summary.';

docs/03-data-model.md

@@ -127,6 +127,8 @@ CREATE TABLE asset_battery (
     -- planner_max_soc_percent, planner_discharge_floor_percent,
     -- planner_extreme_buy_threshold_czk_kwh,
     -- planner_terminal_soc_value_factor
+    -- V077: planner_daytime_charge_target_enabled, planner_night_baseload_buffer_percent,
+    -- planner_daytime_charge_price_quantile, planner_charge_commitment_penalty_czk_kwh
 );
 ```
 
@@ -359,7 +361,7 @@ CREATE TABLE planning_run (
     horizon_end     TIMESTAMPTZ NOT NULL,
     created_at      TIMESTAMPTZ DEFAULT now(),
     status          TEXT DEFAULT 'draft',   -- 'draft', 'approved', 'active', 'superseded'
-    solver_params   JSONB,
+    solver_params   JSONB,  -- po V077: JSON z planning_engine (masks, soc_bounds, objective_terms, …)
     notes           TEXT
 );
 ```

docs/04-modules/control.md

@@ -150,9 +150,9 @@ bits 0–1). Detail registrů: [`modbus-registers.md`](modbus-registers.md) (reg
 |---|---|
 | **SELL** | `grid_setpoint_w` < 0 **a** `battery_w` < 0 |
 | **CHARGE** | `battery_w` > 0 **a** `grid_setpoint_w` > 0 |
-| **PASSIVE (ZERO)** | vše ostatní — reg. **108/109** dle `_deye_zero_export_amps_for_passive` (viz `operating-modes.md`) |
+| **PASSIVE (ZERO)** | vše ostatní — reg. **108/109** z `deye_battery_charge_discharge_amps()` v `setpoints.py` (volá `write_inverter_setpoints`) |
 
-**PASSIVE** (AUTO, ZERO): výchozí **108** i **109** = maximum z DB; u exportu bez vybíjení **108 = 0**, u importu bez nabíjení **109 = 0** (`_deye_zero_export_amps_for_passive`). **TOU** z plánu. Reg. **142** = `deye_zero_export_mode`. Reg. **145** (solar sell): **0** při `export_ban` mimo SELL, jinak **1** — význam přepínače a rozdíl vůči neřízeným FVE polím je v [`operating-modes.md`](operating-modes.md) (sekce *ZERO a zakázaný export*).
+**PASSIVE** (AUTO, ZERO): proudy **108/109** počítá **`deye_battery_charge_discharge_amps`**: pokud plán žádá **nabíjení** (`battery_w > 0`) včetně scénáře **PV přebytek + export do sítě** (`grid_setpoint_w < 0`), nastaví se **kladný nabíjecí proud (108)** a **109 = 0** — nesmí se použít čistě „zero export“ větev, která by při exportu vynutila **108 = 0** a rozbila soulad plán ↔ Deye. Jinak platí `_deye_zero_export_amps_for_passive` (export bez nabíjení → 108 = 0, import bez vybíjení → 109 = 0). **TOU** z plánu. Reg. **142** = `deye_zero_export_mode`. Reg. **143** je tvrdý limit exportu z lokality/invertoru (ne forecast). Reg. **145** (solar sell): **0** při `export_ban` mimo SELL, jinak **1** — význam přepínače a rozdíl vůči neřízeným FVE polím je v [`operating-modes.md`](operating-modes.md) (sekce *ZERO a zakázaný export*).
 
 **SELF_SUSTAIN** zůstává **PASSIVE** v `get_deye_mode`; **108/109** jsou vždy **max z DB** (bez variant ZERO). Rozdíl je **`self_sustain_local_use=True`**: **TOU SOC** = **`min_soc_percent`**, `battery_w=None`.
 
@@ -160,10 +160,10 @@ bits 0–1). Detail registrů: [`modbus-registers.md`](modbus-registers.md) (reg
 
 | Registr | Charge | PASSIVE (ZERO) | SELL | Self-consumption |
 |---|---|---|---|---|
-| **108** (charge A) | škálo dle `battery_w` | max / **0** (FVE přetok) | **0** | dle varianty |
-| **109** (discharge A) | **0** | max / **0** (import, držet bat.) | **max z DB** | dle varianty |
+| **108** (charge A) | škálo dle `battery_w` | max / **0** (export bez `battery_w>0`) / **>0** při `battery_w>0` i při exportu | **0** | dle varianty |
+| **109** (discharge A) | **0** | max / **0** (import, držet bat.) / **0** při `battery_w>0` + export z PV | **max z DB** | dle varianty |
 | **142** (limit control) | `deye_zero_export_mode` | `deye_zero_export_mode` | **0** (selling first) | `deye_zero_export_mode` |
-| **143** (export cap) | max z DB | max z DB | `min(max_site, max(200, \|grid_setpoint_w\|))` | max z DB |
+| **143** (export cap) | max z DB | max z DB | max z DB (tvrdý limit, bez forecast heuristiky) | max z DB |
 | **145** (solar sell) | 1 / 0 při `export_ban` | 1 / 0 při `export_ban` | 1 | 1 / 0 při `export_ban` |
 | **178** (peak shaving) | 48 | 48 | **32** | 48 |
 
@@ -207,7 +207,7 @@ async def write_inverter_setpoints(site_id: int, setpoints: Setpoints, db):
                                             slave=inv.unit_id)
 
             # Export limit
-            export_limit = max(0, -setpoints.grid_setpoint_w) if setpoints.grid_setpoint_w < 0 else 0
+            export_limit = setpoints.grid_export_limit
             await client.write_register(0x00F6, export_limit, slave=inv.unit_id)
 
         logger.info(f"Inverter {inv.code} setpoints written: batt={setpoints.battery_setpoint_w}W")

docs/04-modules/modbus-registers.md

@@ -20,7 +20,7 @@ EMS zapisuje řídící hodnoty přes journal (`modbus_command`) a **`write_regi
 | 142 | Limit control (System work mode) | 0/1/2 | — | **0** = selling first, **1** = zero export to load, **2** = zero export to CT. Hodnota v non-SELL režimech pochází z `asset_inverter.deye_zero_export_mode` (závisí na instalaci – viz tabulka níže). V režimu SELL vždy **0**. |
 | 145 | Solar sell | 0/1 | — | **0** = disabled (přebytek FVE na **straně měniče** se nesmí vést do sítě — curtailment vůči síti), **1** = enabled. Platí jen pro **FVE pod kontrolou Deye** (`controllable = true`); druhá pole (např. **pv-b** u home-01) EMS tímto registerem neřídí. EMS dnes **vždy zapisuje 1**; při 108 = 0 a 145 = 1 přebytky z řiditelného stringu typicky tečou do sítě (viz pass-through níže). |
 | 340 | Max solar power | 0 … cap (W) | 1 W | Strop výkonu DC PV řízeného střídačem (pole A). EMS zapisuje jen pokud `ems.fn_site_has_active_green_bonus_pv(site_id)` (zelený bonus na PV poli) **a** `ems.fn_inverter_pv_a_max_w(inverter_id) > 0`. Hodnota z aktivního `planning_interval`: bez curtailmentu = cap; s `pv_a_curtailed_w > 0` = `clamp(0, cap, pv_a_forecast_solver_w − pv_a_curtailed_w)`. **Není** v `DEYE_CRITICAL_REGS_SELF_SUSTAIN` — verify mismatch nečeká přepnutí do SELF_SUSTAIN. |
-| 143 | Export limit W | závisí na typu (SUN-20K až ~13 500) | 1 W | Max export do sítě; hodnota z `site_grid_connection.max_export_power_w` |
+| 143 | Export limit W | závisí na typu (SUN-20K až ~13 500) | 1 W | Max export do sítě; hodnota z `site_grid_connection.max_export_power_w`. EMS ji neodvozuje z forecastu ani z `grid_setpoint_w`; pro exportní sloty je to tvrdý site/inverter cap. |
 | 178 | Control board special 1 | bitmask | — | Bitové pole pro více funkcí. **EMS používá:** (a) bits **4–5** pro peak shaving switch: **32** (`0b00100000`, bit4–5 = **10**) v režimu **SELL**; **48** (`0b00110000`, bit4–5 = **11**) v **PASSIVE/CHARGE**. (b) **BA81:** bits **0–1** pro „MI export to Grid cutoff“ (AC coupling / GEN): **2** = disable (cutoff OFF), **3** = enable (cutoff ON). EMS zapisuje jako **read-modify-write** (zachová ostatní bity). V některých manuálech/UI je to označené jako „register 179“ (1-based). |
 | 190 | GEN peak shaving | 0–16000 | 1 W | Peak shaving na GEN portu |
 | 191 | Grid peak shaving power | 0–16000 | 1 W | **EMS NEZAPISUJE** – nastavit **manuálně v SolarmanApp**. Hodnota určuje výkon peak shavingu v **W**. |

docs/04-modules/operating-modes.md

@@ -3,6 +3,7 @@
 ## Keep it simple
 
 - **Žádné wattové prahy pro výběr SELL / CHARGE** — mapování z MILP setpointů je čistě ze **znamének** `battery_setpoint_w` a `grid_setpoint_w` (viz `get_deye_mode` v `exporter_monolith.py`).
+- **Přetok FVE do sítě** se neodvozuje z forecastového capu: plán nese explicitní `export_limit_w` jako tvrdý limit lokality / invertoru, ne jako tipované maximum z předpovědi.
 - **ZERO (PASSIVE)** = zero export k CT/zátěži (**142** = `deye_zero_export_mode`), s **plnými proudy 108/109** jen ve výchozím stavu; pro přetok FVE do sítě nebo odběr ze sítě bez vybíjení baterie se jeden z proudů **vynuluje** (`_deye_zero_export_amps_for_passive`).
 - **SELL** = plánovaný export **i** plánované vybíjení (oba záporné) → **142** = selling first, **178** = vypnutý grid peak shaving (32); po návratu do ZERO/CHARGE zase **178** = 48.
 - Novou logiku vždy ověřit proti **reálnému řádku plánu** (audit / `planning_interval`).
@@ -54,6 +55,8 @@ Všechny řádky předpokládají **142** = zero export (ne SELL).
 | Přetok FVE do sítě | `grid_setpoint_w` < 0 **a** `battery_w` ≥ 0 | **0** | max |
 | Držet baterii, brát ze sítě | `grid_setpoint_w` > 0 **a** `battery_w` ≤ 0 | max | **0** |
 
+V obou exportních případech platí, že `export_limit_w` je **tvrdý site/inverter cap**. Nejde o forecastový odhad exportu, takže se může pustit plný přetok v rámci distribučního limitu.
+
 Nabíjení ze sítě s vysokým cílovým SoC v TOU řeší větev **CHARGE** (grid charge v time pointech), ne tato tabulka.
 
 ### ZERO a „zakázaný export FVE do sítě“ (jen řiditelná pole)

docs/04-modules/planning.md

@@ -10,6 +10,9 @@
 - **Dynamický horizont (jen OTE):** konec plánu z **`ems.fn_planning_horizon_end(site_id, horizon_start)`** (výchozí strop **36 h**, minimum pro rolling **1 h** – obojí jako defaultní argumenty v SQL, úprava přes repeatable migraci). Pomocná `ems.fn_last_effective_ote` vrací konec posledního OTE intervalu. Rolling replan při `NULL` přeskočí; denní plán použije krátký (1 h) fallback v Pythonu. Sloty v solveru jsou bez predikovaných cen v rámci tohoto horizontu.
 - **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` (anti-mikrocyklování):** generuje `ems.fn_load_planning_slots_full`. Důležité: pokud rolling replan startuje s baterií na 100 %, `allow_charge` se nesmí stát globálně `false` pro celý horizont – jinak solver nemá motivaci baterii před PV špičkou „uvolnit“ (headroom), protože ji pak nesmí z PV znovu nabít. Aktuálně se v tomto případě `allow_charge` ponechá povolené alespoň pro sloty s `pv_surplus_w > 0`.
+- **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`. `planning_engine.solve_dispatch()` přidá proměnné deficit vůči cíli a penalizaci `max(future_buy, future_sell) − degradace` (clamp), aby šlo prodat ve velmi drahém sell okně i přes deficit. 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`; měkká penalizace proti snížení `bc[t]` oproti předchozímu plánu (`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`).
 - **Runtime guard v exportu setpointů (legacy):**
   - při `AUTO` + `is_predicted_price=true` se na exportní vrstvě vynutí PASSIVE/no-export chování (u nových plánů by `is_predicted_price` v horizontu nemělo nastat).
 - **Ekonomika baterie:**
@@ -30,6 +33,7 @@
 - **Záporná prodejní cena → tvrdý zákaz vývozu (`ge = 0`)** (`planning_engine.solve_dispatch`): platí ve slotu kde `sell_price < 0`, pokud lokality zapne některou z opcí —
   - **`asset_inverter.deye_gen_microinverter_cutoff_enabled`** (`deye-main`) — spojeno s MILP binárkami GEN cut-off (BA81),
   - **nebo** **`ems.site_grid_connection.block_export_on_negative_sell`** (migrace **V074**, default **false**) — bez GEN registrů na Deye; vhodné např. pro **KV1** (fixní nákup, bez nutnosti vést výkon neriťitelného pole B do sítě). **home-01** nech **false**, jinak může být horizont při přebytku z pole B a plné/nedostupné baterii **infeasible** (solver export potřebuje jako fyzikální ventil tam, kde FVE B nelze štípnout ani odpojit modelem bez GEN řádku).
+- **Export bez forecastového capu:** solver ukládá explicitní `planning_interval.export_limit_w` jako tvrdý site/inverter limit a `planning_interval.export_mode` (`NONE` / `PV_SURPLUS` / `BATTERY_SELL`). Exportér z plánu neodvozuje žádný forecastový strop exportu.
 - **Uložené vstupy plánu** (`planning_interval`): `load_baseline_w`, `pv_*_forecast_raw_w`, `pv_*_forecast_solver_w` pro UI a audit.
 - **Více FVE polí s různou orientací:** `planning_engine._load_slots` sčítá predikovaný výkon za 15min přes **všechna** `asset_pv_array` dané lokality — `pv_a_forecast_w` = součet řádků s `controllable = true`, `pv_b_forecast_w` = součet s `controllable = false`. Pro každé pole a slot se bere **nejnovější** `forecast_pv_run` (`ORDER BY created_at DESC`, `DISTINCT ON (pv_array_id)`). Curtailment v LP zůstává **jedno** agregované `pv_a` (součet řiditelných polí); per-string curtailment by vyžadovalo rozšíření modelu.
 - **Kalibrace PV forecastu (delta profil):** tabulka `ems.site_pv_forecast_calibration` drží per `site_id` mimo jiné `delta_learn_min_ts` (dolní mez řádků z `forecast_accuracy` pro učení delty), volitelně `pv_curtailment_policy_effective_from` a přepsání parametrů (`top_n_days`, `half_life_days`, …; **V076** navíc `reference_day_weight_mult` pro „připnuté“ dny níže). **`ems.site_pv_forecast_reference_day`** (**V076**) umožňuje zvýšit váhu konkrétních kalendářních dnů (datum ve `site.timezone` jako u časování slotů) při agregaci δ z `forecast_accuracy` (`fn_pv_forecast_delta_profile`); hromadný zápis **`ems.fn_pv_forecast_sync_reference_days`**, detail **`docs/04-modules/forecast.md`**. `ems.fn_fill_forecast_accuracy` nastavuje `learning_eligible` / `learning_exclude_reason` (sloty před cutoffem, nebo se škrcením / gen cut-off / záznamem v `ems.cutoff_switch_log` po účinnosti policy se z učení vyřadí; u škrcení zůstává `actual_power_w` NULL). Telemetrie: `ems.telemetry_inverter.is_export_limited` nebo `pv_derating_flags <> 0` v okně 15min → stejné vyloučení (`telemetry_derating`). `ems.fn_pv_forecast_delta_profile` vrací `deltas_by_array` i součtové `deltas`; `ems.fn_load_planning_slots_full` aplikuje stejnou **per-pole** korekci jako UI (`fn_forecast_pv_slots_range_corrected`); pokud v JSON profilu chybí `deltas_by_array`, použije se souhrnné `deltas` rozpuštěné podle podílu výkonu pole na slotu (solver má tak stále použitou korekci i bez per-pole JSON).
@@ -421,6 +425,8 @@ def solve_dispatch(
             battery_setpoint_w   = round(pulp.value(batt_charge[t]) - pulp.value(batt_discharge[t])),
             battery_soc_target   = round(pulp.value(soc[t]) / battery.usable_capacity_wh * 100, 1),
             grid_setpoint_w      = round(pulp.value(grid_import[t]) - pulp.value(grid_export[t])),
+            export_limit_w       = int(grid.max_export_power_w) if round(pulp.value(grid_import[t]) - pulp.value(grid_export[t])) < 0 else 0,
+            export_mode          = "BATTERY_SELL" if round(pulp.value(batt_charge[t]) - pulp.value(batt_discharge[t])) < 0 and round(pulp.value(grid_import[t]) - pulp.value(grid_export[t])) < 0 else ("PV_SURPLUS" if round(pulp.value(grid_import[t]) - pulp.value(grid_export[t])) < 0 else "NONE"),
             ev_charge_power_w    = round(pulp.value(ev_charge[t])),
             heat_pump_enabled    = hp_enabled,
             heat_pump_setpoint_w = hp_power,
@@ -495,6 +501,8 @@ COMMENT ON COLUMN ems.planning_interval.pv_a_curtailed_w IS
 
 ## Tuning pro malé baterie (např. BA81)
 
+Kromě **`planner_terminal_soc_value_factor`** existují od **V077** měkké mechanismy **denní safety charge** a **rolling charge commitment** (viz výše) — malé instalace nelze spolehlivě stabilizovat jen slepým zvyšováním terminal faktoru na **0.9**.
+
 ### Terminal SoC shadow price (kritický parametr)
 
 V účelové funkci LP je člen **„terminal SoC shadow price“**: energie ponechaná v baterii na konci horizontu je oceněná jako záporný příspěvek k nákladům (solver má motivaci držet část SoC, pokud se to ekonomicky vyplatí oproti okamžitému vývozu / nákupu).

docs/04-modules/provozni-rezimy-checklist.md

@@ -0,0 +1,293 @@
+# Provozní režimy EMS - praktický přehled
+
+Tenhle dokument je zkrácený provozní cheat sheet. Cíl je jednoduchý:
+
+- rychle poznat, co EMS v daném slotu dělá
+- umět to porovnat s `planning_interval`
+- ověřit to na live registrech Deye a ve FE
+
+## 1. Co je zdroj pravdy
+
+- EMS provozní režim lokality: `ems.site_operating_mode.mode_code`
+- aktivní plán: `ems.planning_interval`
+- fyzická konfigurace invertoru: `asset_inverter` + `site_grid_connection`
+- live stav Deye: registry 108, 109, 141, 142, 143, 145, 178, 340
+
+Když něco nesedí, porovnávej vždy v tomto pořadí:
+
+1. `planning_interval`
+2. `control/registers` na FE
+3. `modbus_command` journal
+
+## 2. EMS režimy lokality
+
+### AUTO
+
+Normální provoz. EMS bere sloty z `planning_interval` a podle nich řídí Deye, EV, TČ a signály.
+
+V AUTO se pak mohou objevit sloty s různým exportním záměrem:
+
+- `PV_SURPLUS`
+- `BATTERY_SELL`
+- `NONE`
+
+### SELF_SUSTAIN
+
+Bezpečný provoz bez obchodní logiky.
+
+- Deye fyzicky běží v PASSIVE
+- baterie se nechává pro vlastní spotřebu
+- export je jen nouzový ventil, pokud je potřeba kvůli feasibility
+
+### CHARGE_CHEAP
+
+- nabíjení ze sítě
+- export se nepoužívá
+- fyzicky CHARGE
+
+### PRESERVE
+
+- baterie je uzamčená
+- žádné nabíjení ani vybíjení
+- fyzicky PASSIVE
+
+### MANUAL
+
+- EMS setpointy nezapisuje
+- vše je ruční řízení
+
+## 3. Tvoje 5 provozních archetypů
+
+### 1. Standardní režim s přetokem
+
+Co tím myslíme:
+
+- baterie se normálně nabíjí i vybíjí podle plánu
+- přetok do sítě je povolený
+- exportní limit je jen tvrdý site / inverter cap
+- když je baterie plná, přebytek FVE jde do sítě
+
+Jak to je v implementaci:
+
+- `export_mode = PV_SURPLUS`
+- `export_limit_w = hard cap`
+- `solar_sell = 1`
+- `deye_physical_mode = PASSIVE`
+- v PASSIVE se pro exportní slot typicky použije `108 = 0`, `109 = max`
+
+Poznámka:
+
+- exportní limit se už netipuje z forecastu
+- neomezuješ tedy výkon do sítě podle předpovědi, jen podle hard capu
+
+### 2. Standardní režim s vypnutým přetokem
+
+Co tím myslíme:
+
+- `solar_sell = false`
+- přebytek FVE se nesmí posílat do sítě
+- jakmile je baterie plná, FVE se utlumí
+
+Jak to je v implementaci:
+
+- tohle není samostatný fyzický Deye režim
+- většinou jde o kombinaci:
+  - `reg 143 = 0` nebo site `no_export`
+  - případně `export_ban = true` a `reg 145 = 0`
+- fyzicky to pořád bývá PASSIVE
+
+Poznámka:
+
+- tohle je důležité ověřovat na `reg 143` a `reg 145`, ne jen na `grid_setpoint_w`
+
+### 3. Prodej přebytku do sítě bez nabíjení baterie
+
+Co tím myslíme:
+
+- baterie není cílem
+- nechci ji nabíjet
+- chci prodávat celou výrobu do sítě
+
+Jak to je v implementaci:
+
+- `export_mode = PV_SURPLUS`
+- `solar_sell = 1`
+- `export_limit_w = hard cap`
+
+Poznámka k implementaci:
+
+- tohle je v kódu garantované až ve chvíli, kdy planner dá `battery_setpoint_w = 0`
+- pokud je `battery_setpoint_w > 0`, tak současná implementace už dovoluje i nabíjení baterie, i když exportní záměr zůstává `PV_SURPLUS`
+- jinými slovy: čisté „prodávám výrobu, ale baterii nechci nabíjet“ ještě není samostatný fyzický Deye režim, je to kombinace plánovacího setpointu a exportního záměru
+
+Použití:
+
+- vhodné, když je výkupní cena vysoká
+- baterii chceš šetřit na jiný slot
+
+### 4. Šetření baterie
+
+Co tím myslíme:
+
+- když je kupní cena nízká
+- nechci brát energii z baterie
+- raději budu kupovat ze sítě
+
+Jak to je v implementaci:
+
+- `battery discharge A = 0`
+- fyzicky PASSIVE
+- baterie se nevybíjí, ale podle slotu se může pořád nabíjet nebo držet
+
+Poznámka:
+
+- tohle je jiné než SELL
+- tady jen chráníš baterii, neprodáváš ji
+
+### 5. Aktivní prodej do sítě z baterie
+
+Co tím myslíme:
+
+- `selling first`
+- baterie prodává do sítě plným výkonem, co dovolí střídač / baterie / síť
+
+Jak to je v implementaci:
+
+- `export_mode = BATTERY_SELL`
+- `deye_physical_mode = SELL`
+- `reg 142 = 0`
+- `reg 178 = 32`
+- `reg 109` na max, `reg 108 = 0`
+
+## 4. Další režimy, které v praxi existují
+
+### CHARGE_CHEAP
+
+- nabíjení ze sítě
+- export vypnutý
+- fyzicky CHARGE
+
+### SELF_SUSTAIN
+
+- vlastní spotřeba
+- fyzicky PASSIVE
+- export jen jako nouzový ventil
+
+### PRESERVE
+
+- baterie uzamčená
+- žádné řízení baterie
+
+### MANUAL
+
+- EMS nezasahuje
+
+## 5. Registry, které má smysl kontrolovat
+
+### 108
+
+Max charge current.
+
+### 109
+
+Max discharge current.
+
+### 142
+
+Limit control:
+
+- `0` = selling first
+- `1` = zero export to load
+- `2` = zero export to CT
+
+### 143
+
+Export cap.
+
+- tvrdý site / inverter limit
+- neforecastuje se
+
+### 145
+
+Solar sell:
+
+- `1` = povoleno
+- `0` = zakázáno
+
+### 178
+
+Bitové pole:
+
+- bits 4-5 = peak shaving switch
+- bits 0-1 = GEN export cut-off u BA81
+
+### 340
+
+Max solar power pro řízenou FVE A.
+
+- není to exportní cap
+- je to strop výroby pole A
+
+## 6. Co kontrolovat na FE
+
+### Planning page
+
+Zkontroluj:
+
+- `deye_physical_mode`
+- `grid_setpoint_w`
+- `export_limit_w`
+- `export_mode`
+- `deye_gen_cutoff_enabled`
+- `effective_buy_price`
+- `effective_sell_price`
+
+### Control panel
+
+Na živém panelu porovnej:
+
+- reg 142
+- reg 143
+- reg 145
+- reg 178
+
+Reg 143 musí být vidět jako hard cap.
+
+## 7. Rychlá kontrola nesrovnalostí
+
+1. Najdi slot v `Planning`
+2. Podívej se na:
+   - `battery_setpoint_w`
+   - `grid_setpoint_w`
+   - `export_limit_w`
+   - `export_mode`
+   - `deye_physical_mode`
+3. Otevři `ControlPanel`
+4. Porovnej live registry:
+   - 142
+   - 143
+   - 145
+   - 178
+5. Podívej se do `modbus_command`
+
+## 8. Co je v implementaci důležité vědět
+
+Tady jsou dva praktické detaily:
+
+- `export_limit_w` se bere jako hard cap z lokality / invertoru
+- export se už netipuje z forecastu
+
+To znamená:
+
+- při `PV_SURPLUS` se má pustit maximum, které dovoluje distribuce a HW
+- při `BATTERY_SELL` se použije SELL a prodej z baterie
+- při běžném importu / šetření baterie se exportní logika nemá „uhádnout“ z ceny nebo forecastu
+
+## 9. Kde hledat v kódu
+
+- plánování: `backend/services/planning_engine.py`
+- mapování plánu na setpointy: `backend/services/control/setpoints.py`
+- zápis Deye: `backend/services/control/inverter.py`
+- live registry: `backend/app/routers/sites.py`
+- FE plánování: `frontend/src/pages/Planning.tsx`
+- FE live registry: `frontend/src/components/ControlPanel.tsx`

docs/07-mcp-postgres-ems.md

@@ -61,6 +61,11 @@ limit 10;
 select ems.fn_plan_explain_bundle(2, 6);
 ```
 
+```sql
+-- Diagnostika posledního běhu plánovače (run_id z planning_run)
+select ems.fn_planning_run_debug(8107);
+```
+
 Měnící funkce (**`ems.fn_delete_forecast_pv_prague_calendar_day`**, **`ems.fn_rebuild_consumption_baseline_stats`**, …) MCP přes **`query` neprovede**, pokud má server jen read-only práva na DB — použij psql aplikačním účtem.
 
 ---

frontend/src/components/ControlPanel.tsx

@@ -84,6 +84,12 @@ const LiveRegistersSection = memo(
             valueText={live?.reg142_limit_control != null ? String(live.reg142_limit_control) : undefined}
           />
           <Metric label="Energy mode" reg={141} valueText={live?.reg141_energy_mode != null ? String(live.reg141_energy_mode) : undefined} />
+          <Metric
+            label="Export cap"
+            reg={143}
+            sub="Hard limit lokality / invertoru; neforecastuje se"
+            valueText={fmtW(live?.reg143_export_limit_w)}
+          />
           <Metric
             label="Peak shaving switch"
             reg={178}

frontend/src/pages/Planning.tsx

@@ -221,6 +221,8 @@ function syntheticForecastOnlyInterval(
     battery_setpoint_w: null,
     battery_soc_target_pct: null,
     grid_setpoint_w: null,
+    export_limit_w: null,
+    export_mode: null,
     deye_physical_mode: null,
     ev1_setpoint_w: null,
     ev2_setpoint_w: null,
@@ -341,6 +343,7 @@ function axiosDetail(e: unknown): string {
 function deyeSetpointLabel(i: PlanningIntervalDto): string {
   const battery_w = i.battery_setpoint_w ?? 0
   const grid_w = i.grid_setpoint_w ?? 0
+  const exportLimitW = i.export_limit_w ?? 0
   const tgt = i.battery_soc_target_pct
   const targetSoc = tgt != null ? Math.min(95, Math.round(Number(tgt))) : 80
 
@@ -353,14 +356,18 @@ function deyeSetpointLabel(i: PlanningIntervalDto): string {
   const pm = (i.deye_physical_mode ?? '').toString().trim().toUpperCase()
   if (pm === 'SELL') {
     const tpPowerW = Math.abs(battery_w)
-    return `SELL | ⬇ ${fmtKw(tpPowerW)} | reg142=0 reg178=32`
+    const cap = exportLimitW > 0 ? ` | cap ${fmtKw(exportLimitW)}` : ''
+    return `SELL | ⬇ ${fmtKw(tpPowerW)}${cap} | reg142=0 reg178=32`
   }
   if (pm === 'CHARGE') {
     return `CHARGE | ⬆ ${fmtKw(Math.max(0, battery_w))} | grid=yes | SOC→${targetSoc}%`
   }
 
   // PASSIVE (ZERO): doplň informaci o variantě 108/109 podle pravidel (bez wattových prahů).
-  if (grid_w < 0 && battery_w >= 0) return 'PASSIVE | FVE→síť (108=0)'
+  if (grid_w < 0 && battery_w >= 0) {
+    const cap = exportLimitW > 0 ? ` | cap ${fmtKw(exportLimitW)}` : ''
+    return `PASSIVE | FVE→síť${cap} (108=0)`
+  }
   if (grid_w > 0 && battery_w <= 0) return 'PASSIVE | držet bat. (109=0)'
   return 'PASSIVE | max/max'
 }
@@ -369,12 +376,15 @@ function deyeModeBadge(i: PlanningIntervalDto): { label: string; klass: string;
   const m = (i.deye_physical_mode ?? 'PASSIVE').toString().trim().toUpperCase()
   const battery_w = i.battery_setpoint_w ?? 0
   const grid_w = i.grid_setpoint_w ?? 0
+  const exportLimitW = i.export_limit_w ?? 0
+  const exportMode = (i.export_mode ?? 'NONE').toString().trim().toUpperCase()
+  const cap = exportLimitW > 0 ? `; hard cap ${formatPlanPowerW(exportLimitW)}` : ''
 
   if (m === 'SELL') {
     return {
       label: 'SELL',
       klass: 'bg-orange-500/15 text-orange-200 ring-1 ring-orange-500/35',
-      title: 'SELL (selling first): reg142=0, reg178=32 (grid peak shaving off)',
+      title: `SELL (selling first): reg142=0, reg178=32 (grid peak shaving off)${cap}`,
     }
   }
   if (m === 'CHARGE') {
@@ -386,12 +396,14 @@ function deyeModeBadge(i: PlanningIntervalDto): { label: string; klass: string;
   }
 
   let variant = 'max/max'
-  if (grid_w < 0 && battery_w >= 0) variant = 'FVE→síť (108=0)'
+  if (grid_w < 0 && battery_w >= 0) {
+    variant = exportMode === 'PV_SURPLUS' ? 'FVE→síť' : 'export'
+  }
   else if (grid_w > 0 && battery_w <= 0) variant = 'držet bat. (109=0)'
   return {
     label: 'PASSIVE',
     klass: 'bg-slate-600/40 text-slate-200 ring-1 ring-slate-500/30',
-    title: `PASSIVE (ZERO): ${variant}; reg142=deye_zero_export_mode; reg178=48`,
+    title: `PASSIVE (ZERO): ${variant}${cap}; reg142=deye_zero_export_mode; reg178=48`,
   }
 }
 
@@ -539,6 +551,8 @@ function PlanTooltip({
   const fveStr = formatPlanPowerW(p.pv_a_w)
   const fveDisplay = fveStr === '—' ? '—' : fveStr.includes('kW') ? fveStr : `${fveStr} W`
   const soc = p.battery_soc_target_pct
+  const exportLimit = i.export_limit_w
+  const exportMode = i.export_mode ?? 'NONE'
   return (
     <div className="rounded-lg border border-slate-600 bg-slate-950 px-3 py-2 text-xs text-slate-200 shadow-xl">
       <div className="mb-1 font-medium text-slate-100">{formatLocal(i.interval_start)}</div>
@@ -556,6 +570,12 @@ function PlanTooltip({
           {sell != null ? `${sell.toFixed(3)} Kč/kWh` : '—'}
         </div>
         <div>FVE (korig. předpověď / audit): {fveDisplay}</div>
+        {exportMode !== 'NONE' ? (
+          <div>
+            Export: {exportMode}
+            {exportLimit != null ? ` · limit ${formatPlanPowerW(exportLimit)}` : ''}
+          </div>
+        ) : null}
         <div>SoC cíl: {soc != null && !Number.isNaN(Number(soc)) ? `${Number(soc).toFixed(1)} %` : '—'}</div>
         <div>Dům: {i.load_baseline_w ?? '—'} W</div>
         <div>Baterie: {i.battery_setpoint_w ?? '—'} W</div>

frontend/src/types/plan.ts

@@ -15,6 +15,10 @@ export type PlanningIntervalDto = {
   battery_setpoint_w: number | null
   battery_soc_target_pct: number | null
   grid_setpoint_w: number | null
+  /** Tvrdý limit exportu do sítě v daném slotu (W); 0 = bez exportu. */
+  export_limit_w?: number | null
+  /** Záměr exportu: NONE / PV_SURPLUS / BATTERY_SELL. */
+  export_mode?: 'NONE' | 'PV_SURPLUS' | 'BATTERY_SELL' | null
   /** Explicitní fyzický režim Deye pro slot (PASSIVE/SELL/CHARGE). */
   deye_physical_mode?: 'PASSIVE' | 'SELL' | 'CHARGE' | null
   /** True = solver plánuje odpojit GEN port (MI export cutoff) v tomto slotu (BA81). */