Bound learner covariance to stop RLS windup

With forgetting 0.999 and no heat excitation (summer, long OFF periods),
the heat-coefficient variance grew by 1/0.999 per sample without limit:
about 8.7e12 after 104 simulated OFF days. The first ON samples could
then swing coefficients to their bounds, and accumulated asymmetry
approached the absolute 1e-8 restore tolerance, past which a restart
silently reset the whole model.

Symmetrize P and bound its diagonal by the prior after every update
(row/column scaling keeps it positive definite). Restore uses a relative
round-off tolerance and applies the same bound, so wound-up v0.2.1
models load instead of being discarded. Payload schema is unchanged.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

tests/test_physics.py

@@ -90,7 +90,8 @@ class ModelTests(unittest.TestCase):
     def test_corrupt_model_restore_is_atomic(self):
         for changes in ({'theta': [-1, .1, 0]}, {'p': [[-1, 0, 0], [0, 1, 0], [0, 0, 1]]},
                         {'count': float('inf')}, {'count': '5'}, {'error_sum': float('nan')},
-                        {'off_count': 1}, {'theta': [float('nan'), 0, 0]}, {'p': None}):
+                        {'off_count': 1}, {'theta': [float('nan'), 0, 0]}, {'p': None},
+                        {'p': [[1, .5, 0], [0, 1, 0], [0, 0, 1]]}):
             with self.subTest(changes=changes):
                 data = m.Learner().as_dict()
                 data.update(changes)
@@ -109,6 +110,30 @@ class ModelTests(unittest.TestCase):
             with self.subTest(key=key), self.assertRaises(ValueError):
                 m.optimize(**args)
 
+    def test_covariance_stays_bounded_without_heat_excitation(self):
+        learn = m.Learner()
+        t = 22.0
+        for _ in range(30000):  # about 104 days with the relay off
+            value = t + 0.003 * (15 - t)
+            self.assertTrue(learn.learn(t, value, 15, 0.0, command=False))
+            t = value
+        for i in range(3):
+            self.assertLessEqual(learn.p[i][i], m.PRIOR_P[i][i])
+            for j in range(3):
+                self.assertEqual(learn.p[i][j], learn.p[j][i])
+        restored = m.Learner.from_dict(learn.as_dict())
+        self.assertEqual(restored.count, 30000)
+        self.assertEqual(restored.p, learn.p)
+
+    def test_restore_tolerates_round_off_and_bounds_wound_up_covariance(self):
+        # Shape of a v0.2.1 model after a summer: huge heat variance, tiny asymmetry.
+        data = m.Learner(count=40000, off_count=40000).as_dict()
+        data['p'] = [[0.03, 1.0, 1e-3], [1.0 + 1e-7, 8.7e12, 0.0], [1e-3, 0.0, 0.0012]]
+        restored = m.Learner.from_dict(data)
+        self.assertEqual(restored.count, 40000)
+        self.assertEqual(restored.p[1][1], m.PRIOR_P[1][1])
+        self.assertEqual(restored.p[0][0], m.PRIOR_P[0][0])
+        self.assertEqual(restored.p[0][1], restored.p[1][0])
 
 if __name__ == '__main__':
     unittest.main()