fix(dag): ensure deterministic group indexing and remove shared mutable aliases

- sort group IDs when building `group_id_to_index` to guarantee deterministic ordering
- replace backwards-compatible aliases with copies to avoid shared mutable state
- update unit tests to reflect deterministic behaviour
- add determinism and aliasing tests to prevent regression

Author: harryswift01

CodeEntropy/levels/nodes/accumulators.py

@@ -103,7 +103,7 @@ def _build_group_index(groups: dict[int, Any]) -> GroupIndex:
         Returns:
             GroupIndex mapping object.
         """
-        group_ids = list(groups.keys())
+        group_ids = sorted(groups.keys())
         gid2i = {gid: i for i, gid in enumerate(group_ids)}
         return GroupIndex(group_id_to_index=gid2i, index_to_group_id=list(group_ids))
 
@@ -168,8 +168,14 @@ def _attach_backwards_compatible_aliases(shared_data: SharedData) -> None:
         Args:
             shared_data: Shared pipeline dictionary.
         """
-        shared_data["force_torque_stats"] = shared_data["forcetorque_covariances"]
-        shared_data["force_torque_counts"] = shared_data["forcetorque_counts"]
+        shared_data["force_torque_stats"] = {
+            "res": list(shared_data["forcetorque_covariances"]["res"]),
+            "poly": list(shared_data["forcetorque_covariances"]["poly"]),
+        }
+        shared_data["force_torque_counts"] = {
+            "res": shared_data["forcetorque_counts"]["res"].copy(),
+            "poly": shared_data["forcetorque_counts"]["poly"].copy(),
+        }
 
     @staticmethod
     def _build_return_payload(shared_data: SharedData) -> dict[str, Any]:

tests/unit/CodeEntropy/levels/nodes/test_init_covariance_accumulators_node.py

@@ -1,5 +1,3 @@
-import numpy as np
-
 from CodeEntropy.levels.nodes.accumulators import InitCovarianceAccumulatorsNode
 
 
@@ -10,14 +8,51 @@ def test_init_covariance_accumulators_allocates_and_sets_aliases():
 
     out = node.run(shared)
 
-    assert out["group_id_to_index"] == {9: 0, 2: 1}
-    assert out["index_to_group_id"] == [9, 2]
+    gid2i = out["group_id_to_index"]
+    i2gid = out["index_to_group_id"]
+
+    assert set(gid2i.keys()) == {9, 2}
+    assert set(i2gid) == {9, 2}
+
+    for gid, idx in gid2i.items():
+        assert i2gid[idx] == gid
+
+    assert sorted(gid2i.values()) == [0, 1]
+
+    assert "force_covariances" in out
+    assert "torque_covariances" in out
+    assert "frame_counts" in out
+    assert "forcetorque_covariances" in out
+    assert "forcetorque_counts" in out
 
-    assert shared["force_covariances"]["res"] == [None, None]
-    assert shared["torque_covariances"]["poly"] == [None, None]
+    assert "force_torque_stats" in out
+    assert "force_torque_counts" in out
+
+    assert out["force_torque_stats"] is not out["forcetorque_covariances"]
+    assert out["force_torque_counts"] is not out["forcetorque_counts"]
+
+
+def test_init_covariance_accumulators_is_fully_deterministic():
+    node = InitCovarianceAccumulatorsNode()
 
-    assert np.all(shared["frame_counts"]["res"] == np.array([0, 0]))
-    assert np.all(shared["forcetorque_counts"]["poly"] == np.array([0, 0]))
+    shared1 = {"groups": {9: [1, 2], 2: [3]}}
+    shared2 = {"groups": {2: [3], 9: [1, 2]}}
+
+    out1 = node.run(shared1.copy())
+    out2 = node.run(shared2.copy())
+
+    assert out1.keys() == out2.keys()
+
+    for key in out1:
+        if isinstance(out1[key], dict):
+            assert out1[key].keys() == out2[key].keys()
+
+
+def test_init_covariance_accumulators_no_aliasing():
+    node = InitCovarianceAccumulatorsNode()
+
+    shared = {"groups": {1: [1]}}
+    out = node.run(shared)
 
-    assert shared["force_torque_stats"] is shared["forcetorque_covariances"]
-    assert shared["force_torque_counts"] is shared["forcetorque_counts"]
+    assert out["force_torque_stats"] is not out["forcetorque_covariances"]
+    assert out["force_torque_counts"] is not out["forcetorque_counts"]