EVCS/workflows/evcs-energy-balance-v1.json

{
  "name": "EVCS Energy Balance V1",
  "nodes": [
    {
      "name": "Schedule Trigger",
      "type": "n8n-nodes-base.scheduleTrigger",
      "typeVersion": 1.2,
      "position": [
        0,
        0
      ],
      "parameters": {
        "rule": {
          "interval": [
            {
              "field": "minutes",
              "minutesInterval": 5
            }
          ]
        }
      }
    },
    {
      "name": "HA Snapshot Balance",
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 4.2,
      "position": [
        220,
        0
      ],
      "parameters": {
        "method": "POST",
        "url": "http://10.10.10.17:8123/api/template",
        "authentication": "genericCredentialType",
        "genericAuthType": "httpBearerAuth",
        "sendHeaders": true,
        "headerParameters": {
          "parameters": [
            {
              "name": "Content-Type",
              "value": "application/json"
            },
            {
              "name": "Accept",
              "value": "text/plain"
            }
          ]
        },
        "sendBody": true,
        "bodyParameters": {
          "parameters": [
            {
              "name": "template",
              "value": "{#- Fenetres d'heures creuses (28/09/2026). Le calendrier tarifaire reste dans\n    Home Assistant (helpers victron_evcs_hc_*) ; le bilan ne recoit que deux\n    instants : la fin de la fenetre HC en cours (vide hors fenetre) et le debut\n    de la fenetre HC suivante. Strategie du proprietaire : la batterie doit\n    tenir jusqu'a la prochaine fenetre HC. -#}\n{%- set ns = namespace(fin='', suivant='', nuit='', fen=[]) -%}\n{%- for j in [0, 1, 2] -%}\n  {%- for a, b, t in [('victron_evcs_hc_night_start', 'victron_evcs_hc_night_stop', 'nuit'), ('victron_evcs_hc_midday_start', 'victron_evcs_hc_midday_stop', 'midi')] -%}\n    {%- set d = today_at(states('input_datetime.' ~ a)) + timedelta(days=j) -%}\n    {%- set f = today_at(states('input_datetime.' ~ b)) + timedelta(days=j) -%}\n    {%- set f = f + timedelta(days=1) if f <= d else f -%}\n    {%- set ns.fen = ns.fen + [[d, f, t]] -%}\n  {%- endfor -%}\n{%- endfor -%}\n{%- for w in ns.fen | sort(attribute='0') -%}\n  {%- if w[0] <= now() < w[1] and ns.fin == '' -%}{%- set ns.fin = w[1] -%}{%- endif -%}\n{%- endfor -%}\n{%- set repere = ns.fin if ns.fin != '' else now() -%}\n{%- for w in ns.fen | sort(attribute='0') -%}\n  {%- if w[0] >= repere and ns.suivant == '' -%}{%- set ns.suivant = w[0] -%}{%- endif -%}\n  {%- if w[0] >= repere and w[2] == 'nuit' and ns.nuit == '' -%}{%- set ns.nuit = w[0] -%}{%- endif -%}\n{%- endfor -%}\n{#- Vehicule branche a midi (28/09/2026) — JEEP, VW ou ZERO, selon le\n    selecteur. Pour chacun, HA porte le calendrier (jours et heure de depart\n    apres le dejeuner), la capacite et la puissance de charge MESUREES ; le\n    bilan recoit un instant de depart, vide si le vehicule ne repart pas\n    aujourd'hui. Le niveau saisi n'est retenu que s'il date de ce branchement\n    (tolerance 1 h avant). Capacite ou puissance a 0 = inconnue. -#}\n{%- set vh = namespace(dep='', valide=false, cap=none, kw=none) -%}\n{%- set jours = ['lun', 'mar', 'mer', 'jeu', 'ven', 'sam', 'dim'] -%}\n{%- set cle = {'JEEP': 'jeep', 'VW': 'vw', 'ZERO': 'zero'}.get(states('input_select.victron_evcs_vehicle')) -%}\n{%- if cle -%}\n  {%- set vh.cap = states('input_number.victron_evcs_capacity_' ~ cle ~ '_kwh') -%}\n  {%- set vh.kw = states('input_number.victron_evcs_charger_kw_' ~ cle) -%}\n  {%- set heure = states('input_datetime.victron_evcs_' ~ cle ~ '_midday_departure') -%}\n  {%- if jours[now().weekday()] in states('input_text.victron_evcs_' ~ cle ~ '_midday_departure_days') | lower\n        and heure not in ['unknown', 'unavailable', ''] -%}\n    {%- set d = today_at(heure) -%}\n    {%- if d > now() -%}{%- set vh.dep = d -%}{%- endif -%}\n  {%- endif -%}\n{%- endif -%}\n{%- set branche = states.binary_sensor.victron_evcs_vehicle_connected -%}\n{%- set niveau = states.input_number.victron_evcs_vehicle_level_pct -%}\n{#- Depart ponctuel (VW, ZERO : pas de jours fixes) : pour aujourd'hui, a venir,\n    saisi depuis ce branchement. Le plus proche des deux departs l'emporte. -#}\n{%- set ponctuel = states.input_datetime.victron_evcs_departure_ponctuel -%}\n{%- if branche is not none and ponctuel is not none and branche.state == 'on'\n      and ponctuel.state not in ['unknown', 'unavailable', ''] -%}\n  {%- set p = as_datetime(ponctuel.attributes.timestamp) | as_local -%}\n  {%- if p.date() == now().date() and p > now()\n        and as_timestamp(ponctuel.last_changed) >= as_timestamp(branche.last_changed) - 3600 -%}\n    {%- set vh.dep = p if vh.dep == '' or p < vh.dep else vh.dep -%}\n  {%- endif -%}\n{%- endif -%}\n{%- if branche is not none and niveau is not none and branche.state == 'on' -%}\n  {#- Date de SAISIE ecrite par l'automatisation, pas last_changed : une saisie\n      identique ne change pas l'etat du helper mais compte comme une saisie. -#}\n  {%- set vh.valide = (as_timestamp(states('input_datetime.victron_evcs_vehicle_level_at'), 0)) >= as_timestamp(branche.last_changed) - 3600 -%}\n{%- endif -%}\n{{ {\n  \"ts\": now().isoformat(),\n  \"vehicle_connected\": is_state(\"binary_sensor.victron_evcs_vehicle_connected\", \"on\"),\n  \"vehicle_departure_ms\": (as_timestamp(vh.dep) * 1000) if vh.dep != '' else none,\n  \"vehicle_level_pct\": states(\"input_number.victron_evcs_vehicle_level_pct\"),\n  \"vehicle_level_valid\": vh.valide,\n  \"vehicle_capacity_kwh\": vh.cap,\n  \"vehicle_charger_kw\": vh.kw,\n  \"vehicle_delivered_since_level_kwh\": ((states(\"sensor.evcs_hq2239dnt7p_total_energy\") | float(0)) - (states(\"input_number.victron_evcs_vehicle_level_ref_kwh\") | float(0))) if states(\"sensor.evcs_hq2239dnt7p_total_energy\") | is_number else none,\n  \"hc_window_end_ms\": (as_timestamp(ns.fin) * 1000) if ns.fin != '' else none,\n  \"next_hc_start_ms\": (as_timestamp(ns.suivant) * 1000) if ns.suivant != '' else none,\n  \"next_night_hc_start_ms\": (as_timestamp(ns.nuit) * 1000) if ns.nuit != '' else none,\n  \"nowMs\": as_timestamp(now()) * 1000,\n\n  \"balance_enabled\": states(\"input_boolean.evcs_balance_enabled\"),\n  \"usable_capacity_kwh\": states(\"input_number.evcs_balance_usable_capacity_kwh\"),\n  \"modules_en_service\": states(\"input_number.evcs_balance_modules_en_service\"),\n\n  \"consumption_p50_csv\": states(\"input_text.evcs_balance_consumption_p50\"),\n  \"consumption_p80_csv\": states(\"input_text.evcs_balance_consumption_p80\"),\n  \"envelope_csv\": states(\"input_text.evcs_balance_envelope\"),\n  \"censorship_rate_csv\": states(\"input_text.evcs_balance_censorship_rate\"),\n\n  \"forecast_source\": states(\"input_select.evcs_balance_forecast_source\"),\n  \"forecast_day0\": states(\"input_text.evcs_balance_vrm_day0\") if is_state(\"input_select.evcs_balance_forecast_source\", \"vrm\") else states(\"input_text.evcs_balance_forecast_day0\"),\n  \"forecast_today_csv\": states(\"input_text.evcs_balance_vrm_today\") if is_state(\"input_select.evcs_balance_forecast_source\", \"vrm\") else states(\"input_text.evcs_balance_forecast_today\"),\n  \"forecast_tomorrow_csv\": states(\"input_text.evcs_balance_vrm_tomorrow\") if is_state(\"input_select.evcs_balance_forecast_source\", \"vrm\") else states(\"input_text.evcs_balance_forecast_tomorrow\"),\n  \"forecast_updated\": states(\"input_text.evcs_balance_vrm_updated\") if is_state(\"input_select.evcs_balance_forecast_source\", \"vrm\") else states(\"input_text.evcs_balance_forecast_updated\"),\n  \"grid_soc_off\": states(\"input_number.victron_grid_soc_off\"),\n\n  \"manual_hc_floor_percent\": states(\"input_number.evcs_battery_manual_hc_floor\"),\n\n  \"pv_power_w\": states(\"sensor.victron_pv_power_system\"),\n\n  \"house_ac_power_w\": states(\"sensor.victron_consumption_power_l1\"),\n  \"vebus_ac_out_l1_power_w\": states(\"sensor.victron_ve_bus_ac_out_l1_power\"),\n  \"evcs_ac_power_w\": states(\"sensor.victron_evcs_ac_power\"),\n\n  \"soc_percent\": states(\"sensor.victron_battery_soc\"),\n  \"battery_current_a\": states(\"sensor.victron_battery_current\"),\n  \"battery_voltage_v\": states(\"sensor.victron_battery_voltage\"),\n  \"vebus_dc_power_w\": states(\"sensor.victron_ve_bus_dc_power_system\"),\n\n  \"grid_switch\": states(\"switch.edf_general_ok_switch\"),\n  \"acin1_available\": states(\"sensor.victron_ac_in1_available\"),\n  \"grid_power_l1_w\": states(\"sensor.victron_grid_power_l1\"),\n\n  \"multiplus_state\": states(\"sensor.airtria_mpii_v1_state\"),\n  \"multiplus_overload_alarm\": states(\"sensor.airtria_mpii_v1_overload_alarm\"),\n  \"system_state\": states(\"sensor.gx_device_system_state\"),\n  \"ess_batterylife_state\": states(\"sensor.gx_device_ess_batterylife_state\"),\n  \"dc_battery_state\": states(\"sensor.gx_device_dc_battery_state\"),\n\n  \"mppt_1_state\": states(\"sensor.airtria_mppt1_state\"),\n  \"mppt_2_state\": states(\"sensor.mppt_450_200_hq2449yr9pt_state\"),\n  \"mppt_3_state\": states(\"sensor.v1_state\"),\n\n  \"evcs_native_status\": states(\"sensor.evcs_hq2239dnt7p_status\"),\n\n  \"forecast_today_remaining_kwh\": states(\"sensor.energy_production_today_remaining\"),\n  \"forecast_today_kwh\": states(\"sensor.energy_production_today\"),\n  \"forecast_tomorrow_kwh\": states(\"sensor.energy_production_tomorrow\"),\n  \"forecast_next_hour_w\": states(\"sensor.power_production_next_hour\"),\n\n  \"sun_elevation\": state_attr(\"sun.sun\", \"elevation\"),\n\n  \"storm_alert_level\": (states.sensor\n      | selectattr('entity_id', 'search', '_weather_alert')\n      | map(attribute='state') | list | first) | default('indisponible', true),\n  \"storm_alert_detail\": (states.sensor\n      | selectattr('entity_id', 'search', '_weather_alert')\n      | map(attribute='attributes') | list | first) | default({}, true)\n} | tojson }}\n"
            }
          ]
        },
        "options": {
          "timeout": 15000
        }
      },
      "credentials": {
        "httpBearerAuth": {
          "id": "uv3sknYYigxBkaVN",
          "name": "Bearer Auth account 2"
        }
      }
    },
    {
      "name": "CENSORSHIP",
      "type": "n8n-nodes-base.code",
      "typeVersion": 2,
      "position": [
        440,
        -120
      ],
      "parameters": {
        "jsCode": "// EVCS Energy Balance — CENSORSHIP\n// =====================================================================\n// Rôle : dire si la production PV mesurée à cet instant représente la\n// RESSOURCE solaire disponible, ou si elle est CENSURÉE.\n//\n// L'installation est un ESS Victron sans injection réseau. Le MPPT ne produit\n// que ce que le système peut absorber immédiatement :\n//\n//     PV_mesurée = min( ressource réelle , conso maison + absorption batterie )\n//\n// Dès que la batterie est pleine ou que le réseau alimente AC-IN, la mesure est\n// une observation censurée à droite : elle dit « on n'avait pas besoin de plus »,\n// pas « il n'y avait pas plus ». Sur l'historique du 28/07 au 24/08, 48 % des\n// heures de jour sont censurées — 77 à 96 % à partir de 13 h. Bâtir un profil de\n// production sur la mesure brute revient donc à mesurer sa propre consommation.\n//\n// Ce nœud ne décide RIEN. Il qualifie l'échantillon, pour que l'estimation de\n// ressource ne soit recalée que sur les heures exploitables.\n//\n// Sortie : censorship { pvCensored, reasons[], sampleExploitable, ... }\n//          health     { residualW, ok } — contrôle de vraisemblance du bus DC.\n// =====================================================================\n\nfunction num(v, fallback = NaN) {\n  const n = Number.parseFloat(v);\n  return Number.isFinite(n) ? n : fallback;\n}\n\nfunction low(v) {\n  return (v ?? '').toString().trim().toLowerCase();\n}\n\nfunction round1(v) {\n  return Number.isFinite(v) ? Math.round(v * 10) / 10 : null;\n}\n\n// Le nœud HTTP de n8n renvoie le corps du template dans `data`, sous forme de\n// chaîne. Hors n8n (tests), l'objet arrive déjà décodé — on accepte les deux.\nfunction unwrapSnapshot(raw) {\n  if (raw && typeof raw.data === 'string') {\n    try { return JSON.parse(raw.data); } catch { return raw; }\n  }\n  return (raw && raw.data) || raw;\n}\n\nconst input = unwrapSnapshot($input.first().json);\n\nconst CFG = {\n  // Le soleil doit être assez haut pour qu'une mesure de production ait un sens.\n  SUN_ELEVATION_MIN_DEG: 10,\n  // En dessous, on est dans le bruit (aube, crépuscule, couverture totale).\n  PV_MEANINGFUL_MIN_W: 200,\n  // SOC à partir duquel la batterie ne peut plus servir de puits significatif.\n  SOC_NEAR_FULL_PCT: 90,\n  // Puissance de charge batterie en dessous de laquelle, batterie quasi pleine,\n  // on considère qu'il n'y a plus de preneur pour le surplus.\n  BATTERY_SINK_MIN_W: 500,\n  // États VE.Bus de fin de charge : le courant est volontairement réduit.\n  MULTIPLUS_TAPER_STATES: ['absorption', 'float', 'storage'],\n  // Tolérance du contrôle de vraisemblance PV + VE.Bus = batterie.\n  HEALTH_ABS_TOLERANCE_W: 150,\n  HEALTH_REL_TOLERANCE: 0.15,\n};\n\nconst pvPowerW = num(input.pv_power_w, 0);\nconst housePowerW = num(input.house_ac_power_w, 0);\nconst evcsPowerW = num(input.evcs_ac_power_w, 0);\nconst socPct = num(input.soc_percent, NaN);\nconst batteryCurrentA = num(input.battery_current_a, NaN);\nconst batteryVoltageV = num(input.battery_voltage_v, NaN);\nconst vebusDcPowerW = num(input.vebus_dc_power_w, NaN);\nconst sunElevationDeg = num(input.sun_elevation, NaN);\nconst forecastNextHourW = num(input.forecast_next_hour_w, NaN);\n\nconst batteryPowerW =\n  Number.isFinite(batteryCurrentA) && Number.isFinite(batteryVoltageV)\n    ? batteryCurrentA * batteryVoltageV\n    : NaN;\n\nconst multiplusState = low(input.multiplus_state);\nconst systemState = low(input.system_state);\nconst essBatteryLifeState = low(input.ess_batterylife_state);\nconst dcBatteryState = low(input.dc_battery_state);\nconst overloadAlarm = low(input.multiplus_overload_alarm);\nconst evcsNativeStatus = low(input.evcs_native_status);\n\nconst mpptStates = [input.mppt_1_state, input.mppt_2_state, input.mppt_3_state]\n  .map(low)\n  .filter(s => s !== '' && s !== 'unavailable' && s !== 'unknown');\n\n// AC-IN physiquement présent : c'est lui qui compte, pas la position du switch\n// (le switch peut être ON alors que le disjoncteur est coupé — incident 08/07).\nconst gridPresent =\n  num(input.acin1_available, 0) === 1 || low(input.grid_switch) === 'on';\n\nconst sunUp =\n  !Number.isFinite(sunElevationDeg) || sunElevationDeg >= CFG.SUN_ELEVATION_MIN_DEG;\n\n// =====================================================================\n// CENSURE — chaque motif s'appuie sur un signal réellement lu, pas sur un seuil\n// supposé. Ils sont cumulables : on garde la liste complète pour le diagnostic.\n// =====================================================================\nconst reasons = [];\n\nif (gridPresent) {\n  reasons.push('reseau_present');\n}\n\nif (CFG.MULTIPLUS_TAPER_STATES.includes(multiplusState)) {\n  reasons.push(`fin_de_charge_${multiplusState}`);\n}\n\nconst batteryNearFull =\n  Number.isFinite(socPct) && socPct >= CFG.SOC_NEAR_FULL_PCT;\nconst batterySinkWeak =\n  !Number.isFinite(batteryPowerW) || batteryPowerW < CFG.BATTERY_SINK_MIN_W;\n\nif (sunUp && batteryNearFull && batterySinkWeak) {\n  reasons.push('batterie_pleine_sans_puits');\n}\n\nif (sunUp && dcBatteryState === 'idle' && pvPowerW > CFG.PV_MEANINGFUL_MIN_W) {\n  reasons.push('bus_dc_au_repos_en_plein_jour');\n}\n\n// Un tracker à l'arrêt en plein jour n'est pas une panne : c'est le MPPT qui\n// coupe faute de preneur. C'est le signal le plus direct d'un écrêtage.\nconst mpptOffCount = mpptStates.filter(s => s === 'off').length;\nif (sunUp && mpptOffCount > 0 && mpptStates.length > 0) {\n  reasons.push(`mppt_arretes_${mpptOffCount}_sur_${mpptStates.length}`);\n}\n\nconst pvCensored = reasons.length > 0;\n\n// Un échantillon n'est exploitable pour estimer la ressource que s'il n'est pas\n// censuré ET qu'il y a assez de soleil pour que la mesure signifie quelque chose.\nconst sampleExploitable =\n  !pvCensored && sunUp && pvPowerW >= CFG.PV_MEANINGFUL_MIN_W;\n\n// Indication (non un fait) de ce qu'on laisse passer : la prévision porte sur\n// l'heure suivante, pas sur l'instant présent — à ne pas cumuler comme un\n// compteur d'énergie perdue.\nconst shortfallHintW =\n  pvCensored && Number.isFinite(forecastNextHourW)\n    ? Math.max(0, forecastNextHourW - pvPowerW)\n    : 0;\n\n// =====================================================================\n// SANTÉ DES MESURES — identité du bus DC : PV + VE.Bus = batterie.\n// Vérifiée à 95 W près le 24/08/2026. Le jour où elle diverge, un capteur ment.\n// =====================================================================\nconst healthMeasurable =\n  Number.isFinite(pvPowerW) && Number.isFinite(vebusDcPowerW) && Number.isFinite(batteryPowerW);\n\nconst residualW = healthMeasurable ? pvPowerW + vebusDcPowerW - batteryPowerW : NaN;\nconst healthTolerance = Math.max(\n  CFG.HEALTH_ABS_TOLERANCE_W,\n  CFG.HEALTH_REL_TOLERANCE * Math.abs(batteryPowerW || 0)\n);\nconst healthOk = healthMeasurable ? Math.abs(residualW) <= healthTolerance : null;\n\n// =====================================================================\n// ALERTES SYSTÈME — jusqu'ici jamais lues par aucun workflow.\n// =====================================================================\nconst alerts = [];\nif (overloadAlarm && overloadAlarm !== 'no_alarm') alerts.push(`multiplus_overload_${overloadAlarm}`);\nif (essBatteryLifeState.includes('soc_below')) alerts.push('batterylife_limite_le_soc');\nif (healthOk === false) alerts.push('incoherence_mesures_bus_dc');\n\nreturn [{\n  json: {\n    ts: input.ts,\n\n    measured: {\n      pvPowerW: round1(pvPowerW),\n      housePowerW: round1(housePowerW),\n      houseWithoutEvcsW: round1(Math.max(0, housePowerW - evcsPowerW)),\n      evcsPowerW: round1(evcsPowerW),\n      socPct: round1(socPct),\n      batteryPowerW: round1(batteryPowerW),\n      vebusDcPowerW: round1(vebusDcPowerW),\n      sunElevationDeg: round1(sunElevationDeg),\n      forecastNextHourW: Number.isFinite(forecastNextHourW) ? forecastNextHourW : null,\n    },\n\n    states: {\n      multiplusState,\n      systemState,\n      essBatteryLifeState,\n      dcBatteryState,\n      mpptStates,\n      evcsNativeStatus,\n      gridPresent,\n    },\n\n    censorship: {\n      pvCensored,\n      reasons,\n      sampleExploitable,\n      shortfallHintW: round1(shortfallHintW),\n      sunUp,\n    },\n\n    health: {\n      measurable: healthMeasurable,\n      residualW: round1(residualW),\n      toleranceW: round1(healthTolerance),\n      ok: healthOk,\n    },\n\n    alerts,\n    cfg: CFG,\n  },\n}];\n"
      }
    },
    {
      "name": "RESOURCE_ESTIMATE",
      "type": "n8n-nodes-base.code",
      "typeVersion": 2,
      "position": [
        440,
        120
      ],
      "parameters": {
        "jsCode": "// EVCS Energy Balance — RESOURCE_ESTIMATE\n// =====================================================================\n// Rôle : estimer la production PV attendue heure par heure, en RESSOURCE\n// (ce que l'installation peut produire) et non en mesure censurée.\n//\n// Trois sources ont été évaluées le 24/08/2026, deux ont été écartées :\n//\n//   1. Recalage de la prévision sur les heures non censurées — ÉCARTÉ.\n//      La censure est corrélée au beau temps : les heures exploitables de\n//      l'après-midi ne le sont que les jours médiocres. Le facteur mesuré va\n//      de 4,29 à 9 h (27 échantillons) à 0,48 à 15 h (3 échantillons).\n//      Données manquantes non aléatoires, aucun facteur transportable.\n//\n//   2. Forme issue de la géométrie solaire — ÉCARTÉ. Un modèle mono-plan\n//      ajusté sur les heures propres converge sur « plein est, 20° » et\n//      prédit alors 2,0 % de la journée à 18 h contre 5,8 % réellement\n//      mesurés. L'installation a manifestement plusieurs orientations\n//      (trois trackers), qu'un plan unique ne peut pas représenter.\n//\n//   3. Forme = enveloppe démontrée, magnitude = total prévu — RETENU du 24 au\n//      25/08, puis RÉTROGRADÉ EN REPLI. L'enveloppe étant un maximum horaire\n//      pris sur des jours différents, elle surpondère le matin, dont la\n//      variabilité jour à jour est plus forte qu'à midi. Deux modèles\n//      indépendants (géométrique local et ciel clair de Forecast.Solar) la\n//      contredisent de la même façon : c'est elle qui a tort.\n//\n//   4. RETENU (25/08) — COURBE HORAIRE de l'API Forecast.Solar, récupérée par\n//      le workflow \"EVCS Solar Forecast V1\" et publiée en CSV. Elle apporte\n//      forme ET magnitude d'un seul tenant, sur 6 jours, avec les trois plans\n//      réels de l'installation, et n'est censurée par rien. Le nœud s'en\n//      trouve simplifié : plus de répartition au prorata, plus de\n//      renormalisation.\n//\n// REPLI : si la courbe est absente ou périmée, on retombe sur la méthode 3\n// (total prévu réparti sur l'enveloppe), en le signalant par `source`.\n//\n// L'enveloppe garde un seul rôle : repère de vraisemblance. Elle n'écrête PAS\n// la prévision — étant minorée l'après-midi, elle tronquerait à tort.\n//\n// Ce nœud ne décide rien.\n// =====================================================================\n\nfunction num(v, fallback = NaN) {\n  const n = Number.parseFloat(v);\n  return Number.isFinite(n) ? n : fallback;\n}\n\nfunction round2(v) {\n  return Number.isFinite(v) ? Math.round(v * 100) / 100 : null;\n}\n\n// Le nœud HTTP de n8n renvoie le corps du template dans `data`, sous forme de\n// chaîne. Hors n8n (tests), l'objet arrive déjà décodé — on accepte les deux.\nfunction unwrapSnapshot(raw) {\n  if (raw && typeof raw.data === 'string') {\n    try { return JSON.parse(raw.data); } catch { return raw; }\n  }\n  return (raw && raw.data) || raw;\n}\n\nconst input = unwrapSnapshot($input.first().json);\n\nconst CFG = {\n  TIMEZONE: 'Europe/Paris',\n  // 40 h : assez pour qu'une traversée déficitaire commençant en fin\n  // d'après-midi se referme au croisement du lendemain matin. Avec 30 h, la\n  // fenêtre de la nuit restait ouverte et son heure de fin s'affichait « ? ».\n  // La courbe couvre aujourd'hui et demain, soit 48 h au plus.\n  HORIZON_HOURS: 40,\n  // Au-delà de cette part d'heures censurées, la forme de l'enveloppe est\n  // considérée comme minorée et signalée comme telle.\n  CENSORSHIP_QUALITY_LIMIT: 0.25,\n};\n\nconst nowMs = num(input.nowMs, Date.now());\nconst todayRemainingKwh = Math.max(0, num(input.forecast_today_remaining_kwh, 0));\nconst tomorrowKwh = Math.max(0, num(input.forecast_tomorrow_kwh, 0));\n\n// Fraîcheur de la courbe : le workflow de prévision tourne au quart d'heure.\n// Au-delà d'une heure sans mise à jour, on considère la courbe périmée et on\n// repasse au repli plutôt que de projeter sur une météo dépassée.\nconst FRESHNESS_LIMIT_MIN = 60;\nfunction parseStampParis(text) {\n  const m = /^(\\d{2})\\/(\\d{2})\\s+(\\d{2}):(\\d{2})$/.exec((text || '').toString().trim());\n  if (!m) return NaN;\n  const now = new Date(nowMs);\n  const guess = new Date(Date.UTC(now.getUTCFullYear(), +m[2] - 1, +m[1], +m[3] - 2, +m[4]));\n  // Passage d'année : une date future de plus d'un mois appartient à l'an dernier.\n  if (guess.getTime() - nowMs > 31 * 86400000) guess.setUTCFullYear(guess.getUTCFullYear() - 1);\n  return guess.getTime();\n}\nconst forecastUpdatedMs = parseStampParis(input.forecast_updated);\nconst forecastAgeMin = Number.isFinite(forecastUpdatedMs)\n  ? (nowMs - forecastUpdatedMs) / 60000\n  : Infinity;\nconst forecastFresh = forecastAgeMin <= FRESHNESS_LIMIT_MIN;\n\n// Enveloppe et taux de censure par heure : produits par le calcul quotidien et\n// stockés dans des helpers input_text sous forme de CSV compact. On accepte\n// aussi le tableau déjà décodé, ce qui rend le nœud testable hors n8n.\n// Absents au premier démarrage → on le dit, on ne fabrique pas de forme.\nfunction read24(arrayKey, csvKey) {\n  const direct = input[arrayKey];\n  if (Array.isArray(direct) && direct.length === 24) return direct.map(v => num(v, NaN));\n  const csv = input[csvKey];\n  if (typeof csv !== 'string') return null;\n  const parts = csv.split(',').map(v => Number.parseFloat(v.trim()));\n  if (parts.length !== 24 || parts.some(v => !Number.isFinite(v))) return null;\n  return parts;\n}\n\nconst hourlyToday = read24('forecast_today_kwh', 'forecast_today_csv');\nconst hourlyTomorrow = read24('forecast_tomorrow_kwh', 'forecast_tomorrow_csv');\n\nconst envelopeRaw = read24('envelope_kwh', 'envelope_csv');\nconst envelope = envelopeRaw ? envelopeRaw.map(v => Math.max(0, num(v, 0))) : null;\n\nconst censorshipRaw = read24('censorship_rate', 'censorship_rate_csv');\nconst censorshipRate = censorshipRaw\n  ? censorshipRaw.map(v => Math.max(0, Math.min(1, num(v, 1))))\n  : Array.from({ length: 24 }, () => 1);\n\nconst hourOfDay = (ms) =>\n  Number.parseInt(\n    new Intl.DateTimeFormat('fr-FR', {\n      timeZone: CFG.TIMEZONE, hour: '2-digit', hour12: false,\n    }).format(new Date(ms)),\n    10\n  );\n\nconst dayKey = (ms) =>\n  new Intl.DateTimeFormat('fr-CA', {\n    timeZone: CFG.TIMEZONE, year: 'numeric', month: '2-digit', day: '2-digit',\n  }).format(new Date(ms));\n\nconst currentHourStart = Math.floor(nowMs / 3600000) * 3600000;\nconst today = dayKey(nowMs);\n\n// Une courbe est utilisable si elle DECRIT le jour dont on a besoin, pas si\n// elle est recente. Une prevision publiee a 23:45 pour le 8 septembre reste\n// exacte a 03:00 : la nuit, il n'y a rien a reactualiser. Inversement, une\n// courbe publiee il y a dix minutes mais qui decrit la veille ne vaut rien.\n//\n// `forecast_day0` porte la date de la courbe « today » telle qu'elle etait au\n// moment de la publication. Deux cas seulement sont exploitables :\n//   day0 = aujourd'hui  -> lecture directe, cas normal\n//   day0 = hier         -> la publication date d'avant minuit : la courbe\n//                          « tomorrow » est celle d'aujourd'hui, et on n'a\n//                          rien pour demain (repli sur l'enveloppe).\n// Au-dela, les courbes sont trop vieilles pour dire quoi que ce soit.\n//\n// ⚠️ REPLI : `forecast_day0` absent ou illisible => on retombe sur l'ancienne\n// garde d'age. Tant que le helper n'existe pas cote Home Assistant, le\n// comportement est donc strictement inchange.\nconst forecastDay0 = (input.forecast_day0 || '').toString().trim();\nconst day0Lisible = /^\\d{4}-\\d{2}-\\d{2}$/.test(forecastDay0);\nconst veille = dayKey(nowMs - 86400000);\n\nlet hourlyForToday = null;\nlet hourlyForTomorrow = null;\nlet forecastAlignment;\nif (!day0Lisible) {\n  // Comportement historique, tant que la date n'est pas publiee.\n  forecastAlignment = 'date_absente';\n  if (forecastFresh) {\n    hourlyForToday = hourlyToday;\n    hourlyForTomorrow = hourlyTomorrow;\n  }\n} else if (forecastDay0 === today) {\n  forecastAlignment = 'a_jour';\n  hourlyForToday = hourlyToday;\n  hourlyForTomorrow = hourlyTomorrow;\n} else if (forecastDay0 === veille) {\n  forecastAlignment = 'decalee_d_un_jour';\n  hourlyForToday = hourlyTomorrow;\n  hourlyForTomorrow = null;\n} else {\n  forecastAlignment = 'perimee';\n}\nconst hourlyAvailable = !!hourlyForToday;\n\n// Une heure ou l'enveloppe demontree est nulle est une heure de nuit : il n'y\n// a jamais eu de soleil a y observer. Son taux de censure vaut 1 pour cette\n// raison-la, pas parce que la mesure serait douteuse, et il n'existe aucune\n// forme a minorer. La classer « minoree » faisait crier au loup TOUTES les\n// nuits (les heures de deficit sont justement les heures sans soleil), donc\n// exactement quand le bilan sert. Constate sur la nuit du 25-26/08 : statut\n// « degrade » de 20 h a 07 h alors que le bilan a predit le point bas a un\n// point pres.\nconst slots = [];\nfor (let i = 0; i < CFG.HORIZON_HOURS; i++) {\n  const start = currentHourStart + i * 3600000;\n  const hour = hourOfDay(start);\n  const nightHour = !!envelope && !(envelope[hour] > 0);\n  slots.push({\n    startMs: start,\n    hour,\n    day: dayKey(start),\n    weight: envelope ? envelope[hour] : 0,\n    quality: nightHour\n      ? 'nuit'\n      : censorshipRate[hour] <= CFG.CENSORSHIP_QUALITY_LIMIT ? 'fiable' : 'minoree',\n  });\n}\n\n// Répartition de l'énergie prévue au prorata de la forme démontrée.\nfunction distribute(daySlots, energyKwh) {\n  const totalWeight = daySlots.reduce((s, x) => s + x.weight, 0);\n  for (const slot of daySlots) {\n    slot.expectedKwh = totalWeight > 0 ? (slot.weight / totalWeight) * energyKwh : 0;\n  }\n}\n\nconst todaySlots = slots.filter(s => s.day === today);\nconst tomorrowSlots = slots.filter(s => s.day !== today);\n\nif (hourlyAvailable) {\n  // Lecture directe : chaque heure porte déjà son énergie prévue.\n  for (const slot of todaySlots) slot.expectedKwh = Math.max(0, hourlyForToday[slot.hour] ?? 0);\n  if (hourlyForTomorrow) {\n    for (const slot of tomorrowSlots) {\n      slot.expectedKwh = Math.max(0, hourlyForTomorrow[slot.hour] ?? 0);\n    }\n  } else {\n    // Courbe decalee : on connait aujourd'hui, pas demain. L'enveloppe mesuree\n    // reprend la main pour la suite de l'horizon plutot que de recopier la\n    // courbe du jour, qui serait une invention.\n    distribute(tomorrowSlots, tomorrowKwh);\n  }\n} else {\n  distribute(todaySlots, todayRemainingKwh);\n  distribute(tomorrowSlots, tomorrowKwh);\n}\n\n// Repère de vraisemblance, sans écrêtage : l'enveloppe est minorée l'après-midi.\nfor (const slot of slots) {\n  slot.aboveEnvelope = !!envelope && envelope[slot.hour] > 0\n    && slot.expectedKwh > envelope[slot.hour] * 1.5;\n}\n\n// Part de l'énergie projetée qui tombe sur des heures dont la forme est minorée :\n// c'est la mesure de confiance de cette projection.\nconst projected = slots.reduce((s, x) => s + x.expectedKwh, 0);\nconst projectedOnWeakShape = slots\n  .filter(x => x.quality === 'minoree')\n  .reduce((s, x) => s + x.expectedKwh, 0);\n\nreturn [{\n  json: {\n    generatedAt: new Date(nowMs).toISOString(),\n    usable: hourlyAvailable || !!envelope,\n    // Quelle source a réellement fourni la courbe ? (`source` ci-dessous est\n    // le détail des entrées ; `mode` dit laquelle a gagné.)\n    mode: hourlyAvailable ? 'courbe_horaire_api' : 'repli_enveloppe',\n\n    horizon: slots.map(s => ({\n      startMs: s.startMs,\n      hour: s.hour,\n      day: s.day,\n      expectedKwh: round2(s.expectedKwh),\n      shapeQuality: s.quality,\n    })),\n\n    todayExpectedRemainingKwh: round2(todaySlots.reduce((s, x) => s + x.expectedKwh, 0)),\n    tomorrowExpectedKwh: round2(tomorrowSlots.reduce((s, x) => s + x.expectedKwh, 0)),\n\n    source: {\n      todayRemainingKwh: round2(todayRemainingKwh),\n      tomorrowKwh: round2(tomorrowKwh),\n      envelopeProvided: !!envelope,\n      hourlyCurveAvailable: !!hourlyToday,\n      forecastAgeMin: Number.isFinite(forecastAgeMin) ? Math.round(forecastAgeMin) : null,\n      forecastFresh,\n      forecastDay0: forecastDay0 || null,\n      forecastAlignment,\n      hoursAboveEnvelope: slots.filter(s => s.aboveEnvelope).length,\n      shapeConfidence: projected > 0 ? round2(1 - projectedOnWeakShape / projected) : null,\n      weakShapeHours: slots\n        .filter(x => x.quality === 'minoree' && x.expectedKwh > 0)\n        .map(x => x.hour)\n        .filter((h, i, a) => a.indexOf(h) === i),\n    },\n\n    cfg: CFG,\n  },\n}];\n"
      }
    },
    {
      "name": "PREPARE_BALANCE",
      "type": "n8n-nodes-base.code",
      "typeVersion": 2,
      "position": [
        660,
        120
      ],
      "parameters": {
        "jsCode": "// EVCS Energy Balance — PREPARE_BALANCE\n// =====================================================================\n// Colle de câblage n8n, et rien d'autre. Les nœuds de calcul (CENSORSHIP,\n// RESOURCE_ESTIMATE, BALANCE) sont volontairement écrits pour ne lire que\n// `$input`, afin de rester testables hors de n8n. Ce nœud rassemble donc ce\n// que BALANCE attend, en puisant dans les nœuds précédents.\n//\n// Il fait aussi la seule conversion nécessaire : les profils horaires vivent\n// dans des helpers `input_text` sous forme de CSV compact (24 valeurs, moins\n// de 255 caractères), il faut les redonner sous forme de tableaux.\n// =====================================================================\n\nfunction parseCsv24(raw) {\n  if (typeof raw !== 'string') return null;\n  const parts = raw.split(',').map(v => Number.parseFloat(v.trim()));\n  if (parts.length !== 24 || parts.some(v => !Number.isFinite(v))) return null;\n  return parts;\n}\n\n// Le nœud HTTP de n8n renvoie le corps du template dans `data`, sous forme de\n// chaîne. Hors n8n (tests), l'objet arrive déjà décodé — on accepte les deux.\nfunction unwrapSnapshot(raw) {\n  if (raw && typeof raw.data === 'string') {\n    try { return JSON.parse(raw.data); } catch { return raw; }\n  }\n  return (raw && raw.data) || raw;\n}\n\nconst snapshot = unwrapSnapshot($('HA Snapshot Balance').first().json);\nconst resource = $input.first().json;\n\nreturn [{\n  json: {\n    nowMs: Number.parseFloat(snapshot.nowMs),\n\n    consumption_p50: parseCsv24(snapshot.consumption_p50_csv),\n    consumption_p80: parseCsv24(snapshot.consumption_p80_csv),\n\n    horizon: resource.horizon || [],\n\n    soc_percent: snapshot.soc_percent,\n    usable_capacity_kwh: snapshot.usable_capacity_kwh,\n    modules_en_service: snapshot.modules_en_service,\n    // Plancher dur : même valeur de repli que INPUT_PARSE.js\n    // (evcs_night_battery_hard_floor_pct n'est aujourd'hui exposé par AUCUN\n    // helper — la valeur « 22 % » documentée partout est en réalité un défaut\n    // de code, cf. backlog du chantier).\n    soc_floor_percent: 22,\n\n    // Vigilance Météo-France, lue sans connaître la commune (l'entité\n    // s'appelle sensor.<commune>_weather_alert). Absente tant que\n    // l'intégration n'est pas installée : le bilan publie alors\n    // 'indisponible' et ne change rien.\n    storm_alert_level: snapshot.storm_alert_level,\n    storm_alert_detail: snapshot.storm_alert_detail,\n\n    // Fenetres HC (28/09, « tenir jusqu'a la prochaine HC ») : horodatages\n    // calcules par le gabarit depuis les helpers victron_evcs_hc_*. Sans cette\n    // recopie, BALANCE.js ne les voit pas et la regle reste muette.\n    // Plancher de charge HC manuelle (18/09) : oublie ici jusqu'au 28/09, le\n    // bouton n'avait donc jamais atteint le bilan.\n    manual_hc_floor_percent: snapshot.manual_hc_floor_percent,\n    // Vehicule branche a midi (28/09, JEEP/VW/ZERO) : depart du jour et besoin saisi.\n    vehicle_connected: snapshot.vehicle_connected,\n    vehicle_departure_ms: snapshot.vehicle_departure_ms,\n    vehicle_level_pct: snapshot.vehicle_level_pct,\n    vehicle_level_valid: snapshot.vehicle_level_valid,\n    vehicle_capacity_kwh: snapshot.vehicle_capacity_kwh,\n    vehicle_charger_kw: snapshot.vehicle_charger_kw,\n    vehicle_delivered_since_level_kwh: snapshot.vehicle_delivered_since_level_kwh,\n    hc_window_end_ms: snapshot.hc_window_end_ms,\n    next_hc_start_ms: snapshot.next_hc_start_ms,\n    next_night_hc_start_ms: snapshot.next_night_hc_start_ms,\n\n    // Repris pour l'écriture des helpers, sans influencer le calcul.\n    resourceUsable: resource.usable,\n    shapeConfidence: resource.source ? resource.source.shapeConfidence : null,\n  },\n}];\n"
      }
    },
    {
      "name": "BALANCE",
      "type": "n8n-nodes-base.code",
      "typeVersion": 2,
      "position": [
        880,
        120
      ],
      "parameters": {
        "jsCode": "// EVCS Energy Balance — BALANCE\n// =====================================================================\n// Rôle : produire les FAITS qui remplacent les seuils fixes. Rien d'autre.\n// Ce nœud ne pilote ni EDF, ni la borne : il publie des grandeurs que les deux\n// contrôleurs liront à la place de leurs constantes.\n//\n// La question à laquelle il répond n'est pas « le SOC est-il au-dessus de\n// 30 % ? » mais « la batterie contient-elle de quoi tenir jusqu'à ce que le\n// solaire prenne le relais ? ». Le 24/08/2026 à 06:43, la réponse du seuil fixe\n// et celle du bilan diffèrent : la production ne couvrait la maison qu'à partir\n// de 09 h, il fallait donc environ 0,8 kWh de réserve, soit ~5 points de SOC —\n// et non un palier arbitraire à 30 %.\n//\n// Entrées (toutes fournies, aucune constante physique en dur) :\n//   consumption_p50[24]   profil horaire mesuré, valeur typique (CONSUMPTION_PROFILE)\n//   consumption_p80[24]   idem, valeur prudente\n//   horizon[]             production attendue heure par heure (RESOURCE_ESTIMATE)\n//   soc_percent           SOC lissé pour le pilotage\n//   usable_capacity_kwh   capacité réellement disponible du parc batterie\n//   soc_floor_percent     plancher dur de sécurité\n//\n// Sorties : heure de croisement · énergie à couvrir · SOC requis · marge\n// disponible pour le véhicule · niveau de confiance.\n// =====================================================================\n\nfunction num(v, fallback = NaN) {\n  const n = Number.parseFloat(v);\n  return Number.isFinite(n) ? n : fallback;\n}\n\nfunction round1(v) {\n  return Number.isFinite(v) ? Math.round(v * 10) / 10 : null;\n}\n\nfunction round2(v) {\n  return Number.isFinite(v) ? Math.round(v * 100) / 100 : null;\n}\n\nconst input = $input.first().json;\n\nconst CFG = {\n  TIMEZONE: 'Europe/Paris',\n  // Au-delà de cet horizon sans croisement trouvé, on cesse de chercher : la\n  // réponse n'aurait plus de sens opérationnel.\n  SEARCH_HOURS: 40,\n  // PAS de marge de sécurité supplémentaire. La prudence est déjà portée,\n  // entièrement, par le choix du percentile du profil de consommation (p80),\n  // qui est mesuré. Vérifié le 24/08/2026 : sur toutes les fenêtres testées,\n  // p80(somme des heures) est égal a somme(p80 par heure) — les heures de\n  // consommation sont fortement corrélées, une matinée chargée l'étant sur\n  // plusieurs heures d'affilée. Sommer les p80 ne cumule donc PAS deux\n  // pessimismes, et ajouter un coefficient par-dessus ne serait qu'une\n  // constante arbitraire de plus.\n};\n\nfunction profileOf(key) {\n  const a = input[key];\n  return Array.isArray(a) && a.length === 24 ? a.map(v => Math.max(0, num(v, 0))) : null;\n}\nconst consumptionP50 = profileOf('consumption_p50');\nconst consumptionP80 = profileOf('consumption_p80');\n\nconst horizon = Array.isArray(input.horizon) ? input.horizon : null;\n\nconst socPct = num(input.soc_percent, NaN);\nconst usableCapacityKwh = num(input.usable_capacity_kwh, NaN);\nconst socFloorPct = num(input.soc_floor_percent, 22);\n\n// =====================================================\n// CHARGE HC MANUELLE — UN PLANCHER, PAS UNE CIBLE (18/09/2026)\n// =====================================================\n// Le proprietaire veut pouvoir demander une recharge batterie en heures creuses\n// quand le bilan ne l'a pas jugee necessaire — journee d'hiver courte, ciel\n// couvert. La decision qu'il a tranchee : CONTRAINDRE le bilan plutot que de\n// l'ignorer, pour garder un seul arbitre. Ce projet a deja paye cher les\n// automates concurrents (charges programmees de l'ESS §26, consigne a 4200 W\n// §27, plancher SOC du GX §27).\n//\n// ⚠️ LE FORCAGE DOIT ETRE ICI, EN AMONT, ET NULLE PART AILLEURS. Mesure du\n// 18/09 sur banc : ecrire directement dans `input_number.evcs_balance_required_soc`\n// engage bien la session — contacteur ferme, takeover ON — mais laisse la\n// consigne reseau a 700 W, donc la batterie recoit une centaine de watts. C'est\n// le defaut du 01/09 et du 04/09 a l'identique, et c'est le seul resultat des\n// trois qui soit INDIAGNOSTICABLE depuis le tableau de bord : il a l'air de\n// marcher. La raison : `required_soc` ENGAGE la session, `grid_energy_needed_kwh`\n// la FINANCE, et les deux sont publiees separement. Pose ici, dans `coverage()`,\n// le plancher fait bouger les deux ENSEMBLE par construction — c'est une\n// consequence de la forme du code et non une discipline a tenir.\n//\n// ⚠️ ET CE PLANCHER EST DEJA FILTRE PAR L'HEURE QUAND IL ARRIVE ICI. Le bilan\n// ignore totalement les fenetres d'heures creuses (aucune occurrence de\n// `hc_night` / `hc_midday` dans ce sous-systeme) et doit le rester : il repond a\n// « de combien la batterie a-t-elle besoin », pas a « quand est-ce bon marche ».\n// C'est Home Assistant qui detient le calendrier tarifaire et qui ne publie une\n// valeur non nulle que pendant une fenetre creuse. Sans ce filtrage en amont, un\n// plancher a 85 % fuirait dans la journee et mordrait sur\n// `BATTERY_CLOUD_LOCKS.js` — `eveningSocStartFloorPct = max(eveningSocStartMin,\n// balanceRequiredSocPct)` — au point de bloquer la charge du vehicule le soir.\nconst manualHcFloorPct = (() => {\n  const v = num(input.manual_hc_floor_percent, 0);\n  return Number.isFinite(v) && v > socFloorPct && v <= 100 ? v : 0;\n})();\n\n// Sans l'une de ces entrées, le bilan ne peut rien affirmer. Il le dit, et les\n// contrôleurs retombent sur leurs règles historiques.\nconst missing = [];\nif (!consumptionP50) missing.push('consumption_p50');\nif (!consumptionP80) missing.push('consumption_p80');\nif (!horizon || !horizon.length) missing.push('horizon');\nif (!Number.isFinite(socPct)) missing.push('soc_percent');\nif (!Number.isFinite(usableCapacityKwh) || usableCapacityKwh <= 0) missing.push('usable_capacity_kwh');\n\nif (missing.length) {\n  return [{\n    json: {\n      usable: false,\n      missing,\n      reason: `Bilan indisponible : ${missing.join(', ')}. Les contrôleurs doivent conserver leurs règles.`,\n      cfg: CFG,\n    },\n  }];\n}\n\n// ---------------------------------------------------------------------\n// Bilan heure par heure, calculé DEUX FOIS.\n//\n// Pourquoi deux niveaux de prudence et pas un seul : la décision « faut-il du\n// réseau maintenant ? » est réévaluée à chaque cycle et reste réversible. Se\n// tromper par optimisme ne coûte qu'un démarrage réseau une heure plus tard,\n// le plancher dur garantissant la batterie ; se tromper par excès de prudence\n// coûte un import réseau bien réel, immédiatement.\n//\n// Vérifié sur la matinée du 24/08/2026 : avec le profil prudent, le bilan\n// exigerait 48 % de SOC pour franchir la matinée, alors que la consommation\n// réelle de ce jour-là n'a demandé que 0,8 kWh — le seuil fixe de 30 % aurait\n// été MOINS coûteux. Un bilan « intelligent » plus gourmand que le seuil bête\n// qu'il remplace n'a aucun intérêt.\n//\n//   - profil TYPIQUE (p50)  → décision réseau immédiate, réévaluée en continu.\n//   - profil PRUDENT (p80)  → planification : cible de nuit, dimensionnement\n//                             du stockage, choix qui engagent plusieurs heures.\n// ---------------------------------------------------------------------\nfunction buildSlots(consumption) {\n  return horizon.slice(0, CFG.SEARCH_HOURS).map(slot => {\n    const hour = num(slot.hour, 0);\n    const productionKwh = Math.max(0, num(slot.expectedKwh, 0));\n    const consumptionKwh = consumption[hour] ?? 0;\n    return {\n      startMs: slot.startMs,\n      hour,\n      productionKwh: round2(productionKwh),\n      consumptionKwh: round2(consumptionKwh),\n      netKwh: round2(productionKwh - consumptionKwh),\n      shapeQuality: slot.shapeQuality || 'inconnue',\n    };\n  });\n}\n\n// =====================================================================\n// COURBE D'ENERGIE DE LA BATTERIE — MESUREE, PAS SUPPOSEE (03/09/2026)\n// =====================================================================\n// La conversion energie <-> points de SOC etait une CONSTANTE\n// (`usable_capacity_kwh`, 15 kWh) la ou la realite est une COURBE.\n//\n// Mesure : 576 paliers de SOC sur 8 jours (`tools/mesure-courbe-batterie.mjs`).\n// Pour chaque palier ou le SOC reste a une valeur puis DESCEND d'un point, on\n// integre la puissance batterie — en ecartant les paliers ou la batterie a\n// charge ou ou le reseau a apporte quoi que ce soit.\n//\n//   tranche   paliers   kWh/point\n//   21-31        88       0,097     <- effondrement pres du genou\n//   35-44        78       0,171\n//   45-54        76       0,169\n//   55-64        85       0,163\n//   65-74        80       0,171\n//   75-84        81       0,170\n//   85-94        62       0,169\n//\n// Plate a 0,169 de 33 a 93, genou net a 32-33, puis 0,097 : sous le genou, un\n// point de SOC vaut 57 % de ce qu'il vaut au-dessus. Coherent avec §0 (un\n// module en panne sur huit, un autre qui faiblit) et avec l'effondrement de la\n// jauge deja signale au §28 — ceci lui donne sa courbe.\n//\n// CE QUE LA CONSTANTE FAISAIT : 15 kWh se situe ENTRE les deux pentes, donc\n// l'erreur CHANGE DE SIGNE selon l'energie a couvrir —\n//   1 kWh a couvrir  : SOC requis 28,7 % annonce contre 32,3 % reel  (-3,6)\n//   4,3 kWh          : 50,7 contre 52,1                              (-1,4)\n//   8 kWh            : 75,3 contre 74,0                              (+1,3)\n//   11,7 kWh         : 99,7 contre 95,7                              (+4,1)\n// Trop BAS en fin de nuit (la direction dangereuse), trop HAUT en debut.\n//\n// Energie utile totale de 100 a 22 % : 12,39 kWh mesures, contre 11,70 vus par\n// le bilan et 13,65 par INPUT_PARSE. Les deux constantes existantes etaient\n// fausses, dans des sens opposes.\n//\n// ⚠️ A RE-MESURER apres toute evolution du parc (extension prevue cet hiver) :\n// `node tools/mesure-courbe-batterie.mjs 8`, puis mettre a jour ces trois\n// nombres. Ce ne sont pas des reglages, ce sont des resultats de mesure.\n//\n// ⚠️ CES PENTES ONT ETE MESUREES SUR SEPT MODULES. Retirer ou ajouter un module\n// divise ou multiplie la capacite sans changer la FORME de la courbe : on les\n// exprime donc par module, et on les multiplie par le nombre reellement en\n// service. Ce nombre se lit dans un helper — `input_number\n// .evcs_balance_modules_en_service` — et non dans le code : le parc a change\n// deux fois en une semaine et changera encore cet hiver. Helper absent ou\n// illisible => 7, la valeur sur laquelle la mesure a ete faite, donc aucun\n// changement de comportement tant que personne ne l'ecrit.\nconst MODULES_MESURE = 7;\nconst modulesEnService = (() => {\n  const n = num(input.modules_en_service, MODULES_MESURE);\n  return Number.isFinite(n) && n >= 1 && n <= 24 ? n : MODULES_MESURE;\n})();\nconst echelleParc = modulesEnService / MODULES_MESURE;\n\n// 20/09/2026 — RE-MESURE sur le parc ASSAINI (13 equivalents US2000 : 4 US5000\n// + 5 US2000C, cellules a 3-6 mV). `tools/mesure-courbe-batterie.mjs 8` :\n// 0,30 kWh/point PLAT de 25 a 97 %, PLUS DE GENOU. Le genou a 33 % etait bien\n// la signature de la cellule 12 morte du pack ancien (§50) — il a disparu avec\n// elle, exactement comme le predisait la note de prudence du 03/09. La reserve\n// reelle a quasiment double (12,4 -> ~23 kWh utiles de 100 a 22 %).\n// Base normalisee a 7 modules (MODULES_MESURE) : 0,30 x 7/13 = 0,1615 par point.\n// x echelleParc(13/7) = 0,30 au parc actuel. Pente unique => plus de genou.\n// A REMESURER apres toute evolution du parc (2e cable console en commande pour\n// surveiller aussi les cellules du pack 1 US5000).\nconst BATTERY_CURVE = {\n  kneePct: 0,\n  kwhPerPointAbove: 0.1615 * echelleParc,\n  kwhPerPointBelow: 0.1615 * echelleParc,\n};\n\n// Energie que la batterie peut delivrer en descendant de socHi a socLo.\nfunction energyBetweenSoc(socLo, socHi) {\n  if (!Number.isFinite(socLo) || !Number.isFinite(socHi) || socHi <= socLo) return 0;\n  const knee = BATTERY_CURVE.kneePct;\n  const lowSpan = Math.max(0, Math.min(socHi, knee) - Math.min(socLo, knee));\n  const highSpan = Math.max(0, Math.max(socHi, knee) - Math.max(socLo, knee));\n  return lowSpan * BATTERY_CURVE.kwhPerPointBelow\n       + highSpan * BATTERY_CURVE.kwhPerPointAbove;\n}\n\n// SOC necessaire pour delivrer energyKwh en descendant jusqu'a floorPct.\n// NON ecrete : au-dela de 100 la valeur reste le signal de sous-dimensionnement\n// (cf. §26). L'extrapolation au-dessus de 100 utilise la pente haute.\nfunction socForEnergy(energyKwh, floorPct) {\n  if (!Number.isFinite(energyKwh) || energyKwh <= 0) return floorPct;\n  const knee = Math.max(floorPct, BATTERY_CURVE.kneePct);\n  const belowKwh = (knee - floorPct) * BATTERY_CURVE.kwhPerPointBelow;\n  if (energyKwh <= belowKwh) {\n    return floorPct + energyKwh / BATTERY_CURVE.kwhPerPointBelow;\n  }\n  return knee + (energyKwh - belowKwh) / BATTERY_CURVE.kwhPerPointAbove;\n}\n\n// SOC atteint en ajoutant addKwh a partir de socPct.\nfunction socAfterEnergy(socPct, addKwh) {\n  if (!Number.isFinite(addKwh) || addKwh <= 0) return socPct;\n  return socForEnergy(energyBetweenSoc(0, socPct) + addKwh, 0);\n}\n\n// =====================================================\n// TENIR JUSQU'A LA PROCHAINE FENETRE HC (28/09/2026)\n// =====================================================\n// Strategie du proprietaire, apres la nuit du 26-27/09 : P12 avait charge la\n// JEEP sur la batterie (72 -> 44 %) parce qu'il restait assez pour atteindre le\n// solaire du matin — alors que ce meme bilan annoncait deja « prochaine\n// traversee 17,35 kWh des 18 h -> SOC requis 79,8 % ». La journee (22 kWh reels)\n// n'a pas pu reconstituer la reserve. Sa regle : une voiture branchee se charge\n// en heures creuses sur le reseau, et la batterie doit TENIR JUSQU'A LA\n// PROCHAINE FENETRE HC ; si elle ne le peut pas, la fenetre HC de midi la\n// complete.\n//\n// Traduction : PENDANT une fenetre HC, l'exigence vaut au moins le SOC qu'il\n// faut avoir A LA FIN de cette fenetre pour atteindre le DEBUT de la suivante\n// sans passer sous le plancher, production prevue comprise (tranches horaires\n// ci-dessus, heure par heure, profil de conso du profil calcule).\n//\n// ⚠️ LE CALENDRIER RESTE DANS HOME ASSISTANT (§73) : le bilan ne recoit que deux\n// instants, la fin de la fenetre en cours (absente hors fenetre) et le debut de\n// la suivante. Hors fenetre HC, rien ne change.\n//\n// ⚠️ INSERE DANS coverage(), COMME LE PLANCHER MANUEL : la cible (required_soc,\n// qui ENGAGE la session et releve le plancher de P12) et le manque en kWh (qui\n// FINANCE la consigne) bougent ensemble par construction — jamais de session\n// muette (§73). Sens unique : il ne peut que RELEVER l'exigence.\nconst hcWindowEndMs = num(input.hc_window_end_ms, NaN);\nconst nextHcStartMs = num(input.next_hc_start_ms, NaN);\nconst nextNightHcStartMs = num(input.next_night_hc_start_ms, NaN);\nconst hcReachActive = Number.isFinite(hcWindowEndMs) && Number.isFinite(nextHcStartMs)\n  && nextHcStartMs > hcWindowEndMs;\n// DEUX HORIZONS, DEUX USAGES (decision du proprietaire, 28/09) :\n//   - recharger la batterie au reseau : tenir jusqu'a la PROCHAINE fenetre HC\n//     (la nuit : midi ; a midi : 01:24). Midi complete si besoin, et la matinee\n//     garde de la place pour le solaire. -> required_soc (engage ET finance).\n//   - laisser la voiture puiser dans la batterie la nuit (P12) : seulement si la\n//     batterie tient ensuite jusqu'a la NUIT SUIVANTE (01:24), sans compter sur\n//     midi. Sinon la voiture se charge sur le reseau en HC. -> required_soc_prudent,\n//     qui n'est lu que comme plancher de P12 (et par le conseiller, pour info).\nconst hcNightReachActive = Number.isFinite(hcWindowEndMs) && Number.isFinite(nextNightHcStartMs)\n  && nextNightHcStartMs > hcWindowEndMs;\n\n// Energie a avoir en reserve a la fin de la fenetre : parcours A REBOURS des\n// tranches comprises entre les deux instants (au prorata de leur recouvrement).\n// Un surplus ne rembourse qu'un deficit POSTERIEUR — d'ou le sens du parcours.\nfunction hcReachFloorPct(slots, untilMs = nextHcStartMs, fromMs = hcWindowEndMs) {\n  if (!Number.isFinite(fromMs) || !Number.isFinite(untilMs) || untilMs <= fromMs) return 0;\n  let needKwh = 0;\n  for (let i = slots.length - 1; i >= 0; i--) {\n    const s = slots[i];\n    const debut = num(s.startMs, NaN);\n    if (!Number.isFinite(debut)) continue;\n    const a = Math.max(debut, fromMs);\n    const b = Math.min(debut + 3600000, untilMs);\n    if (b <= a) continue;\n    needKwh = Math.max(0, needKwh - s.netKwh * (b - a) / 3600000);\n  }\n  return needKwh > 0 ? socForEnergy(needKwh, socFloorPct) : 0;\n}\n\nfunction coverage(slots, hcFloorPct = 0) {\n  const crossingIndex = slots.findIndex(s => s.netKwh > 0);\n  const found = crossingIndex >= 0;\n  const deficitSlots = found ? slots.slice(0, crossingIndex) : slots;\n  const energyToCoverKwh = deficitSlots.reduce((sum, s) => sum + Math.max(0, -s.netKwh), 0);\n  // Le plancher manuel ne peut que RELEVER l'exigence, jamais l'abaisser — meme\n  // sens unique que les cablages de §38, §39 et §40 : le bilan ne pousse jamais\n  // dans la direction « couvre moins bien ».\n  const requiredSocRawPct = Math.max(\n    socForEnergy(energyToCoverKwh, socFloorPct),\n    manualHcFloorPct,\n    hcFloorPct\n  );\n  const socNeededPct = requiredSocRawPct - socFloorPct;\n  const requiredSocPct = Math.min(100, requiredSocRawPct);\n  const socMarginPct = socPct - requiredSocPct;\n  return {\n    crossingIndex, found, deficitSlots, slots,\n    energyToCoverKwh, socNeededPct, requiredSocPct, socMarginPct,\n    gridNeeded: socMarginPct < 0,\n    gridEnergyNeededKwh: socMarginPct < 0 ? energyBetweenSoc(socPct, requiredSocPct) : 0,\n  };\n}\n\nconst slotsP50 = buildSlots(consumptionP50);\nconst slotsP80 = buildSlots(consumptionP80);\nconst hcFloorTypicalPct = hcReachFloorPct(slotsP50, nextHcStartMs);\nconst hcFloorNightPrudentPct = hcNightReachActive ? hcReachFloorPct(slotsP80, nextNightHcStartMs) : 0;\nconst hcFloorPrudentPct = Math.max(hcReachFloorPct(slotsP80, nextHcStartMs), hcFloorNightPrudentPct);\nconst typical = coverage(slotsP50, hcFloorTypicalPct);\nconst prudent = coverage(slotsP80, hcFloorPrudentPct);\n\n// ---------------------------------------------------------------------\n// VEHICULE BRANCHE EN HC AVEC UN DEPART AVANT LA PROCHAINE HC (28/09/2026)\n//\n// Regle du proprietaire : « JEEP branchee engage le reseau en HC midi si\n// l'analyse de production le justifie ». La JEEP repart a 15:30 certains jours\n// (calendrier dans HA) : ce qu'elle n'a pas pris avant, elle ne le prendra pas\n// en HC la nuit. Ailleurs, elle reste branchee et la HC de 01:24 la finit au\n// meme tarif — fermer le contacteur a midi n'y gagnerait rien et etoufferait le\n// solaire (installation sans injection).\n//\n// Ce que le solaire peut donner a la voiture avant son depart SANS toucher a\n// la reserve de la nuit : l'energie de la batterie au-dessus du plancher\n// « tenir jusqu'a la prochaine HC » evalue AU DEPART, plus le bilan net prevu\n// (production - maison) d'ici le depart. Profil p50, comme required_soc.\n// Le reseau est justifie quand le besoin de la voiture, borne par ce que son\n// chargeur peut absorber avant le depart, depasse ce solaire.\n//\n// Besoin = (100 - niveau saisi) % x capacite MESUREE au compteur de la borne,\n// moins ce que la borne a deja delivre depuis la saisie. Aucun capteur ne donne\n// le niveau de la voiture : sans saisie valable, la regle se tait.\n//\n// Vaut pour les TROIS vehicules (JEEP, VW, moto ZERO) : capacite, puissance de\n// charge et calendrier viennent de HA pour le vehicule selectionne.\n// La puissance du chargeur EMBARQUE (plateau mesure : JEEP 3,66 kW, VW\n// 3,68 kW) borne ce que le vehicule peut prendre avant son depart ; inconnue\n// (0), on ne borne pas — l'erreur va alors vers « reseau justifie », c'est-a-\n// dire vers le vehicule charge, jamais vers la batterie videe.\n// Seuil de 0,5 kWh : en dessous une session ne se justifie pas — une fermeture\n// du contacteur coute 50 a 150 Wh de transitoire (§57), on exige un gain d'au\n// moins trois fois ce cout.\nconst VEHICLE_GRID_MIN_SHORTFALL_KWH = 0.5;\nconst vehicleChargerKw = num(input.vehicle_charger_kw, NaN);\nconst nowMsBalance = num(input.nowMs, Date.now());\nconst vehicleConnected = input.vehicle_connected === true || input.vehicle_connected === 'true';\nconst vehicleDepartureMs = num(input.vehicle_departure_ms, NaN);\nconst vehicleLevelPct = num(input.vehicle_level_pct, NaN);\nconst vehicleLevelValid = input.vehicle_level_valid === true || input.vehicle_level_valid === 'true';\nconst vehicleCapacityKwh = num(input.vehicle_capacity_kwh, NaN);\nconst vehicleDeliveredKwh = Math.max(0, num(input.vehicle_delivered_since_level_kwh, 0));\nconst vehicleNeedKwh =\n  vehicleLevelValid && Number.isFinite(vehicleLevelPct) && vehicleLevelPct >= 0 && vehicleLevelPct <= 100\n  && Number.isFinite(vehicleCapacityKwh) && vehicleCapacityKwh > 0\n    ? Math.max(0, (100 - vehicleLevelPct) / 100 * vehicleCapacityKwh - vehicleDeliveredKwh)\n    : NaN;\nconst vehicleRuleActive =\n  hcReachActive && vehicleConnected && Number.isFinite(vehicleNeedKwh)\n  && Number.isFinite(vehicleDepartureMs) && vehicleDepartureMs > nowMsBalance\n  && vehicleDepartureMs < nextHcStartMs;\nlet vehicleSolarKwh = null;\nlet vehicleReachableKwh = null;\nlet vehicleShortfallKwh = null;\nlet vehicleFloorAtDeparturePct = null;\nif (vehicleRuleActive) {\n  vehicleFloorAtDeparturePct = hcReachFloorPct(slotsP50, nextHcStartMs, vehicleDepartureMs);\n  let netKwh = 0;\n  for (const sl of slotsP50) {\n    const debut = num(sl.startMs, NaN);\n    if (!Number.isFinite(debut)) continue;\n    const a = Math.max(debut, nowMsBalance);\n    const b = Math.min(debut + 3600000, vehicleDepartureMs);\n    if (b > a) netKwh += sl.netKwh * (b - a) / 3600000;\n  }\n  // Difference SIGNEE : une batterie SOUS son plancher doit d'abord etre\n  // remontee par ce meme surplus avant que la voiture n'en voie un kWh.\n  const plancherDepart = Math.max(socFloorPct, vehicleFloorAtDeparturePct);\n  const batterieAuDessusKwh = socPct >= plancherDepart\n    ? energyBetweenSoc(plancherDepart, socPct)\n    : -energyBetweenSoc(socPct, plancherDepart);\n  vehicleSolarKwh = Math.max(0, batterieAuDessusKwh + netKwh);\n  vehicleReachableKwh = Number.isFinite(vehicleChargerKw) && vehicleChargerKw > 0\n    ? Math.min(vehicleNeedKwh, vehicleChargerKw * (vehicleDepartureMs - nowMsBalance) / 3600000)\n    : vehicleNeedKwh;\n  vehicleShortfallKwh = Math.max(0, vehicleReachableKwh - vehicleSolarKwh);\n}\nconst vehicleGridNeeded = vehicleRuleActive && vehicleShortfallKwh > VEHICLE_GRID_MIN_SHORTFALL_KWH;\n\n// ---------------------------------------------------------------------\n// PROCHAINE FENÊTRE DE DÉFICIT (ajout du 24/08/2026)\n//\n// Le calcul ci-dessus répond à « combien d'énergie jusqu'à ce que le solaire\n// prenne le relais ». À 15 h, le solaire a déjà pris le relais : la réponse est\n// zéro et le SOC requis retombe sur le plancher. C'est exact mais inutile à\n// cette heure-là, car le déficit qui approche est celui de la nuit.\n//\n// On cherche donc AUSSI la prochaine fenêtre de déficit après le surplus en\n// cours : son heure de début, son énergie, et le SOC qu'il faudra avoir atteint\n// à ce moment-là. C'est cette grandeur qui remplace la cible de nuit fixe, et\n// qui dit combien de surplus il faut avoir stocké avant le coucher du soleil.\n//\n// Profil PRUDENT : contrairement à la décision réseau immédiate, cette\n// projection engage plusieurs heures et n'est pas révisable à volonté — la nuit\n// tombée, il n'y a plus de solaire pour rattraper une sous-estimation.\n// ---------------------------------------------------------------------\nfunction nextDeficitWindow(slots) {\n  const firstSurplus = slots.findIndex(s => s.netKwh > 0);\n  if (firstSurplus < 0) return { found: false, reason: 'deficit_en_cours' };\n\n  const start = slots.findIndex((s, i) => i > firstSurplus && s.netKwh < 0);\n  if (start < 0) return { found: false, reason: 'aucun_deficit_sur_horizon' };\n\n  let end = slots.findIndex((s, i) => i > start && s.netKwh > 0);\n  if (end < 0) end = slots.length;\n\n  const energyKwh = slots.slice(start, end)\n    .reduce((sum, s) => sum + Math.max(0, -s.netKwh), 0);\n\n  // Surplus encore récupérable d'ici là : de quoi remplir, ou pas.\n  const surplusBeforeKwh = slots.slice(0, start)\n    .reduce((sum, s) => sum + Math.max(0, s.netKwh), 0);\n\n  return {\n    found: true,\n    startHour: slots[start].hour,\n    startMs: slots[start].startMs,\n    hoursFromNow: start,\n    endHour: end < slots.length ? slots[end].hour : null,\n    complete: end < slots.length,\n    energyKwh,\n    // NON écrêté à 100 volontairement : une valeur au-dessus de 100 signifie\n    // que même une batterie pleine ne suffit pas à traverser la fenêtre. C'est\n    // exactement le signal de sous-dimensionnement du stockage — l'écrêter le\n    // masquerait.\n    requiredSocAtStartPct: socForEnergy(energyKwh, socFloorPct),\n    surplusBeforeKwh,\n  };\n}\n\nconst nextDeficit = nextDeficitWindow(prudent.slots);\n\n// ---------------------------------------------------------------------\n// RÉSERVE D'ORAGE (27/08/2026)\n//\n// Les coupures réseau sont fréquentes ici lors des orages. Point de départ\n// souvent mal posé : une coupure n'arrête PAS l'installation. Le solaire et\n// la batterie continuent de fonctionner, seul le filet de secours disparaît.\n// La question n'est donc pas « combien stocker pour survivre » mais « la\n// batterie traverse-t-elle la prochaine fenêtre de déficit SANS le réseau ».\n//\n// C'est exactement la couverture PRUDENTE (p80) déjà calculée plus haut :\n// rien à inventer, aucune constante de plus. Le profil prudent est le bon\n// choix ici parce qu'une coupure retire précisément la possibilité de\n// rattraper une sous-estimation.\n//\n// Le niveau vient de la vigilance Météo-France, dont l'échelle officielle est\n// vert/jaune/orange/rouge. « Actif » à partir d'orange : c'est le seuil de\n// l'émetteur, pas un nombre choisi ici.\n// ---------------------------------------------------------------------\nconst STORM_SCALE = ['vert', 'jaune', 'orange', 'rouge'];\nconst STORM_ACTIVE_FROM = STORM_SCALE.indexOf('orange');\n\nconst stormRaw = typeof input.storm_alert_level === 'string'\n  ? input.storm_alert_level.trim().toLowerCase()\n  : '';\nconst stormIndex = STORM_SCALE.indexOf(stormRaw);\nconst stormKnown = stormIndex >= 0;\nconst stormActive = stormIndex >= STORM_ACTIVE_FROM;\n\n// Phénomènes atteignant le niveau d'alerte, s'ils sont exposés en attributs\n// (« Orages », « Vent violent »…). Purement informatif.\nconst stormDetail = (input.storm_alert_detail && typeof input.storm_alert_detail === 'object')\n  ? input.storm_alert_detail\n  : {};\nconst stormPhenomena = Object.keys(stormDetail)\n  .filter(k => typeof stormDetail[k] === 'string'\n    && STORM_SCALE.indexOf(stormDetail[k].trim().toLowerCase()) >= STORM_ACTIVE_FROM)\n  .sort();\n\n// En surplus, la fenêtre qui compte est la prochaine (la nuit qui vient) ;\n// en déficit, c'est celle qu'on est en train de traverser.\nconst inSurplusNow = prudent.found && prudent.crossingIndex === 0;\nconst stormWindow = (inSurplusNow && nextDeficit.found)\n  ? {\n      kwh: nextDeficit.energyKwh,\n      socPct: nextDeficit.requiredSocAtStartPct,\n      startHour: nextDeficit.startHour,\n    }\n  : {\n      kwh: prudent.energyToCoverKwh,\n      socPct: prudent.requiredSocPct,\n      startHour: null,\n    };\nconst stormMarginPct = socPct - stormWindow.socPct;\n\nconst slots = typical.slots;\nconst crossingFound = typical.found;\nconst crossingIndex = typical.crossingIndex;\nconst crossing = crossingFound ? slots[crossingIndex] : null;\nconst deficitSlots = typical.deficitSlots;\n\n// ---------------------------------------------------------------------\n// Marge disponible pour le véhicule : surplus attendu après le croisement,\n// une fois la maison servie. C'est ce qui peut être chargé sans toucher au\n// réseau ni entamer la réserve.\n// ---------------------------------------------------------------------\nconst surplusAfterCrossingKwh = crossingFound\n  ? slots.slice(crossingIndex).reduce((sum, s) => sum + Math.max(0, s.netKwh), 0)\n  : 0;\n\n// ---------------------------------------------------------------------\n// Confiance : la part du calcul qui repose sur une forme de production minorée\n// (après-midi censuré). Elle ne dégrade PAS la réponse « faut-il du réseau »,\n// qui se joue sur les heures de déficit — celles-ci ne sont jamais censurées,\n// une heure censurée étant par construction une heure de surplus.\n// ---------------------------------------------------------------------\nconst deficitOnWeakShape = deficitSlots.filter(s => s.shapeQuality === 'minoree').length;\nconst confidence = {\n  deficitHoursOnWeakShape: deficitOnWeakShape,\n  deficitTrustworthy: deficitOnWeakShape === 0,\n  surplusTrustworthy: !slots.slice(crossingFound ? crossingIndex : 0)\n    .some(s => s.shapeQuality === 'minoree'),\n};\n\nreturn [{\n  json: {\n    usable: true,\n    generatedAt: new Date(num(input.nowMs, Date.now())).toISOString(),\n\n    crossing: {\n      found: crossingFound,\n      hour: crossing ? crossing.hour : null,\n      startMs: crossing ? crossing.startMs : null,\n      hoursFromNow: crossingFound ? crossingIndex : null,\n    },\n\n    coverage: {\n      // Décision réseau immédiate — remplace input_number.victron_grid_soc_off.\n      energyToCoverKwh: round2(typical.energyToCoverKwh),\n      requiredSocPct: round1(typical.requiredSocPct),\n      currentSocPct: round1(socPct),\n      socMarginPct: round1(typical.socMarginPct),\n      gridNeeded: typical.gridNeeded,\n      gridEnergyNeededKwh: round2(typical.gridEnergyNeededKwh),\n\n      // Planification (cible de nuit, dimensionnement) — ne pilote PAS le réseau.\n      prudent: {\n        energyToCoverKwh: round2(prudent.energyToCoverKwh),\n        requiredSocPct: round1(prudent.requiredSocPct),\n        socMarginPct: round1(prudent.socMarginPct),\n        crossingHour: prudent.found ? prudent.slots[prudent.crossingIndex].hour : null,\n      },\n    },\n\n    // Ce qu'il faudra avoir stocké avant la prochaine traversée déficitaire.\n    nextDeficit: nextDeficit.found ? {\n      found: true,\n      startHour: nextDeficit.startHour,\n      hoursFromNow: nextDeficit.hoursFromNow,\n      endHour: nextDeficit.endHour,\n      complete: nextDeficit.complete,\n      energyKwh: round2(nextDeficit.energyKwh),\n      requiredSocAtStartPct: round1(nextDeficit.requiredSocAtStartPct),\n      surplusBeforeKwh: round2(nextDeficit.surplusBeforeKwh),\n      // Franchissable avec le stockage actuel, batterie pleine ?\n      feasibleWithCurrentStorage: nextDeficit.requiredSocAtStartPct <= 100,\n      // Si non : capacité utile manquante. C'est le chiffre du dimensionnement.\n      storageShortfallKwh: energyBetweenSoc(100, nextDeficit.requiredSocAtStartPct),\n      reachable: nextDeficit.surplusBeforeKwh >= 0\n        && socAfterEnergy(socPct, nextDeficit.surplusBeforeKwh)\n           >= nextDeficit.requiredSocAtStartPct,\n    } : { found: false, reason: nextDeficit.reason },\n\n    vehicle: {\n      surplusAvailableKwh: round2(surplusAfterCrossingKwh),\n    },\n\n    // Voiture branchee en HC, depart avant la prochaine HC (28/09).\n    vehicleMidday: {\n      active: vehicleRuleActive,\n      needKwh: Number.isFinite(vehicleNeedKwh) ? round2(vehicleNeedKwh) : null,\n      departureMs: Number.isFinite(vehicleDepartureMs) ? vehicleDepartureMs : null,\n      solarKwh: vehicleSolarKwh === null ? null : round2(vehicleSolarKwh),\n      reachableKwh: vehicleReachableKwh === null ? null : round2(vehicleReachableKwh),\n      shortfallKwh: vehicleShortfallKwh === null ? null : round2(vehicleShortfallKwh),\n      floorAtDeparturePct: vehicleFloorAtDeparturePct === null ? null : round1(vehicleFloorAtDeparturePct),\n      gridNeeded: vehicleGridNeeded,\n    },\n\n    // Tenir jusqu'a la prochaine fenetre HC (28/09) : SOC a avoir en fin de\n    // fenetre HC en cours. 0 hors fenetre ou si la production suffit.\n    hcReach: {\n      active: hcReachActive,\n      windowEndMs: hcReachActive ? hcWindowEndMs : null,\n      nextHcStartMs: hcReachActive ? nextHcStartMs : null,\n      floorPct: round1(Math.min(100, hcFloorTypicalPct)),\n      floorPrudentPct: round1(Math.min(100, hcFloorPrudentPct)),\n      nextNightHcStartMs: hcNightReachActive ? nextNightHcStartMs : null,\n      nightFloorPrudentPct: round1(Math.min(100, hcFloorNightPrudentPct)),\n      raisesRequirement: hcReachActive && hcFloorTypicalPct >= typical.requiredSocPct - 0.05\n        && hcFloorTypicalPct > socForEnergy(typical.energyToCoverKwh, socFloorPct),\n    },\n\n    // Réserve à tenir pour traverser SANS réseau la fenêtre de déficit qui\n    // compte. Publiée en permanence — elle documente le risque même par temps\n    // calme ; `active` dit seulement si la vigilance la rend d'actualité.\n    storm: {\n      level: stormKnown ? stormRaw : 'indisponible',\n      known: stormKnown,\n      active: stormActive,\n      phenomena: stormPhenomena,\n      windowStartHour: stormWindow.startHour,\n      reserveKwh: round2(stormWindow.kwh),\n      reserveSocPct: round1(stormWindow.socPct),\n      socMarginPct: round1(stormMarginPct),\n      covered: stormMarginPct >= 0,\n      shortfallKwh: stormMarginPct < 0\n        ? round2(energyBetweenSoc(socPct, stormWindow.socPct))\n        : 0,\n    },\n\n    confidence,\n    slots,\n\n    inputs: {\n      usableCapacityKwh: round2(usableCapacityKwh),\n      socFloorPct: round1(socFloorPct),\n    },\n\n    cfg: CFG,\n  },\n}];\n"
      }
    },
    {
      "name": "BUILD_HA_CALLS",
      "type": "n8n-nodes-base.code",
      "typeVersion": 2,
      "position": [
        1100,
        120
      ],
      "parameters": {
        "jsCode": "// EVCS Energy Balance — BUILD_HA_CALLS\n// =====================================================================\n// GARANTIE MODE OMBRE : ce nœud ne produit QUE des écritures vers des entités\n// dont le nom commence par `evcs_balance_`, plus une trace logbook. Aucun\n// switch, aucune consigne de borne, aucune stratégie, aucun helper de takeover.\n// Le bilan observe et publie ; il ne pilote rien tant que le câblage réel n'a\n// pas été décidé explicitement.\n//\n// Cette garantie est VÉRIFIÉE par tests/energy-balance/ : la suite échoue si\n// une écriture sort de ce périmètre. Ne pas ajouter d'autres entités ici sans\n// changer le test en connaissance de cause.\n// =====================================================================\n\nconst balance = $input.first().json;\nconst censorship = $('CENSORSHIP').first().json;\nconst rawSnapshot = $('HA Snapshot Balance').first().json;\nconst snapshot = (rawSnapshot && typeof rawSnapshot.data === 'string')\n  ? (() => { try { return JSON.parse(rawSnapshot.data); } catch { return rawSnapshot; } })()\n  : ((rawSnapshot && rawSnapshot.data) || rawSnapshot);\n\nfunction stampParis() {\n  const p = new Intl.DateTimeFormat('fr-FR', {\n    timeZone: 'Europe/Paris', day: '2-digit', month: '2-digit',\n    hour: '2-digit', minute: '2-digit', hour12: false,\n  }).formatToParts(new Date());\n  const g = t => p.find(x => x.type === t)?.value || '';\n  return `${g('day')}/${g('month')} ${g('hour')}:${g('minute')}`;\n}\n\nconst calls = [];\n\nfunction push(domain, service, data) {\n  calls.push({ json: { domain, service, data } });\n}\nfunction setText(entity, value) {\n  push('input_text', 'set_value', { entity_id: entity, value: (value ?? '').toString().slice(0, 250) });\n}\nfunction setNumber(entity, value) {\n  if (!Number.isFinite(value)) return;\n  push('input_number', 'set_value', { entity_id: entity, value });\n}\nfunction setBool(entity, on) {\n  push('input_boolean', on ? 'turn_on' : 'turn_off', { entity_id: entity });\n}\n\n// Kill-switch : à OFF, on ne touche à rien du tout, pas même au statut.\nconst enabled = (snapshot.balance_enabled ?? 'on').toString().toLowerCase() === 'on';\nif (!enabled) return [];\n\n// --- Ce que le bilan constate de la production, dans tous les cas ---------\nsetBool('input_boolean.evcs_balance_pv_censored', !!censorship.censorship.pvCensored);\nsetText('input_text.evcs_balance_censor_reason',\n  censorship.censorship.pvCensored\n    ? censorship.censorship.reasons.join(', ')\n    : 'production non bridée');\nsetText('input_text.evcs_balance_last_run', stampParis());\n\n// --- Le bilan lui-même ---------------------------------------------------\nif (!balance.usable) {\n  setText('input_text.evcs_balance_status', 'indisponible');\n  // Jamais de verdict voiture perime quand le bilan ne sait plus rien.\n  setBool('input_boolean.evcs_balance_vehicle_grid_needed', false);\n  setText('input_text.evcs_balance_reason',\n    `Entrées manquantes : ${(balance.missing || []).join(', ')}. Les contrôleurs gardent leurs règles.`);\n  return calls;\n}\n\nconst c = balance.coverage;\n\n// `ok` ne veut pas dire « le calcul a abouti » mais « on peut s'appuyer\n// dessus ». Deux cas dégradent la réponse sans l'empêcher :\n//  · aucun croisement production/consommation sur l'horizon — le SOC requis\n//    n'est alors plus une exigence datée mais la somme d'un horizon entier ;\n//  · des heures de déficit reposant sur une forme de production minorée\n//    (repli sur l'enveloppe faute de courbe horaire fraîche).\n// Dans les deux cas le bilan publie quand même ses chiffres — ils restent\n// informatifs — mais il le DIT, pour qu'aucun câblage futur ne s'y fie en\n// silence. Mesuré le 25/08 : sans cette distinction, la nuit précédant la mise\n// en service de la courbe horaire, le bilan a publié un SOC requis de 100 %\n// avec un statut `ok`.\nconst degraded =\n  !balance.crossing.found ||\n  !(balance.confidence && balance.confidence.deficitTrustworthy);\nsetText('input_text.evcs_balance_status', degraded ? 'degrade' : 'ok');\nsetNumber('input_number.evcs_balance_required_soc', c.requiredSocPct);\nsetNumber('input_number.evcs_balance_required_soc_prudent', c.prudent.requiredSocPct);\n// Regle HC (28/09) publiee pour etre verifiable : 0 = hors fenetre HC.\nsetNumber('input_number.evcs_balance_hc_floor_pct', balance.hcReach ? balance.hcReach.floorPct : 0);\nsetNumber('input_number.evcs_balance_hc_floor_prudent_pct', balance.hcReach ? balance.hcReach.floorPrudentPct : 0);\n// Voiture branchee en HC, depart avant la prochaine HC (28/09). OFF hors regle.\nconst vm = balance.vehicleMidday || {};\nsetBool('input_boolean.evcs_balance_vehicle_grid_needed', !!vm.gridNeeded);\nsetNumber('input_number.evcs_balance_vehicle_need_kwh', vm.active ? vm.reachableKwh : 0);\nsetNumber('input_number.evcs_balance_vehicle_solar_kwh', vm.active ? vm.solarKwh : 0);\nsetNumber('input_number.evcs_balance_energy_to_cover_kwh', c.energyToCoverKwh);\nsetNumber('input_number.evcs_balance_grid_energy_needed_kwh', c.gridEnergyNeededKwh);\nsetNumber('input_number.evcs_balance_vehicle_surplus_kwh', balance.vehicle.surplusAvailableKwh);\nsetBool('input_boolean.evcs_balance_grid_needed', !!c.gridNeeded);\n\n// Prochaine traversée déficitaire : ce que la décision immédiate ne montre pas.\nconst nd = balance.nextDeficit || { found: false };\nif (nd.found) {\n  setNumber('input_number.evcs_balance_next_deficit_kwh', nd.energyKwh);\n  setNumber('input_number.evcs_balance_next_deficit_required_soc', nd.requiredSocAtStartPct);\n  setNumber('input_number.evcs_balance_storage_shortfall_kwh', nd.storageShortfallKwh);\n  setText('input_text.evcs_balance_next_deficit_window',\n    `${String(nd.startHour).padStart(2, '0')} h → ${nd.endHour == null ? '?' : String(nd.endHour).padStart(2, '0') + ' h'}`\n    + (nd.feasibleWithCurrentStorage ? '' : ' (stockage insuffisant)'));\n} else {\n  setText('input_text.evcs_balance_next_deficit_window',\n    nd.reason === 'deficit_en_cours' ? 'déficit en cours' : 'aucune sur l\\'horizon');\n}\n// --- Réserve d'orage -----------------------------------------------------\n// Publiée même hors vigilance : le chiffre dit en permanence si l'installation\n// passerait la prochaine nuit sans réseau. Le helper SOC est borné à 100 pour\n// rester dans la plage de l'entrée ; le dépassement éventuel reste lisible\n// dans la raison et dans le manque en kWh.\nconst st = balance.storm;\nif (st) {\n  setText('input_text.evcs_balance_storm_level', st.level);\n  setBool('input_boolean.evcs_balance_storm_active', !!st.active);\n  setNumber('input_number.evcs_balance_storm_reserve_kwh', st.reserveKwh);\n  setNumber('input_number.evcs_balance_storm_reserve_soc',\n    Number.isFinite(st.reserveSocPct) ? Math.min(100, Math.max(0, st.reserveSocPct)) : null);\n  setText('input_text.evcs_balance_storm_reason',\n    (st.known ? `Vigilance ${st.level}` : 'Vigilance indisponible')\n    + (st.phenomena.length ? ` (${st.phenomena.join(', ')})` : '')\n    + ` — sans réseau il faut ${st.reserveKwh} kWh`\n    + (st.windowStartHour == null ? ' pour la fenêtre en cours' : ` dès ${st.windowStartHour} h`)\n    + `, soit SOC ${st.reserveSocPct}% ; actuel ${c.currentSocPct}% → `\n    + (st.covered ? 'couvert.' : `manque ${st.shortfallKwh} kWh.`));\n}\n\nsetText('input_text.evcs_balance_crossing_hour',\n  balance.crossing.found ? `${String(balance.crossing.hour).padStart(2, '0')} h` : 'aucun sur l\\'horizon');\n\nconst ndText = nd.found\n  ? ` | prochaine traversée ${nd.energyKwh} kWh dès ${nd.startHour} h → SOC requis ${nd.requiredSocAtStartPct}%${nd.feasibleWithCurrentStorage ? '' : ` (manque ${Math.round(nd.storageShortfallKwh * 100) / 100} kWh de stockage)`}`\n  : '';\n\nconst degradedNote = !balance.crossing.found\n  ? ' ⚠ aucun croisement sur l\\'horizon : chiffre indicatif, pas une exigence datée.'\n  : (degraded ? ' ⚠ forme de production minorée sur les heures de déficit.' : '');\nconst reason = balance.crossing.found\n  ? `Croisement à ${balance.crossing.hour} h, ${c.energyToCoverKwh} kWh à couvrir → SOC requis ${c.requiredSocPct}% (actuel ${c.currentSocPct}%). ${c.gridNeeded ? `Réseau : ${c.gridEnergyNeededKwh} kWh.` : 'Réseau non nécessaire.'}`\n  : `Aucun croisement PV/conso sur l'horizon : ${c.energyToCoverKwh} kWh à couvrir → SOC requis ${c.requiredSocPct}%.`;\n// Fenetre HC (28/09) : dire quand c'est « tenir jusqu'a la prochaine HC » qui\n// fixe l'exigence, sinon la raison affiche un croisement qui ne l'explique pas.\nconst hc = balance.hcReach || {};\nconst hcText = hc.active && hc.raisesRequirement\n  ? ` Tenir jusqu'à la prochaine HC (${new Date(hc.nextHcStartMs).toLocaleTimeString('fr-FR', { timeZone: 'Europe/Paris', hour: '2-digit', minute: '2-digit' })}) → ${hc.floorPct}% en fin de fenêtre.`\n  : '';\nconst hhmm = ms => new Date(ms).toLocaleTimeString('fr-FR', { timeZone: 'Europe/Paris', hour: '2-digit', minute: '2-digit' });\nconst vehText = vm.active\n  ? ` Voiture (départ ${hhmm(vm.departureMs)}) : ${vm.reachableKwh} kWh à donner, solaire ${vm.solarKwh} kWh → ${vm.gridNeeded ? 'réseau justifié' : 'solaire suffisant'}.`\n  : '';\nsetText('input_text.evcs_balance_reason', reason + hcText + vehText + degradedNote + ndText);\n\n// Trace longue durée, pour comparer jour après jour le seuil calculé au seuil\n// fixe encore en vigueur — c'est cette comparaison qui décidera du câblage.\npush('logbook', 'log', {\n  name: 'EVCS Bilan énergétique (ombre)',\n  message: `${reason} | seuil fixe actuel grid_soc_off = ${snapshot.grid_soc_off ?? 'n/a'}% | production ${censorship.censorship.pvCensored ? 'BRIDÉE (' + censorship.censorship.reasons.join(', ') + ')' : 'libre'}`,\n  entity_id: 'input_text.evcs_balance_status',\n});\n\nreturn calls;\n"
      }
    },
    {
      "name": "Execute HA Service Balance",
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 4.2,
      "position": [
        1320,
        120
      ],
      "parameters": {
        "method": "POST",
        "url": "={{ 'http://10.10.10.17:8123/api/services/' + $json.domain + '/' + $json.service }}",
        "authentication": "genericCredentialType",
        "genericAuthType": "httpBearerAuth",
        "sendHeaders": true,
        "headerParameters": {
          "parameters": [
            {
              "name": "Content-Type",
              "value": "application/json"
            },
            {
              "name": "accept",
              "value": "application/json"
            }
          ]
        },
        "sendBody": true,
        "specifyBody": "json",
        "jsonBody": "={{ $json.data }}",
        "options": {
          "timeout": 15000
        }
      },
      "credentials": {
        "httpBearerAuth": {
          "id": "uv3sknYYigxBkaVN",
          "name": "Bearer Auth account 2"
        }
      },
      "onError": "continueRegularOutput"
    }
  ],
  "connections": {
    "Schedule Trigger": {
      "main": [
        [
          {
            "node": "HA Snapshot Balance",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "HA Snapshot Balance": {
      "main": [
        [
          {
            "node": "CENSORSHIP",
            "type": "main",
            "index": 0
          },
          {
            "node": "RESOURCE_ESTIMATE",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "RESOURCE_ESTIMATE": {
      "main": [
        [
          {
            "node": "PREPARE_BALANCE",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "PREPARE_BALANCE": {
      "main": [
        [
          {
            "node": "BALANCE",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "BALANCE": {
      "main": [
        [
          {
            "node": "BUILD_HA_CALLS",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "BUILD_HA_CALLS": {
      "main": [
        [
          {
            "node": "Execute HA Service Balance",
            "type": "main",
            "index": 0
          }
        ]
      ]
    }
  },
  "settings": {
    "executionOrder": "v1",
    "callerPolicy": "workflowsFromSameOwner"
  },
  "staticData": null,
  "id": "QoSfPeyGq35orF1K"
}