fix: detect actual EV phase instead of hardcoding phase A

- evcharger.cpp: phases() now calls meteredPhases() instead of returning PhaseNone
- smartchargingmanager: add chargerPhaseKey() with 3-level fallback
  1. meteredPhases() when charger is active
  2. effectivePhases from last known state
  3. fallback 'A' + warning (previous behavior)
- Remove 4 FIXME comments on lines 394, 477, 517

CLAUDE.md

@@ -1,84 +1,133 @@
-# Agent Plugin — `powersync-energy-plugin-etm`
+# Agent Plugin — `powersync-energy-plugin-etm` (GPL3)
 > Lire aussi le `CLAUDE.md` du dossier parent avant de commencer.
 
 ---
 
 ## Mon rôle
-Je suis le **cœur du HEMS ETM-PowerSync**. Je contiens toute la logique
+Je suis le **plugin nymea Community** du HEMS ETM-PowerSync.  
-d'optimisation énergétique : gestion des consommateurs (EV, ECS, PAC),
+Je contiens toute la logique GPL3 : recharge EV sur surplus, tarif HP/HC,
-tarification, météo, et décision d'activation par surplus solaire.
+protection surcharge, et le pont vers `powersync-optimizer` pour les tiers payants.
 
-Je suis un **code propriétaire ETM** — pas open-source, pas de publication upstream.
+**Licence : GPL3** — tout mon code est open-source assumé.  
+Origine : fork de nymea-energy-plugin-nymea (source nymea/Chargebyte, GPL3).  
+Pas de remote upstream Git public — mises à jour via portage manuel depuis
+`etm-nymea/nymea-energy-plugin-nymea`.
+
+---
+
+## Règle fondamentale
+
+```
+Ce repo = fonctionnalités Community UNIQUEMENT.
+Zéro logique Auto / Predict AI dans ce repo.
+Ces features passent exclusivement par PowerSyncClient → optimizer.
+```
 
 ---
 
 ## Ce que je FOURNIS
 
 ### API JSON-RPC `EnergyPlugin.*`
-| Méthode | Rôle |
+| Méthode | Rôle | Tier |
-|---|---|
+|---|---|---|
-| `GetChargingInfos(evChargerId)` | Config recharge EV (mode, deadline, SOC cible) |
+| `GetChargingInfos(evChargerId)` | Config recharge EV | Community |
-| `SetChargingInfo(chargingInfo)` | Mettre à jour la config d'une borne EV |
+| `SetChargingInfo(chargingInfo)` | Mettre à jour config borne EV | Community |
-| `GetChargingSchedules(evChargerId)` | Planning calculé par l'OptimizationEngine |
+| `GetChargingSchedules(evChargerId)` | Planning calculé | Community |
-| `GetAvailableSpotMarketProviders()` | Liste des providers tarifs disponibles |
+| `GetAvailableSpotMarketProviders()` | Liste providers tarifs | Community |
-| `SetSpotMarketConfiguration(enabled, providerId)` | Activer/choisir un provider |
+| `SetSpotMarketConfiguration(enabled, providerId)` | Activer provider | Community |
-| `GetSpotMarketScoreEntries(date)` | Cotations horaires aWATTar |
+| `GetSpotMarketScoreEntries(date)` | Cotations horaires | Community |
-| `SetPhasePowerLimit(Uint)` | Protection surcharge réseau (A/phase) |
+| `SetPhasePowerLimit(Uint)` | Protection surcharge | Community |
-| `SetAcquisitionTolerance(Double)` | Seuil surplus déclenchant la charge |
+| `SetAcquisitionTolerance(Double)` | Seuil surplus | Community |
-| `SetBatteryLevelConsideration(Double)` | Facteur batterie dans le calcul surplus |
+| `SetBatteryLevelConsideration(Double)` | Facteur batterie | Community |
 
 ### Notifications push
 `ChargingInfoAdded/Removed/Changed`, `ChargingSchedulesChanged`,
 `SpotMarketConfigurationChanged`, `SpotMarketScoreEntriesChanged`,
 `PhasePowerLimitChanged`
 
+### `.so` produit
+```
+libnymea_energypluginnymea.so   ← nom identique à l'upstream (drop-in replacement)
+install : /usr/lib/nymea/energy/
+```
+
 ---
 
 ## Ce que je CONSOMME
 
