Keep unknown window states from passing as closed

Confirmed: when an open window's contact sensor became unknown or
unavailable, the tracker ended the ventilation event as a close at the
poll time, started recovery at full weight and forecasts assumed the
window closed. (Learning was already excluded for that zone.)

Each window is now OPEN, CLOSED or UNKNOWN with its last known state,
since when, and since when it is unknown:

- an unknown sensor keeps an open window's event (and the zone's
  "open" status) going; forecasts use the last known state;
- a close observed only after an outage is recorded as unconfirmed:
  closed=None with the reported time and a maximum duration; recovery
  is assumed from that report but not used for any learning;
- opening seen only after an outage starts an event without a
  temperature-before, so its recovery is not learned either;
- events count minutes with an unknown sensor; Status shows each
  window's last known state and unknown minutes;
- one unknown sensor only blocks learning for its own zone.

Predictions with an unavailable wind sensor now keep an open window's
natural ventilation (calm air) instead of dropping the term; learning
still refuses unknown inputs.

Regression tests for every OPEN/CLOSED/UNKNOWN transition, a six-hour
outage, multiple windows with one unknown, and missing wind during
ventilation.

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

tests/test_windows.py

@@ -145,3 +145,111 @@ class TrackerTests(unittest.TestCase):
 
 if __name__ == '__main__':
     unittest.main()
