feat: update monitor snapshot, graph_json, and backend for frame-based PE state and setup_tokens

Task 1: Update monitor/snapshot.py for frame-based PE state
- Replace PESnapshot fields: matching_store/gen_counters → frames/tag_store/presence/port_store/free_frames
- Update capture() to read frame data from live PE instances
- Change SMSnapshot.t0_store type from tuple[Token, ...] to tuple[int, ...]
- Update imports: add Instruction, FrameSlotValue, Port

Task 2: Update monitor/graph_json.py for frame events and act_id
- Add imports for new event types (FrameAllocated, FrameFreed, FrameSlotWritten, TokenRejected)
- Update _serialise_node to use act_id instead of ctx
- Add _serialise_slot helper function for frame slot serialization
- Update _serialise_pe_state to show frames instead of matching_store
- Update Matched event serialization to include frame_id
- Add serialization handlers for new frame event types
- Update SM node synthesis to use act_id instead of ctx

Task 3: Update monitor/backend.py for setup_tokens injection
- In _handle_load(), inject setup_tokens before seed_tokens
- Setup tokens come from AssemblyResult (IRAM writes, ALLOC, frame slot writes)

monitor/backend.py

···
 
             system = build_topology(env, pe_configs, sm_configs)
 
+            # Inject setup tokens (IRAM writes, ALLOC, frame slot writes)
+            for token in result.setup_tokens:
+                system.inject(token)
+
             # Inject seed tokens
             for seed in result.seed_tokens:
                 system.inject(seed)

monitor/graph_json.py

···
     SimEvent, TokenReceived, Matched, Executed, Emitted,
     CellWritten, DeferredRead as DeferredReadEvent,
     DeferredSatisfied, ResultSent,
+    FrameAllocated, FrameFreed, FrameSlotWritten, TokenRejected,
 )
 from monitor.snapshot import StateSnapshot
 
···
         "const": node.const,
         "pe": node.pe,
         "iram_offset": node.iram_offset,
-        "ctx": node.ctx,
+        "act_id": node.act_id,
         "has_error": False,
         "loc": {
             "line": 0,
···
     }
 
 
+def _serialise_slot(slot: Any) -> Any:
+    """Serialize a frame slot value to JSON-compatible format."""
+    if slot is None:
+        return None
+    if isinstance(slot, int):
+        return slot
+    # slot is a FrameDest
+    return {
+        "target_pe": slot.target_pe,
+        "offset": slot.offset,
+        "act_id": slot.act_id,
+        "port": slot.port.name,
+        "token_kind": slot.token_kind.name,
+    }
+
+
 def _serialise_edge(edge: IREdge) -> dict[str, Any]:
     """Serialize an IR edge to JSON."""
     return {
···
 
     iram_json = {}
     for offset, inst in pe_snap.iram.items():
-        opcode_str = str(inst.op.name) if hasattr(inst.op, 'name') else str(inst.op)
+        opcode_str = str(inst.opcode.name) if hasattr(inst.opcode, 'name') else str(inst.opcode)
         iram_json[str(offset)] = {
             "opcode": opcode_str,
             "offset": offset,
         }
 
-    matching_store_json = []
-    try:
-        for row in pe_snap.matching_store:
-            row_json = []
-            for entry in row:
-                if isinstance(entry, dict):
-                    row_json.append({
-                        "occupied": entry.get("occupied", False),
-                        "data": entry.get("data", 0),
-                        "port": entry.get("port", None),
-                    })
-                else:
-                    logger.warning(f"Non-dict entry in matching_store: {type(entry).__name__}")
-            matching_store_json.append(row_json)
-    except (TypeError, KeyError) as e:
-        logger.error(f"Error serializing matching_store: {e}")
+    frames_json = [[_serialise_slot(s) for s in frame] for frame in pe_snap.frames]
 
     return {
+        "pe_id": pe_snap.pe_id,
         "iram": iram_json,
-        "matching_store": matching_store_json,
-        "gen_counters": list(pe_snap.gen_counters),
-        "input_queue_depth": len(pe_snap.input_queue),
-        "output_count": len(pe_snap.output_log),
+        "frames": frames_json,
+        "tag_store": pe_snap.tag_store,
+        "free_frames": list(pe_snap.free_frames),
+        "input_queue_size": len(pe_snap.input_queue),
     }
 
 
···
         base["details"] = {
             "left": event.left,
             "right": event.right,
-            "ctx": event.ctx,
+            "act_id": event.act_id,
+            "frame_id": event.frame_id,
             "offset": event.offset,
         }
     elif isinstance(event, Executed):
···
         }
     elif isinstance(event, Emitted):
         base["details"] = {"token": str(event.token)}
