fix: fail loudly on attr_map/varid_map inconsistency, explicit not-yet-observable returns

The .get() pattern silently returned empty sets even in cases that would indicate
a population bug. Replace with direct dict access guarded only by explicit
"not yet observable" early returns (no vars of this type/attr have been seen yet
-- the invariant simply cannot be checked and passes vacuously). Inside the
iteration loop, add assertions so any discrepancy between attr_map and varid_map
fails loudly rather than being masked.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: Essoz

traincheck/invariant/contain_relation.py

@@ -1317,16 +1317,32 @@ def online_check(
             events = []
             attr_name = child_param.attr_name
             with checker_data.lock:
-                candidate_varids = checker_data.attr_map.get(
-                    child_param.var_type, {}
-                ).get(attr_name, set())
+                # No variables of this type/attr have been observed yet — not yet checkable.
+                if child_param.var_type not in checker_data.attr_map:
+                    return OnlineCheckerResult(
+                        trace=None, invariant=inv, check_passed=True
+                    )
+                if attr_name not in checker_data.attr_map[child_param.var_type]:
+                    return OnlineCheckerResult(
+                        trace=None, invariant=inv, check_passed=True
+                    )
+                candidate_varids = checker_data.attr_map[child_param.var_type][
+                    attr_name
+                ]
                 if isinstance(child_param, VarNameParam):
                     candidate_varids = {
                         v
                         for v in candidate_varids
                         if v.var_name == child_param.var_name
                     }
                 for varid in candidate_varids:
+                    # attr_map guarantees attr_name is in varid_map[varid]; fail loudly
+                    # if the population logic ever violates this invariant.
+                    assert attr_name in checker_data.varid_map[varid], (
+                        f"attr_map/varid_map inconsistency: {varid} is in "
+                        f"attr_map[...][{attr_name}] but "
+                        f"varid_map[{varid}] has no '{attr_name}' entry"
+                    )
                     for i in reversed(
                         range(1, len(checker_data.varid_map[varid][attr_name]))
                     ):

traincheck/onlinechecker/utils.py

@@ -188,9 +188,17 @@ def query_var_changes_within_time_and_process(
     checker_data: Checker_data,
 ) -> list:
     """Extract all variable change events from the trace, within a specific time range and process."""
-    events = []
+    events: list = []
     with checker_data.lock:
-        for varid in checker_data.attr_map.get(var_type, {}).get(attr_name, set()):
+        if var_type not in checker_data.attr_map:
+            return events
+        if attr_name not in checker_data.attr_map[var_type]:
+            return events
+        for varid in checker_data.attr_map[var_type][attr_name]:
+            assert attr_name in checker_data.varid_map[varid], (
+                f"attr_map/varid_map inconsistency: {varid} in "
+                f"attr_map[{var_type}][{attr_name}] but not in varid_map"
+            )
             for i in reversed(range(1, len(checker_data.varid_map[varid][attr_name]))):
 
                 change_time = checker_data.varid_map[varid][attr_name][