fix(kernel): key the window bounds cache on the window count as well as identity

Addresses two of the three review comments on this PR.

A window list that grows or shrinks in place keeps its id(), so identity alone was
not enough to decide a cache hit. run_prediction_kernel passes n_charge/n_export
from len(window_list) alongside the cached arrays, so a stale shorter array would
be read past its end by the C kernel - a memory-safety failure rather than merely
a wrong plan. The count is now part of the hit condition.

Nothing on the planning path resizes a window list today, so this guards the class
rather than fixing a live defect. The test proves it would have bitten: before the
change, appending to a cached list left a one-entry bounds array against two
windows, and popping left window_bound_tuple returning the longer tuple.

Also corrects the correctness note, which pointed at Plan.set_window_start() and
Prediction.set_window_start(). Neither exists - they are module functions here -
and after the rebase the prediction path does not use them at all, since
_prepare_export applies a trial start copy-on-write to a window dict and list of
its own.

The third comment, to build the bound tuple from a generator rather than a list
comprehension, is not taken: measured over 50k calls at 200 windows, the generator
is 19.3% slower (307ms against 366ms), because it pays per-item interpreter
overhead the specialised list comprehension avoids.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: springfall2008

apps/predbat/prediction_kernel.py

@@ -398,9 +398,10 @@ def int32_array(values):
 # time in a plan. They are cached here, keyed on the identity of the window list.
 #
 # CORRECTNESS: the cache is only sound while no window's start or end changes underneath it. Every
-# such mutation must call invalidate_window_cache() - route them through
-# Plan.set_window_start()/Prediction.set_window_start() rather than assigning window["start"]
-# directly. run_window_cache_tests replays a full plan with VALIDATE_WINDOW_CACHE on, which
+# such mutation must call invalidate_window_cache() - route them through the set_window_start() and
+# set_window_end() helpers below rather than assigning window["start"] or window["end"] directly.
+# The prediction path does not need them: _prepare_export applies a trial start copy-on-write, to a
+# window dict and list of its own, so nothing the cache has seen is touched. run_window_cache_tests replays a full plan with VALIDATE_WINDOW_CACHE on, which
 # re-derives the bounds on every hit and fails on any stale entry, so a missed invalidation is a
 # test failure rather than a silently wrong plan.
 #
@@ -457,13 +458,19 @@ def _window_cache_entry(window_list):
     """
     key = id(window_list)
     entry = _WINDOW_BOUNDS_CACHE.get(key)
-    if entry is not None and entry[0] is window_list:
+    # The window count is part of the hit condition, not just the identity: a list that grows or
+    # shrinks in place keeps its id(), and run_prediction_kernel passes n_charge/n_export from
+    # len(window_list) alongside these arrays. A stale shorter array would then be read past its end
+    # by the C kernel - a memory-safety failure rather than merely a wrong plan. Bare start/end
+    # writes are handled by set_window_start/set_window_end instead; nothing on the planning path
+    # resizes a window list today, so this is a guard against the class rather than a live fix.
+    if entry is not None and entry[0] is window_list and entry[4] == len(window_list):
         if VALIDATE_WINDOW_CACHE:
             _validate_entry(window_list, entry)
         return entry
     if len(_WINDOW_BOUNDS_CACHE) >= WINDOW_CACHE_MAX:
         _WINDOW_BOUNDS_CACHE.clear()
-    entry = [window_list, None, None, None]
+    entry = [window_list, None, None, None, len(window_list)]
     _WINDOW_BOUNDS_CACHE[key] = entry
     return entry
 

apps/predbat/tests/test_window.py

@@ -457,6 +457,33 @@ def run_window_cache_tests(my_predbat):
     print("**** Running window cache tests ****")
     failed = False
 
+    # A window list that grows or shrinks in place keeps its id(), so the entry must also check the
+    # length. Otherwise run_prediction_kernel passes n_charge = len(window_list) alongside the older,
+    # shorter cached arrays and the C kernel reads past their end - a memory-safety failure rather
+    # than merely a wrong plan, which is why this is guarded and not just documented.
+    prediction_kernel.invalidate_window_cache()
+    growing = [{"start": 0, "end": 30, "average": 5.0}]
+    starts_before, ends_before = prediction_kernel.window_bound_arrays(growing)
+    if len(starts_before) != 1:
+        print("ERROR: expected a single-entry bounds array, got {}".format(len(starts_before)))
+        failed = True
+    growing.append({"start": 60, "end": 120, "average": 6.0})
+    starts_after, ends_after = prediction_kernel.window_bound_arrays(growing)
+    if len(starts_after) != len(growing) or len(ends_after) != len(growing):
+        print("ERROR: bounds arrays are stale after the window list grew - len {} against {} windows".format(len(starts_after), len(growing)))
+        failed = True
+    elif list(starts_after) != [0, 60] or list(ends_after) != [30, 120]:
+        print("ERROR: bounds arrays wrong after growth: {} / {}".format(list(starts_after), list(ends_after)))
+        failed = True
+    # The tuple used for the prediction cache key has to follow the same rule
+    prediction_kernel.invalidate_window_cache()
+    shrinking = [{"start": 0, "end": 30, "average": 5.0}, {"start": 60, "end": 120, "average": 6.0}]
+    prediction_kernel.window_bound_tuple(shrinking)
+    shrinking.pop()
+    if prediction_kernel.window_bound_tuple(shrinking) != ((0, 30),):
+        print("ERROR: window_bound_tuple is stale after the window list shrank: {}".format(prediction_kernel.window_bound_tuple(shrinking)))
+        failed = True
+
     # A repeated lookup on an unchanged list returns the identical cached objects
     prediction_kernel.invalidate_window_cache()
     windows = [{"start": 0, "end": 30, "average": 5.0}, {"start": 60, "end": 120, "average": 6.0}]