-### Interfaces nymea (détection par interface, jamais par ThingClassId)
+### Interfaces nymea (par interface, jamais par ThingClassId)
 | Interface | États lus | Actions envoyées |
 |---|---|---|
 | `evcharger` | `chargingEnabled`, `maxChargingCurrent`, `pluggedIn`, `charging`, phases | `setChargingEnabled`, `setMaxChargingCurrent` |
 | `electricvehicle` | `batteryLevel`, `maxChargingCurrent`, `capacity` | — |
 | `rootmeter` / `energymeter` | `currentPowerPhaseA/B/C`, `currentPhaseA/B/C` | — |
 | `energystorage` | `currentPower`, `batteryLevel` | — |
-| `thermostat` | `temperature`, `mode` | `setMode`, `setTargetTemperature` |
 
-### Depuis `nymea-experience-plugin-energy`
+### Signal déclencheur
-- `EnergyManager*` injecté via `EnergyPlugin::init()`
+`PowerBalanceEntryAdded` depuis `nymea-experience-plugin-energy` → cycle ~1 min.
-- Signal `PowerBalanceEntryAdded` → déclenche le cycle d'optimisation (~1 min)
+
+### Service propriétaire (optionnel)
+`PowerSyncClient` → Unix socket `/run/powersync/optimizer.sock`  
+Si absent → mode Community local, aucune erreur.
 
 ---
 
-## Architecture interne cible
+## Architecture interne
 
 ```
-powersync-energy-plugin-etm
+powersync-energy-plugin-etm/
 │
-├── TierManager                    ← lit /etc/powersync/tier.conf
+├── [code upstream nymea/Chargebyte]     ← ne pas modifier directement
-│   └── active/désactive les modules selon le tier
+│   ├── SmartChargingManager.*           ← à corriger (bugs phase EV)
+│   ├── SpotMarketManager.*              ← aWATTar AT/DE ✅
+│   └── NymeaEnergyJsonHandler.*         ← API JSON-RPC
 │
-├── OptimizationEngine             ← chef d'orchestre (à créer)
+└── etm/                                 ← tout notre code ETM ici
-│   ├── calcule le surplus PV disponible
+    ├── PowerSyncClient.*                ← pont vers optimizer (Unix socket)
-│   ├── consulte TariffManager (tarif actuel)
+    ├── tariff/
-│   ├── consulte WeatherManager (météo J+1 si tier Auto+)
+    │   └── StaticHcHpProvider.*         ← HP/HC statique (Community)
-│   └── distribue la puissance selon la priorité :
+    └── [futures extensions Community]
-│       1. ECS  (priorité haute — chaleur)
+```
-│       2. PAC  (selon température extérieure)
+
-│       3. EV   (selon deadline connue)
+---
-│
+
-├── ConsumerManager
+## PowerSyncClient — le pont vers l'optimizer
-│   ├── EvConsumer                 ← refactor SmartChargingManager existant
+
-│   ├── EcsConsumer                ← à créer
+```cpp
-│   └── HeatPumpConsumer           ← à créer
+class PowerSyncClient : public QObject {
-│
+    Q_OBJECT
-├── TariffManager
+public:
-│   ├── StaticHcHpProvider         ← à créer (Community)
+    // Vérifie si powersync-optimizer tourne
-│   └── aWATTarProvider            ← ✅ existe (AT + DE)
+    bool isAvailable() const;
-│
+
-└── WeatherManager
+    // Demande une décision d'optimisation (Auto/Predict AI)
-    └── OpenMeteoProvider          ← à créer (Auto uniquement)
+    OptimizationResult requestOptimization(const SurplusData &data);
+
+    // Récupère la météo J+1 (Auto)
+    WeatherForecast getWeatherForecast();
+
+    // Récupère le tarif dynamique courant (Predict AI)
+    TariffData getDynamicTariff();
+
+signals:
+    void availabilityChanged(bool available);
+    void optimizationResultReceived(OptimizationResult result);
+};
+```
+
+**Comportement du cycle principal :**
+```cpp
+void SmartChargingManager::runCycle() {
+    if (m_powerSyncClient->isAvailable()) {
+        // Auto / Predict AI — délègue à l'optimizer
+        auto result = m_powerSyncClient->requestOptimization(buildSurplusData());
+        applyOptimizationResult(result);
+    } else {
+        // Community — logique GPL3 locale
+        planSurplusCharging();      // EV sur surplus
+        planSpotMarketCharging();   // EV sur aWATTar
+    }
+}
 ```
 
 ---
@@ -86,36 +135,39 @@ powersync-energy-plugin-etm
 ## État actuel du code
 
 ### ✅ Fonctionnel
