fix(deye): fail the first cycle when the startup poll returns no telemetry

automatic_config() runs on the first cycle alone, so a startup that
completed without telemetry would map only the args backed by cached
ratings (soc_max, battery_rate_max, inverter_limit) and permanently skip
the energy args — import_today and friends — until the next process
restart. Since fetch_sensor_data() raises ValueError when load_today is
unset, that aborts every Predbat run.

run() now returns False on a first cycle whose live poll produced
nothing. ComponentBase leaves first set when run() returns False and
retries the whole startup path on its backoff (60s doubling to a 128
minute cap), so startup completes properly once the API answers.

Gated on the live poll only, not on config/battery: that endpoint can be
permanently unsupported on a model (2106001), and gating on it would back
off to 128 minutes and never complete startup. automatic_config() already
degrades gracefully when the battery config is missing.

This closes the gap left by no longer caching telemetry — previously a
restored live cache could have carried a failed first poll.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: springfall2008

apps/predbat/deye.py

@@ -1146,8 +1146,9 @@ async def run(self, seconds, first):
         if self.tier_expired("config", DEYE_TTL_CONFIG):
             await self.refresh_config()
 
+        live_ok = True
         if self.tier_expired("live", DEYE_TTL_LIVE):
-            await self.refresh_live()
+            live_ok = await self.refresh_live()
 
         # Free: reads the HA control entities rather than the API, so it runs every tick
         # regardless of tier.
@@ -1187,6 +1188,15 @@ async def run(self, seconds, first):
 
         await self._reconcile_control()
 
+        if first and not live_ok:
+            # Startup has not really succeeded without telemetry: automatic_config() would
+            # map only the args backed by cached ratings and permanently skip the rest,
+            # because it runs on the first cycle alone. Returning False leaves first set,
+            # so ComponentBase retries the whole startup path on its backoff (60s doubling
+            # to 128 minutes) until a poll comes back.
+            self.log("Warn: DEYE first poll returned no telemetry, deferring startup; it will be retried after a backoff")
+            return False
+
         if first and self.automatic:
             await self.automatic_config()
         return True

apps/predbat/tests/test_deye_storage.py

@@ -414,6 +414,88 @@ async def fake_post(endpoint_key, body):
     assert not failed, "test_fresh_applied_payload_suppresses_a_redundant_write"
 
 
+def test_first_run_fails_when_telemetry_is_unavailable():
+    """A first cycle with no telemetry returns False so ComponentBase retries startup.
+
+    automatic_config() runs on the first cycle alone, so completing startup without
+    telemetry would permanently skip the energy args (import_today and friends) until the
+    next process restart. Failing the run leaves first set and the driver backs off and
+    retries instead.
+    """
+    failed = False
+    d = StorageDeye(auth_method="oauth")
+    d._mock_storage = _warm_cache()
+    configured = []
+
+    async def fake_post(endpoint_key, body):
+        """Fake DEYE POST: device/latest reports a failure body."""
+        if endpoint_key == "device_latest":
+            return {"success": False, "msg": "device offline"}
+        return {"success": True}
+
+    async def record_config():
+        """Record that automatic_config was reached."""
+        configured.append(True)
+
+    with patch.object(d, "_post", side_effect=fake_post):
+        with patch.object(d, "check_and_refresh_oauth_token", side_effect=_true):
+            with patch.object(d, "publish_data", side_effect=_noop):
+                with patch.object(d, "publish_schedule_settings_ha", side_effect=_noop_arg):
+                    with patch.object(d, "_reconcile_control", side_effect=_noop):
+                        with patch.object(d, "automatic_config", side_effect=record_config):
+                            d.automatic = True
+                            result = run_async(d.run(seconds=0, first=True))
+
+    if result is not False:
+        print(f"ERROR: a first run without telemetry must return False, got {result!r}")
+        failed = True
+    if configured:
+        print("ERROR: automatic_config must not run on an incomplete first cycle")
+        failed = True
+    if not any("deferring startup" in m for m in d.log_messages):
+        print(f"ERROR: expected a deferred-startup warning: {d.log_messages}")
+        failed = True
+    assert not failed, "test_first_run_fails_when_telemetry_is_unavailable"
+
+
+def test_first_run_succeeds_once_telemetry_arrives():
+    """The retry completes startup: telemetry polls, automatic_config runs, run returns True."""
+    failed = False
+    d = StorageDeye(auth_method="oauth")
+    d._mock_storage = _warm_cache()
+    configured = []
+
+    async def fake_post(endpoint_key, body):
+        """Fake DEYE POST: device/latest now succeeds."""
+        if endpoint_key == "device_latest":
+            return {"success": True, "deviceDataList": [{"deviceSn": "INV1", "dataList": LIVE_DATA_LIST}]}
+        return {"success": True}
+
+    async def record_config():
+        """Record that automatic_config was reached."""
+        configured.append(True)
+
+    with patch.object(d, "_post", side_effect=fake_post):
+        with patch.object(d, "check_and_refresh_oauth_token", side_effect=_true):
+            with patch.object(d, "publish_data", side_effect=_noop):
+                with patch.object(d, "publish_schedule_settings_ha", side_effect=_noop_arg):
+                    with patch.object(d, "_reconcile_control", side_effect=_noop):
+                        with patch.object(d, "automatic_config", side_effect=record_config):
+                            d.automatic = True
+                            result = run_async(d.run(seconds=0, first=True))
+
+    if result is not True:
+        print(f"ERROR: a first run with telemetry must return True, got {result!r}")
+        failed = True
+    if not configured:
+        print("ERROR: automatic_config should run once telemetry is available")
+        failed = True
+    if not d.device_energy.get("INV1"):
+        print(f"ERROR: energy counters should be populated for automatic_config: {d.device_energy}")
+        failed = True
+    assert not failed, "test_first_run_succeeds_once_telemetry_arrives"
+
+
 def test_storage_absent_behaves_as_before():
     """With no storage component every load/save no-ops and each tier simply refreshes."""
     failed = False
