fix: address Phase 7 code review issues

- CRITICAL 1: Rewrite snapshot tests to use frame-based state (frames, tag_store, presence, port_store, free_frames) instead of removed matching_store and gen_counters
- test_capture_pe_matching_store_structure → test_capture_pe_frame_structure
- test_capture_pe_gen_counters → test_capture_pe_tag_store
- test_capture_multiple_pes_and_sms: updated to test frame state instead

- CRITICAL 2: Fix monitor/server.py DyadToken construction (inject and send commands)
- Change ctx= to act_id= parameter
- Remove old fields gen=0, wide=False
- Update JSON key from 'ctx' to 'act_id'

- CRITICAL 3: Fix test_backend.py MonadToken construction
- Change ctx= to act_id= in test_inject_token_appears_in_snapshot
- Change ctx= to act_id= in test_send_token_respects_backpressure

- IMPORTANT 1: Rewrite test_capture_sm_t0_store to use int values
- T0 store is now list[int], not list[Token]
- Changed from appending MonadToken objects to appending int values (777, 888)

- IMPORTANT 2: Fix formatting.py T0 store display
- Change 'tokens' to 'entries' in T0 store formatting line

monitor/formatting.py

···
 
     # T0 store
     lines.append(
-        f"  T0 store: {colour(str(len(sm_snapshot.t0_store)), 'white')} tokens"
+        f"  T0 store: {colour(str(len(sm_snapshot.t0_store)), 'white')} entries"
     )
 
     # Input queue

monitor/server.py

···
                         # Construct a CMToken from command data
                         target = cmd_json.get("target", 0)
                         offset = cmd_json.get("offset", 0)