-- `SmartChargingManager` : recharge EV sur surplus solaire (mode Eco)
+- SmartChargingManager : recharge EV surplus (mode Eco) + aWATTar AT/DE
-- `SpotMarketManager` : planification aWATTar AT/DE avec cache 24h
-- `NymeaEnergyJsonHandler` : API JSON-RPC `EnergyPlugin.*` complète
 - Overload protection triphasée
-- Détection appareils par interface (zero UUID hardcodé)
+- API JSON-RPC `EnergyPlugin.*` complète
+- Détection appareils par interface (zéro UUID hardcodé)
 
 ### ❌ À corriger en priorité
 | Fichier | Problème | Priorité |
 |---|---|---|
-| `evcharger.cpp:171`, `smartchargingmanager.cpp:394,477,517` | Assume toujours phase A — faux pour EV monophasé sur B/C | 🔴 Haute |
+| `evcharger.cpp:171`, `smartchargingmanager.cpp:394,477,517` | Assume toujours phase A — faux pour EV sur phase B/C | 🔴 |
-| `smartchargingmanager.cpp:59` | Migration `endTime → endDateTime` + récurrence hebdo non terminée | 🟠 Moyenne |
+| `EnergyPluginNymea::init()` | Pas de guard si `EnergyManager*` null | 🟠 |
-| `smartchargingmanager.cpp:884` | Planification limitée à 24h | 🟠 Moyenne |
+| `smartchargingmanager.cpp:59` | Récurrence hebdo non terminée | 🟠 |
-| `smartchargingmanager.cpp:1835` | Actions EV non séquentielles, pas de retry | 🟠 Moyenne |
+| `smartchargingmanager.cpp:884` | Planification limitée à 24h | 🟠 |
-| `EnergyPluginNymea::init()` | Pas de guard si `EnergyManager*` est null | 🟠 Moyenne |
+| `smartchargingmanager.cpp:1835` | Actions EV non séquentielles, pas de retry | 🟠 |
 
-### ❌ À créer
+### ❌ À créer (code ETM dans `etm/`)
-- `StaticHcHpProvider` (TariffManager — Community)
+- `PowerSyncClient` (pont Unix socket vers optimizer)
-- `EcsConsumer` (chauffe-eau / ECS sur surplus)
+- `StaticHcHpProvider` (tarif HP/HC statique — Community)
-- `HeatPumpConsumer` (PAC sur surplus)
-- `OptimizationEngine` (orchestrateur multi-consommateurs)
-- `WeatherManager` + `OpenMeteoProvider` (Auto)
-- `TierManager` + lecture `/etc/powersync/tier.conf`
 
 ---
 
 ## Règles de modification
 
-- Tout changement de signature `EnergyPlugin.*` → mettre à jour `INTERFACE.md`
+- Tout code ETM va dans `etm/` — jamais dans le code upstream
-- Tout nouveau StateType ou ActionType → notifier l'Agent App
+- Modifier le code upstream uniquement pour corriger des bugs (FIXME existants)
-- Ne jamais modifier `nymea-experience-plugin-energy` depuis ce repo
+- Tout changement d'API `EnergyPlugin.*` → mettre à jour `INTERFACE.md`
-- Tester sur un système Community avant d'activer des features Auto/Predict AI
+- Ne jamais ajouter de logique Auto/Predict AI dans ce repo
 - Build : `qmake energyplugin.pro && make -j$(nproc)`
-- Install : `/usr/lib/nymea/energy/libnymea_energypluginnymea.so`
+
+---
+
+## Portage des mises à jour nymea/Chargebyte
+
+Quand une nouvelle version est disponible dans `etm-nymea/nymea-energy-plugin-nymea` :
+1. `diff -r etm-nymea/nymea-energy-plugin-nymea/ powersync-energy-plugin-etm/`
+2. Porter manuellement les corrections hors dossier `etm/`
+3. Ne jamais écraser `etm/`

energyplugin/evcharger.cpp

@@ -168,13 +168,13 @@ Electricity::Phases EvCharger::phases() const
         }
     }
 
-    // TODO: Can we figure out from the root meter on which phase we're attached?
+    // For single-phase chargers, detect the actual connected phase from per-phase metering
-    // One idea would be to sign up on root meter changes. When chargingEnabled is set or unset,
+    Electricity::Phases metered = meteredPhases();
-    // memorize root meter values and compare the next (or some more) cycles if a phase changed
+    if (metered != Electricity::PhaseNone) {
-    // by a similar value as we'd expect    
+        return metered;
-
+    }
-    // Until we have this detection, we must ask the user how many phases will be used while charging
 