@@ -576,6 +658,8 @@ def run_deye_storage_tests(my_predbat):
         ("restore_primes_ratings", test_restore_primes_the_ratings_signature),
         ("stale_applied_payload", test_stale_applied_payload_is_discarded_but_orders_are_not),
         ("fresh_applied_payload_suppresses", test_fresh_applied_payload_suppresses_a_redundant_write),
+        ("first_fails_without_telemetry", test_first_run_fails_when_telemetry_is_unavailable),
+        ("first_succeeds_with_telemetry", test_first_run_succeeds_once_telemetry_arrives),
         ("storage_absent", test_storage_absent_behaves_as_before),
         ("corrupt_cache_isolated", test_corrupt_cache_only_affects_its_own_tier),
         ("shape_validation", test_shape_validation_rejects_garbage),

docs/superpowers/specs/2026-07-28-deye-storage-persistence-design.md

@@ -152,6 +152,15 @@ actually performs, and forces a corrective rewrite after any longer outage.
   next tick. No other tier is affected.
 - Restored data is shape-validated (`isinstance` dict/list) before use, as
   `gecloud.py` does, so a truncated file cannot poison in-memory state.
+- A first cycle whose live poll returns nothing makes `run()` return **False**.
+  `automatic_config()` runs on the first cycle alone, so completing startup
+  without telemetry would permanently skip the energy args until the next process
+  restart. Returning False leaves `first` set and `ComponentBase` retries the
+  whole startup path on its backoff (60s doubling to 128 minutes). Deliberately
+  gated on the live poll only, not on `config/battery`: that endpoint can be
+  permanently unsupported on a model (`2106001`), and gating on it would back off
+  to 128 minutes and never complete startup, whereas `automatic_config()` already
+  degrades gracefully when battery config is missing.
 - A failed refresh must **not** save — saving would reset the TTL and skip the
   retry — and must not clobber good in-memory state. This is the same principle
   as the `RatedPower` clobber fix: absence of data is not zero.
@@ -178,6 +187,8 @@ Cases:
 - `applied_payload` restored inside 15 minutes suppresses a redundant write;
   outside 15 minutes it is discarded and the next apply writes.
 - A discovery that returns nothing does not clobber an already-known device list.
+- A first cycle without telemetry returns False and does not run
+  `automatic_config()`; the retry with telemetry returns True and does.
 - A pending order restored from storage resumes polling to completion.
 
 ## Files touched