SAFETY-97: "gives nothing" is graded against each battery's idle reading

B's power reading shows -95 to -118 W at idle (standby draw), so the
|reading| < 100 W refusal band never held a refusing B: never at N=2,
and since SAFETY-94's shared rule not at N=1 either (review F1).

Each unit now learns its idle reading (app/idle.py): only while control
runs, the unit is not refused/stale/tripped and its command has stayed
within 50 W for 120 s; first value a 120 s mean, then a 30 min follow;
samples beyond 250 W dropped, value clamped to 250 W; saved per unit and
restored. The shared refusal evidence, compute()'s N=1 engage and end,
the unit refusal ends, the stale-path refusal and SAFETY-42's "parked"
test are centred on it. Until learned it is 0 W, the rule as it was.

Refusing B caught at N=1 28/28/65 s and N=2 24/24/60 s (1/2/5 s
meters), before never; refusing A unchanged. Healthy B with its offset,
SAFETY-94's scenarios, 96 runs: 0 stale, 0 refused. Live replay: 0.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_019DBUfvndgHwaV339Fvd2gr

goodwe_controller/tools/safety94_rig.py

@@ -11,13 +11,15 @@ as the live boards do. B reads 100 W below what it gives (its standby draw:
 reads every 1 s and cycles on a new meter value, as `run_control()` does.
 
 A frozen register stops publishing at `freeze_at`; a refusing battery (`cut`)
-gives 0 W and reads -4 W. Uses only the Controller API release/1.0 02ed120
+gives 0 W and reads -4 W plus its offset (B: -104 W), with `noise` W of
+seeded jitter (SAFETY-97). Uses only the Controller API release/1.0 02ed120
 has, so the same file runs on the tree before SAFETY-94.
 """
 
 import asyncio
 import math
 import os
+import random
 import sys
 from datetime import datetime, timedelta, timezone
 
@@ -40,9 +42,9 @@ MAINT = {"maintenance_enabled": True, "maintenance_start_hour": 11,
 
 
 class _Store:
-    def __init__(self):
+    def __init__(self, data=None):
         from app.store import DEFAULTS
-        self.data = dict(DEFAULTS)
+        self.data = dict(DEFAULTS, **(data or {}))
 
     def set(self, k, v):
         self.data[k] = v
@@ -69,8 +71,9 @@ class Plant:
     """The batteries, their registers and the meter, in simulated seconds."""
 
     def __init__(self, units, load, tau, tick, soc, cut, freeze_at,
-                 publish_s=PUBLISH_S, dither=False):
+                 publish_s=PUBLISH_S, dither=False, noise=0.0, seed=0):
         self.units, self.load, self.tau, self.tick = units, load, tau, tick
+        self.noise, self.rng = noise, random.Random(seed)
         self.publish_s, self.dither, self.n_pub = publish_s, dither, 0
         self.soc_fn, self.cut, self.freeze_at = soc, cut, freeze_at
         self.cmd = {u: 0.0 for u in units}
@@ -98,9 +101,11 @@ class Plant:
                     # `dither`: the +-1 W a settled register shows (live).
                     self.n_pub += 1
                     jit = (self.n_pub * 7 % 3 - 1) if self.dither else 0
-                    self.reg[u] = (CUT_W if self.cut(u, self.t)
-                                   else float(round(self.real[u] + OFFSET[u])
-                                              + jit))
+                    self.reg[u] = (
+                        float(round(CUT_W + OFFSET[u] + self.rng.uniform(
+                            -self.noise, self.noise)))
+                        if self.cut(u, self.t)
+                        else float(round(self.real[u] + OFFSET[u]) + jit))
             if abs(self.t / self.tick - round(self.t / self.tick)) < 1e-6:
                 self.grid_v = float(round(self.load(self.t)
                                           - sum(self.real.values())))
@@ -148,18 +153,18 @@ def options(n, extra=None):
 
 def run(n, load, dur, *, tau=10.0, tick=1.0, soc=None, cut=None,
         freeze_at=None, extra=None, floor_s=15.0, publish_s=PUBLISH_S,
-        dither=False):
+        dither=False, noise=0.0, seed=0, store=None):
     """Returns a dict: per-unit stale trips [(t, unit)], refusals
     [(t, unit or 'site')], rows [(t, grid, {u: cmd}, {u: real}, {u: reg},
-    phases)] and the controller."""
+    phases)] and the controller. `store`: saved state to start from."""
     units = tuple("ab"[:n])
     soc = soc or (lambda u, t: 50.0)
     cut = cut or (lambda u, t: False)
     plant = Plant(units, load, tau, tick, soc, cut, freeze_at, publish_s,
-                  dither)
+                  dither, noise, seed)
 
     async def go():
-        c = Controller(options(n, extra), _Hass(plant), _Store(), _Pub(),
+        c = Controller(options(n, extra), _Hass(plant), _Store(store), _Pub(),
                        stop=asyncio.Event())
         for i in c.inverters:
             i.dev_min, i.dev_max = -5000.0, 5000.0