+    // Phase unknown — charger has no per-phase metering or is not currently charging
     return Electricity::PhaseNone;
 }
 

energyplugin/smartchargingmanager.cpp

@@ -391,9 +391,9 @@ void SmartChargingManager::verifyOverloadProtection(const QDateTime &currentDate
 
             if (evCharger->phaseCount() == 1) {
 
-                // FIXME: get the actual phase, not assume it is phase A in single phase charging
+                const QString phase = chargerPhaseKey(evCharger);
-                if (requiredThrottlePower.value("A") > 0) {
+                if (requiredThrottlePower.value(phase) > 0) {
-                    int throttleAmpere = qCeil(requiredThrottlePower.value("A") / 230);
+                    int throttleAmpere = qCeil(requiredThrottlePower.value(phase) / 230);
                     int desiredFallbackAmpere = evCharger->maxChargingCurrent() - throttleAmpere;
 
                     if (desiredFallbackAmpere < static_cast<int>(m_processInfos[evCharger].minimalChargingCurrent)) {
@@ -474,8 +474,7 @@ void SmartChargingManager::verifyOverloadProtectionRecovery(const QDateTime &cur
                 bool restoreCharger = false;
 
                 if (evCharger->phaseCount() == 1) {
-                    // FIXME: get the actual phase, not assume it is phase A in single phase charging
+                    if (availablePhasePower.value(chargerPhaseKey(evCharger)) >= requiredRestorePhasePower) {
-                    if (availablePhasePower.value("A") >= requiredRestorePhasePower) {
                         qCDebug(dcNymeaEnergy()) << "Overload protection: Enought power available to restore the original configuration"
                                                  << manualMaxChargingCurrent(evCharger->id()) << "[A]";
                         restoreCharger = true;
@@ -514,8 +513,7 @@ void SmartChargingManager::verifyOverloadProtectionRecovery(const QDateTime &cur
                 bool restoreChargerPower = false;
 
                 if (evCharger->phaseCount() == 1) {
-                    // FIXME: get the actual phase, not assume it is phase A in single phase charging
+                    if (availablePhasePower.value(chargerPhaseKey(evCharger)) >= requiredRestorePhasePower) {
-                    if (availablePhasePower.value("A") >= requiredRestorePhasePower) {
                         qCDebug(dcNymeaEnergy()) << "Overload protection: Enought power available to start charging using the minimal charging current of"
                                                  << m_processInfos.value(evCharger).minimalChargingCurrent << "[A]";
                         restoreChargerPower = true;
@@ -1770,6 +1768,28 @@ Electricity::Phases SmartChargingManager::getAscendingPhasesForCount(uint phaseC
     return phases;
 }
 
+QString SmartChargingManager::chargerPhaseKey(EvCharger *evCharger) const
+{
+    // Use live metering first — reliable when charger is actively charging
+    Electricity::Phases metered = evCharger->meteredPhases();
+    if (metered.testFlag(Electricity::PhaseA)) return QStringLiteral("A");
+    if (metered.testFlag(Electricity::PhaseB)) return QStringLiteral("B");
+    if (metered.testFlag(Electricity::PhaseC)) return QStringLiteral("C");
+
+    // Charger may be off — fall back to last known phase stored by prepareInformation()
+    if (m_processInfos.contains(evCharger)) {
+        Electricity::Phases known = m_processInfos.value(evCharger).effectivePhases;
+        if (known.testFlag(Electricity::PhaseA)) return QStringLiteral("A");
+        if (known.testFlag(Electricity::PhaseB)) return QStringLiteral("B");
+        if (known.testFlag(Electricity::PhaseC)) return QStringLiteral("C");
+    }
+
+    // Phase unknown — conservative fallback (unchanged previous behavior)
+    qCWarning(dcNymeaEnergy()) << "Cannot determine connected phase for"
+                               << evCharger->name() << "— defaulting to phase A";
+    return QStringLiteral("A");
+}
+
 uint SmartChargingManager::getBestPhaseCount(EvCharger *evCharger, double surplusAmpere)
 {
     uint desiredPhaseCount = 1;

energyplugin/smartchargingmanager.h

@@ -123,6 +123,7 @@ private:
 
     Electricity::Phases getAscendingPhasesForCount(uint phaseCount);
     uint getBestPhaseCount(EvCharger *evCharger, double surplusAmpere);
+    QString chargerPhaseKey(EvCharger *evCharger) const;
 
     EnergyManager *m_energyManager = nullptr;
     ThingManager *m_thingManager = nullptr;