+    elif isinstance(event, FrameAllocated):
+        base["details"] = {
+            "act_id": event.act_id,
+            "frame_id": event.frame_id,
+        }
+    elif isinstance(event, FrameFreed):
+        base["details"] = {
+            "act_id": event.act_id,
+            "frame_id": event.frame_id,
+        }
+    elif isinstance(event, FrameSlotWritten):
+        base["details"] = {
+            "frame_id": event.frame_id,
+            "slot": event.slot,
+            "value": event.value,
+        }
+    elif isinstance(event, TokenRejected):
+        base["details"] = {
+            "reason": event.reason,
+        }
     else:
         base["details"] = {}
 
···
             "const": None,
             "pe": None,
             "iram_offset": None,
-            "ctx": None,
+            "act_id": None,
             "has_error": False,
             "loc": {"line": 0, "column": 0, "end_line": None, "end_column": None},
             "sm_id": sm_id,

monitor/snapshot.py

···
 from dataclasses import dataclass
 from typing import Optional
 
-from cm_inst import ALUInst, SMInst
+from cm_inst import Instruction, FrameSlotValue, Port
 from emu.network import System
 from sm_mod import Presence
 from tokens import Token
···
     """Frozen snapshot of a Processing Element's state at a moment in time."""
 
     pe_id: int
-    iram: dict[int, ALUInst | SMInst]
-    matching_store: tuple[tuple[dict, ...], ...]
-    gen_counters: tuple[int, ...]
+    iram: dict[int, Instruction]
+    frames: tuple[tuple[FrameSlotValue, ...], ...]
+    tag_store: dict[int, int]
+    presence: tuple[tuple[bool, ...], ...]
+    port_store: tuple[tuple[Port | None, ...], ...]
+    free_frames: tuple[int, ...]
     input_queue: tuple[Token, ...]
     output_log: tuple[Token, ...]
 
···
     sm_id: int
     cells: dict[int, SMCellSnapshot]
     deferred_read: Optional[dict]
-    t0_store: tuple[Token, ...]
+    t0_store: tuple[int, ...]
     input_queue: tuple[Token, ...]
 
 
···
 def capture(system: System) -> StateSnapshot:
     """Capture a frozen snapshot of the entire system state at the current moment.
 
-    Reads from live PE and SM attributes (matching_store, iram, input_store.items,
-    output_log, gen_counters, cells, deferred_read, t0_store).
+    Reads from live PE and SM attributes (frames, tag_store, presence, port_store,
+    free_frames, iram, input_store.items, output_log, cells, deferred_read, t0_store).
 
     Args:
         system: A System instance from emu.network.build_topology()
···
     """
     pes = {}
     for pe_id, pe in system.pes.items():
-        matching = []
-        for ctx_row in pe.matching_store:
-            row = []
-            for entry in ctx_row:
-                row.append({
-                    "occupied": entry.occupied,
-                    "data": entry.data,
-                    "port": entry.port.name if entry.occupied else None,
-                })
-            matching.append(tuple(row))
+        frames = tuple(
+            tuple(slot for slot in frame)
+            for frame in pe.frames
+        )
+        tag_store = dict(pe.tag_store)
+        presence = tuple(
+            tuple(p for p in frame_presence)
+            for frame_presence in pe.presence
+        )
+        port_store = tuple(
+            tuple(p for p in frame_ports)
+            for frame_ports in pe.port_store
+        )
+        free_frames = tuple(pe.free_frames)
 
         pes[pe_id] = PESnapshot(
             pe_id=pe_id,
             iram=dict(pe.iram),
-            matching_store=tuple(matching),
-            gen_counters=tuple(pe.gen_counters),
+            frames=frames,
+            tag_store=tag_store,
+            presence=presence,
+            port_store=port_store,
+            free_frames=free_frames,
             input_queue=tuple(pe.input_store.items),
             output_log=tuple(pe.output_log),
         )