-                        ctx = cmd_json.get("ctx", 0)
+                        act_id = cmd_json.get("act_id", 0)
                         data = cmd_json.get("data", 0)
                         token = DyadToken(
-                            target=target, offset=offset, ctx=ctx, data=data,
-                            port=Port.L, gen=0, wide=False
+                            target=target, offset=offset, act_id=act_id, data=data,
+                            port=Port.L
                         )
                         result = await loop.run_in_executor(
                             None, backend.send_command,
···
                         # Same as inject but respects backpressure
                         target = cmd_json.get("target", 0)
                         offset = cmd_json.get("offset", 0)
-                        ctx = cmd_json.get("ctx", 0)
+                        act_id = cmd_json.get("act_id", 0)
                         data = cmd_json.get("data", 0)
                         token = DyadToken(
-                            target=target, offset=offset, ctx=ctx, data=data,
-                            port=Port.L, gen=0, wide=False
+                            target=target, offset=offset, act_id=act_id, data=data,
+                            port=Port.L
                         )
                         result = await loop.run_in_executor(
                             None, backend.send_command,

tests/test_backend.py

···
         backend._handle_load(source)
 
         # Inject a token
-        token = MonadToken(target=0, offset=0, ctx=0, data=99, inline=True)
+        token = MonadToken(target=0, offset=0, act_id=0, data=99, inline=True)
         result = backend._handle_inject(token)
 
         assert isinstance(result, StepResult)
···
         backend._handle_load(source)
 
         # Send a token (should go through SimPy backpressure mechanism)
-        token = MonadToken(target=0, offset=0, ctx=0, data=77, inline=True)
+        token = MonadToken(target=0, offset=0, act_id=0, data=77, inline=True)
         result = backend._handle_send(token)
 
         assert isinstance(result, StepResult)

tests/test_snapshot.py

···
         # Since no cells were written, cells dict should be empty
         assert sm_snap.cells == {}
 
-    def test_capture_pe_matching_store_structure(self):
-        """Test that PE matching store is captured with correct structure."""
+    def test_capture_pe_frame_structure(self):
+        """Test that PE frame state is captured with correct structure."""
         env = simpy.Environment()
 
         iram = {0: Instruction(opcode=ArithOp.ADD, output=OutputStyle.INHERIT, has_const=False, dest_count=2, wide=False, fref=0)}
-        pe_configs = [PEConfig(pe_id=0, iram=iram, frame_count=4, offsets=64)]
+        pe_configs = [PEConfig(pe_id=0, iram=iram, frame_count=4, frame_slots=64)]
         sm_configs = []
 
         system = build_topology(env, pe_configs, sm_configs)
···
         snapshot = capture(system)
 
         pe_snap = snapshot.pes[0]
-        # matching_store should be a tuple of tuples (frozen dataclass)
-        assert isinstance(pe_snap.matching_store, tuple)
-        assert len(pe_snap.matching_store) == 4  # 4 context slots
-        for ctx_row in pe_snap.matching_store:
-            assert isinstance(ctx_row, tuple)
-            assert len(ctx_row) == 64  # 64 offsets per context
+        # frames should be a tuple of tuples (frozen dataclass)
+        assert isinstance(pe_snap.frames, tuple)
+        assert len(pe_snap.frames) == 4  # 4 frames
+        for frame in pe_snap.frames:
+            assert isinstance(frame, tuple)
+            # Each frame has slots
+
+        # tag_store should be dict mapping act_id to frame_id
+        assert isinstance(pe_snap.tag_store, dict)
+
+        # presence should be a tuple of tuples (frame_count x matchable_offsets)
+        assert isinstance(pe_snap.presence, tuple)
+        assert len(pe_snap.presence) == 4  # 4 frames
+
+        # port_store should be a tuple of tuples
+        assert isinstance(pe_snap.port_store, tuple)
+        assert len(pe_snap.port_store) == 4  # 4 frames
 
-        # Each entry should have occupied, data, port
-        for ctx_row in pe_snap.matching_store:
-            for entry in ctx_row:
-                assert "occupied" in entry
-                assert "data" in entry
-                assert "port" in entry
-                # Unoccupied entries should have port=None
-                assert entry["occupied"] is False
-                assert entry["data"] is None
-                assert entry["port"] is None
+        # free_frames should be a tuple of frame IDs
+        assert isinstance(pe_snap.free_frames, tuple)
 
     def test_capture_pe_output_log(self):
         """Test that PE output_log is captured."""
···
         with pytest.raises(AttributeError):
             snapshot.pes = {}
 
-    def test_capture_pe_gen_counters(self):
-        """Test that PE generation counters are captured."""
+    def test_capture_pe_tag_store(self):
+        """Test that PE tag_store is captured."""
         env = simpy.Environment()
 
         iram = {0: Instruction(opcode=RoutingOp.CONST, output=OutputStyle.SINK, has_const=True, dest_count=0, wide=False, fref=0)}
-        pe_configs = [PEConfig(pe_id=0, iram=iram)]
+        pe_configs = [PEConfig(pe_id=0, iram=iram, frame_count=8)]
         system = build_topology(env, pe_configs, [])
 
-        # Simulate generation counter increment
-        system.pes[0].gen_counters[0] = 5
-        system.pes[0].gen_counters[1] = 10
-
+        # Verify tag_store is captured
         snapshot = capture(system)
 
         pe_snap = snapshot.pes[0]
-        assert pe_snap.gen_counters[0] == 5
-        assert pe_snap.gen_counters[1] == 10
+        # tag_store should be a dict mapping act_id to frame_id
+        assert isinstance(pe_snap.tag_store, dict)
+        assert hasattr(pe_snap, 'frames')
+        assert hasattr(pe_snap, 'free_frames')
 
     def test_capture_sm_deferred_read(self):
         """Test that SM deferred_read state is captured."""
···
         system = build_topology(env, [], sm_configs)
 
         sm = system.sms[0]
-        # Add some tokens to T0 store
-        token1 = MonadToken(target=0, offset=5, act_id=0, data=777, inline=True)
-        token2 = MonadToken(target=0, offset=6, act_id=0, data=888, inline=True)
-        sm.t0_store.append(token1)
-        sm.t0_store.append(token2)
+        # Add some int values to T0 store
+        sm.t0_store.append(777)
+        sm.t0_store.append(888)
 
         snapshot = capture(system)
 
         sm_snap = snapshot.sms[0]
         assert len(sm_snap.t0_store) == 2
-        assert sm_snap.t0_store[0] == token1
-        assert sm_snap.t0_store[1] == token2
+        assert sm_snap.t0_store[0] == 777
+        assert sm_snap.t0_store[1] == 888
 
     def test_capture_multiple_pes_and_sms(self):
         """Test capturing state of a system with multiple PEs and SMs."""
         env = simpy.Environment()
 
         pe_configs = [
-            PEConfig(pe_id=0, iram={0: Instruction(opcode=RoutingOp.CONST, output=OutputStyle.SINK, has_const=True, dest_count=0, wide=False, fref=0)}),
-            PEConfig(pe_id=1, iram={0: Instruction(opcode=RoutingOp.CONST, output=OutputStyle.SINK, has_const=True, dest_count=0, wide=False, fref=0)}),
+            PEConfig(pe_id=0, iram={0: Instruction(opcode=RoutingOp.CONST, output=OutputStyle.SINK, has_const=True, dest_count=0, wide=False, fref=0)}, frame_count=4),
+            PEConfig(pe_id=1, iram={0: Instruction(opcode=RoutingOp.CONST, output=OutputStyle.SINK, has_const=True, dest_count=0, wide=False, fref=0)}, frame_count=4),
         ]
         sm_configs = [
             SMConfig(sm_id=0, cell_count=256),
···
         system = build_topology(env, pe_configs, sm_configs)
 
         # Set up some state
-        system.pes[0].gen_counters[0] = 7
-        system.pes[1].gen_counters[0] = 13
         system.sms[0].cells[5].pres = Presence.FULL
         system.sms[0].cells[5].data_l = 50
         system.sms[1].cells[10].pres = Presence.FULL
···
         assert len(snapshot.pes) == 2
         assert len(snapshot.sms) == 2
 
-        # Verify PE state
-        assert snapshot.pes[0].gen_counters[0] == 7
-        assert snapshot.pes[1].gen_counters[0] == 13
+        # Verify PE frame state is captured
+        assert len(snapshot.pes[0].frames) == 4
+        assert len(snapshot.pes[1].frames) == 4
+        assert isinstance(snapshot.pes[0].tag_store, dict)
+        assert isinstance(snapshot.pes[1].tag_store, dict)
 
         # Verify SM state
         assert snapshot.sms[0].cells[5].pres == Presence.FULL