+
+
+class UnknownStateTests(unittest.TestCase):
+    """OPEN, CLOSED and UNKNOWN are three states: unknown never means closed."""
+
+    def setUp(self):
+        self.tracker = wm.VentilationTracker(wm.build_windows([(window('w'), None)], ['bed']), recovery_minutes=20)
+        self.t = 1_000_000.0
+
+    def poll(self, state, changed_ago=None, temp=20.0):
+        changed = self.t - changed_ago if changed_ago is not None else self.t - 100_000
+        self.tracker.update(self.t, {'w': (state, changed)}, {'bed': temp}, WEATHER)
+        inputs = self.tracker.zone_inputs('bed', WEATHER)
+        forecast = self.tracker.forecast('bed', 6, 15, WEATHER, self.t)
+        self.t += 300
+        return inputs, forecast, dict(self.tracker.window_state['w'])
+
+    def open_for_a_while(self):
+        self.poll('off')
+        self.poll('off', temp=21.0)
+        self.poll('on', changed_ago=100, temp=20.4)
+        self.poll('on', changed_ago=400, temp=20.0)
+
+    def test_open_to_unknown_keeps_the_event_and_assumes_still_open(self):
+        self.open_for_a_while()
+        inputs, forecast, state = self.poll('unavailable', changed_ago=60, temp=19.8)
+        self.assertEqual(len(self.tracker.events), 0)          # no confirmed closing without evidence
+        self.assertIn('bed', self.tracker._open_event)
+        self.assertEqual((inputs['known'], inputs['affected'], inputs['recovery']), (False, True, 0.0))
+        self.assertEqual(forecast[0]['opening'], 1.0)           # last seen open: still treated as open
+        self.assertEqual((state['open'], state['last_known_open']), (None, True))
+        self.assertIsNotNone(state['unknown_since'])
+
+    def test_unknown_to_open_continues_the_same_event(self):
+        self.open_for_a_while()
+        self.poll('unavailable', changed_ago=60)
+        self.poll('unavailable', changed_ago=360)
+        inputs, _, state = self.poll('on', changed_ago=30)      # sensor back, window still open
+        self.assertEqual((len(self.tracker.events), state['unknown_since']), (0, None))
+        self.assertFalse(inputs['known'])                       # the interval itself was unknown
+        inputs, _, _ = self.poll('on', changed_ago=330)
+        self.assertEqual((inputs['known'], inputs['opening']), (True, 1.0))
+        self.poll('off', changed_ago=120, temp=20.2)            # confirmed close
+        event = self.tracker.events[-1]
+        self.assertEqual((event['closed_confirmed'], event['sensor_unknown_minutes']), (True, 10.0))  # two polls
+        self.assertIsNotNone(event['duration_minutes'])
+
+    def test_unknown_to_closed_records_an_unconfirmed_close(self):
+        self.open_for_a_while()
+        self.poll('unavailable', changed_ago=60)
+        inputs, forecast, state = self.poll('off', changed_ago=20, temp=20.1)
+        event = self.tracker.events[-1]
+        self.assertEqual((event['closed'], event['closed_confirmed'], event['duration_minutes']), (None, False, None))
+        self.assertGreater(event['duration_max_minutes'], 0)
+        self.assertEqual((state['open'], state['last_known_open'], state['unknown_since']), (False, False, None))
+        # Recovery is assumed from when the sensor reported closed, but its timing is
+        # unknown, so neither the ventilation nor the envelope model learns from it.
+        self.assertGreater(inputs['recovery'], 0.9)
+        self.assertEqual((inputs['known'], inputs['affected'], inputs['opening']), (False, True, None))
+        self.assertEqual(forecast[0]['opening'], 0.0)
+        self.assertGreater(forecast[0]['recovery'], 0.0)
+
+    def test_closed_to_unknown_assumes_closed_but_blocks_learning(self):
+        self.poll('off')
+        self.poll('off')
+        inputs, forecast, state = self.poll('unavailable', changed_ago=120)
+        self.assertEqual((inputs['known'], inputs['affected']), (False, True))
+        self.assertEqual(forecast[0]['opening'], 0.0)
+        self.assertEqual((state['open'], state['last_known_open']), (None, False))
+        self.assertEqual(len(self.tracker.events), 0)
+
+    def test_unknown_to_open_after_a_closed_window_starts_an_unconfirmed_event(self):
+        self.poll('off')
+        self.poll('off', temp=21.0)
+        self.poll('unavailable', changed_ago=60, temp=20.6)
+        self.poll('on', changed_ago=30, temp=20.0)               # opened at some point during the outage
+        event = self.tracker._open_event['bed']
+        self.assertEqual((event['opened_confirmed'], event['temperature_before']), (False, None))
+        self.poll('on', changed_ago=330, temp=19.8)
+        inputs, _, _ = self.poll('off', changed_ago=100, temp=19.9)
+        self.assertTrue(self.tracker.events[-1]['closed_confirmed'])
+        # Without the temperature before ventilation, recovery cannot be learned.
+        self.assertFalse(inputs['known'])
+
+    def test_recovery_after_prolonged_unavailability(self):
+        self.open_for_a_while()
+        for _ in range(72):                                      # six hours without the sensor
+            self.poll('unavailable', changed_ago=60)
+        self.assertEqual(len(self.tracker.events), 0)
+        inputs, _, _ = self.poll('off', changed_ago=60)
+        event = self.tracker.events[-1]
+        self.assertFalse(event['closed_confirmed'])
+        self.assertGreaterEqual(event['duration_max_minutes'], 360)
+        self.assertEqual(event['sensor_unknown_minutes'], 360.0)
+        for _ in range(12):                                       # recovery decays, learning resumes
+            inputs, _, _ = self.poll('off')
+        self.assertEqual((inputs['known'], inputs['affected'], inputs['recovery']), (True, False, 0.0))
+
+    def test_multiple_windows_with_one_unknown(self):
+        tracker = wm.VentilationTracker(wm.build_windows([(window('a'), None), (window('b'), None)], ['bed']))
+        for t, a, b in ((0, 'off', 'off'), (300, 'on', 'off'), (600, 'on', 'unavailable'),
+                        (900, 'off', 'unavailable')):
+            tracker.update(float(t), {'a': (a, t - 60.0), 'b': (b, t - 60.0)}, {'bed': 20.0}, WEATHER)
+        # Window a closed (confirmed); b was last seen closed: the event ends, confirmed,
+        # but the zone stays out of learning while b's state is unknown.
+        self.assertTrue(tracker.events[-1]['closed_confirmed'])
+        inputs = tracker.zone_inputs('bed', WEATHER)
+        self.assertEqual((inputs['known'], inputs['unknown_windows']), (False, ['B']))