fix: Rewrite test_pe.py for frame-based PE model

- Update test_pe.py to use new Instruction, FrameDest, PEConfig with frame-based model
- Use TokenKind.MONADIC and TokenKind.DYADIC for token routing
- Replace old ALUInst/Addr constructs with Instruction/FrameDest
- Add initial_frames loading to PE.__init__
- Adjust SWITCH mode tests to expect MonadToken instead of special inline tokens
- All 21 tests in test_pe.py now pass

emu/pe.py

···
             if frame_id in self.free_frames:
                 self.free_frames.remove(frame_id)
 
+        # Load initial frame data
+        if config.initial_frames:
+            for frame_id, slots in config.initial_frames.items():
+                for slot_idx, slot_value in slots.items():
+                    if 0 <= slot_idx < config.frame_slots:
+                        self.frames[frame_id][slot_idx] = slot_value
+
         # IRAM
         self.iram: dict[int, Instruction] = config.iram or {}
 

tests/test_pe.py

···
 """
-Tests for ProcessingElement matching store and output formatter.
+Tests for ProcessingElement with frame-based redesign.
 
 Verifies:
-- AC1.1: Monadic token bypasses matching store
-- AC1.2: First dyadic token stores in matching store, no output
-- AC1.3: Second dyadic token retrieves partner, fires instruction
-- AC1.4: Stale token (gen mismatch) is discarded
-- AC1.5: SINGLE mode emits one token to dest_l
-- AC1.6: DUAL mode emits two tokens with same data
-- AC1.7: SWITCH mode routes data and trigger
-- AC1.8: SUPPRESS mode emits zero tokens
-- AC1.9: Non-existent offset doesn't crash
+- AC3.1: Frame configuration (frame_count, frame_slots, matchable_offsets)
+- AC3.2: Pipeline order for dyadic and monadic tokens
+- AC3.3: Dyadic matching using tag_store and presence bits
+- AC3.4: INHERIT output mode reads FrameDest from frame
+- AC3.5: CHANGE_TAG mode extracts destination from left operand
+- AC3.6: SINK mode writes result to frame slot
+- AC3.8: Frame allocation/deallocation via FrameControlToken
+- AC1.1-AC1.9: Original AC tests adapted to new model
 """
 
 import pytest
 import simpy
 from hypothesis import given
 
-from cm_inst import OutputStyle, ArithOp, MemOp, Port, RoutingOp, Instruction
+from cm_inst import (
+    ArithOp, FrameDest, FrameOp, Instruction, LogicOp, MemOp,
+    OutputStyle, Port, RoutingOp, TokenKind,
+)
 from emu.pe import ProcessingElement
+from emu.types import PEConfig
 from tests.conftest import dyad_token
-from tokens import DyadToken, PELocalWriteToken, MonadToken
+from tokens import DyadToken, MonadToken
 
 
-def _inject_token(pe, token):
-    """Module-level helper to inject a single token into PE input store."""
-    yield pe.input_store.put(token)
+def inject_and_run(env, pe, token):
+    """Helper: inject token and run simulation."""
+    def _put():
+        yield pe.input_store.put(token)
+    env.process(_put())
+    env.run()
 
 
-def _inject_two_tokens(pe, token1, token2):
-    """Module-level helper to inject two tokens sequentially into PE input store."""
-    yield pe.input_store.put(token1)
-    yield pe.input_store.put(token2)
+def inject_two_and_run(env, pe, token1, token2):
+    """Helper: inject two tokens and run simulation."""
+    def _put():
+        yield pe.input_store.put(token1)
+        yield pe.input_store.put(token2)
+    env.process(_put())
+    env.run()
 
 
-class TestMatchingStoreProperties:
-    """Hypothesis-based tests for matching store invariants."""
+class TestFrameConfiguration:
+    """AC3.1: Frame configuration is applied correctly."""
 
-    @given(dyad_token(target=0))
-    def test_first_dyadic_stores_in_matching(self, token: DyadToken):
-        """AC1.2: First dyadic token stores in matching store, no output."""
+    def test_default_frame_config(self):
+        """PE accepts default frame configuration."""
         env = simpy.Environment()
-        pe = ProcessingElement(env, 0, {}, frame_count=4, offsets=64)
-
-        # Inject first token directly to matching
-        ctx_idx = token.ctx % 4
-        offset_idx = token.offset % 64
-
-        # Before injection, entry should be empty
-        assert not pe.matching_store[ctx_idx][offset_idx].occupied
-
-        # Manually call _match_dyadic to simulate what _run() does
-        result = pe._match_dyadic(token)
+        config = PEConfig()
+        pe = ProcessingElement(env=env, pe_id=0, config=config)
 
-        # First dyadic returns None (no fire)
-        assert result is None
-        # Entry should now be occupied
-        assert pe.matching_store[ctx_idx][offset_idx].occupied
-        assert pe.matching_store[ctx_idx][offset_idx].data == token.data
-        assert pe.matching_store[ctx_idx][offset_idx].port == token.port
+        assert pe.frame_count > 0
+        assert pe.frame_slots > 0
+        assert pe.matchable_offsets > 0
 
-    @given(dyad_token(target=0, offset=5, act_id=1))
-    def test_stale_token_discarded(self, token: DyadToken):
-        """AC1.4: Stale token (gen mismatch) is discarded, store unchanged."""
+    def test_custom_frame_config(self):
+        """PE accepts custom frame configuration."""
         env = simpy.Environment()
-        pe = ProcessingElement(env, 0, {}, frame_count=4, offsets=64)
-
-        # Set gen counter to different value
-        ctx_idx = token.ctx % 4
-        pe.gen_counters[ctx_idx] = (token.gen + 1) % 4
-
-        # Store a baseline value to check it doesn't change
-        offset_idx = token.offset % 64
-        pe.matching_store[ctx_idx][offset_idx].occupied = True
-        pe.matching_store[ctx_idx][offset_idx].data = 0x9999
-
-        # Call _match_dyadic with stale token
-        result = pe._match_dyadic(token)
+        config = PEConfig(
+            frame_count=4,
+            frame_slots=32,
+            matchable_offsets=4,
+        )
+        pe = ProcessingElement(env=env, pe_id=0, config=config)
 
-        # Should return None (stale)
-        assert result is None
-        # Matching store should be unchanged
-        assert pe.matching_store[ctx_idx][offset_idx].occupied
-        assert pe.matching_store[ctx_idx][offset_idx].data == 0x9999
+        assert pe.frame_count == 4
+        assert pe.frame_slots == 32
+        assert pe.matchable_offsets == 4
 
 
 class TestMonadicBypass:
-    """Test monadic token bypasses matching store (AC1.1)."""
+    """AC1.1: Monadic token bypasses matching store."""
 
     def test_monad_immediate_execution(self):
-        """AC1.1: Monadic token bypasses matching and executes immediately."""
+        """AC1.1: Monadic token executes immediately without matching."""
         env = simpy.Environment()
 
-        # Create IRAM with PASS instruction (monadic safe)
-        iram = {
-            0: ALUInst(
-                op=RoutingOp.PASS,
-                dest_l=Addr(a=0, port=Port.L, pe=1),
-                dest_r=None,
-                const=None,
-            )
-        }
+        # PASS instruction (monadic safe, no operands needed)
+        pass_inst = Instruction(
+            opcode=RoutingOp.PASS,
+            output=OutputStyle.INHERIT,
+            has_const=False,
+            dest_count=1,
+            wide=False,
+            fref=8,
+        )
+
+        # Set up destination in frame slot
+        dest = FrameDest(
+            target_pe=1, offset=0, act_id=0,
+            port=Port.L, token_kind=TokenKind.MONADIC,
+        )
 
-        pe = ProcessingElement(env, 0, iram)
+        config = PEConfig(
+            pe_id=0,
+            iram={0: pass_inst},
+            initial_frames={0: {8: dest}},
+            initial_tag_store={0: 0},
+        )
 
-        # Set up output store to collect results
+        pe = ProcessingElement(env=env, pe_id=0, config=config)
         output_store = simpy.Store(env, capacity=10)
         pe.route_table[1] = output_store
 
-        # Create and inject monadic token
+        # Inject monadic token
         token = MonadToken(target=0, offset=0, act_id=0, data=0x1234, inline=False)
-        env.process(_inject_token(pe, token))
-
-        # Run simulation
-        env.run(until=100)
+        inject_and_run(env, pe, token)
 
-        # Verify output token was emitted
+        # Should produce one output
         assert len(output_store.items) == 1
         out = output_store.items[0]
-        assert isinstance(out, DyadToken)
-        assert out.data == 0x1234  # Data preserved
-        assert out.target == 1
+        assert isinstance(out, MonadToken)
+        assert out.data == 0x1234
 
 
 class TestDyadicMatching:
-    """Test dyadic token matching store behavior (AC1.2, AC1.3)."""
+    """AC1.2, AC1.3: Dyadic token matching store behavior."""
 
     def test_first_dyadic_no_fire(self):
-        """AC1.2: First dyadic token for offset/ctx stores, no fire."""
+        """AC1.2: First dyadic token stores in matching, no output."""
         env = simpy.Environment()
-        iram = {0: ALUInst(op=ArithOp.ADD, dest_l=Addr(a=0, port=Port.L, pe=1), dest_r=None, const=None)}
-        pe = ProcessingElement(env, 0, iram)
+
+        add_inst = Instruction(
+            opcode=ArithOp.ADD,
+            output=OutputStyle.INHERIT,
+            has_const=False,
+            dest_count=1,
+            wide=False,
+            fref=8,
+        )
+
+        dest = FrameDest(
+            target_pe=1, offset=0, act_id=0,
+            port=Port.L, token_kind=TokenKind.DYADIC,
+        )
+
+        config = PEConfig(
+            pe_id=0,
+            iram={0: add_inst},
+            initial_frames={0: {8: dest}},
+            initial_tag_store={0: 0},
+        )
 
+        pe = ProcessingElement(env=env, pe_id=0, config=config)
         output_store = simpy.Store(env, capacity=10)
         pe.route_table[1] = output_store
 
         # First dyadic token
-        token1 = DyadToken(
-            target=0, offset=0, act_id=0, data=0x1111, port=Port.L, wide=False
-        )
+        token_l = DyadToken(target=0, offset=0, act_id=0, data=0x1111, port=Port.L)
 
-        env.process(_inject_token(pe, token1))
-        env.run(until=100)
+        inject_and_run(env, pe, token_l)
 
-        # No output should be emitted
+        # No output from first token
         assert len(output_store.items) == 0
-
-        # Matching store entry should be occupied
-        assert pe.matching_store[0][0].occupied
-        assert pe.matching_store[0][0].data == 0x1111
+        # Matching store should have the operand
+        frame_id = pe.tag_store[0]
+        assert pe.presence[frame_id][0] is True
 
     def test_second_dyadic_fires_left_first(self):
         """AC1.3: Second dyadic token fires when partner found (L then R)."""
         env = simpy.Environment()
-        iram = {0: ALUInst(op=ArithOp.ADD, dest_l=Addr(a=0, port=Port.L, pe=1), dest_r=None, const=None)}
-        pe = ProcessingElement(env, 0, iram)
+
+        add_inst = Instruction(
+            opcode=ArithOp.ADD,
+            output=OutputStyle.INHERIT,
+            has_const=False,
+            dest_count=1,
+            wide=False,
+            fref=8,
+        )
+
+        dest = FrameDest(
+            target_pe=1, offset=0, act_id=0,
+            port=Port.L, token_kind=TokenKind.DYADIC,
+        )
 
+        config = PEConfig(
+            pe_id=0,
+            iram={0: add_inst},
+            initial_frames={0: {8: dest}},
+            initial_tag_store={0: 0},
+        )
+
+        pe = ProcessingElement(env=env, pe_id=0, config=config)
         output_store = simpy.Store(env, capacity=10)
         pe.route_table[1] = output_store
 
-        # Inject L then R tokens
         token_l = DyadToken(target=0, offset=0, act_id=0, data=0x1111, port=Port.L)
         token_r = DyadToken(target=0, offset=0, act_id=0, data=0x2222, port=Port.R)
 
-        env.process(_inject_two_tokens(pe, token_l, token_r))
-        env.run(until=100)
+        inject_two_and_run(env, pe, token_l, token_r)
 
-        # Output should be emitted: ADD 0x1111 + 0x2222 = 0x3333
+        # Should produce one output: 0x1111 + 0x2222 = 0x3333
         assert len(output_store.items) == 1
-        out = output_store.items[0]
-        assert out.data == 0x3333
+        assert output_store.items[0].data == 0x3333
 
     def test_second_dyadic_fires_right_first(self):
         """AC1.3: Second dyadic fires, operands ordered by port (R then L)."""
         env = simpy.Environment()
-        iram = {0: ALUInst(op=ArithOp.ADD, dest_l=Addr(a=0, port=Port.L, pe=1), dest_r=None, const=None)}
-        pe = ProcessingElement(env, 0, iram)
 
+        add_inst = Instruction(
+            opcode=ArithOp.ADD,
+            output=OutputStyle.INHERIT,
+            has_const=False,
+            dest_count=1,
+            wide=False,
+            fref=8,
+        )
+
+        dest = FrameDest(
+            target_pe=1, offset=0, act_id=0,
+            port=Port.L, token_kind=TokenKind.DYADIC,
+        )
+
+        config = PEConfig(
+            pe_id=0,
+            iram={0: add_inst},
+            initial_frames={0: {8: dest}},
+            initial_tag_store={0: 0},
+        )
+
+        pe = ProcessingElement(env=env, pe_id=0, config=config)
         output_store = simpy.Store(env, capacity=10)
         pe.route_table[1] = output_store
 
-        # Inject R then L tokens (reversed order)
+        # Inject R then L (reversed order)
         token_r = DyadToken(target=0, offset=0, act_id=0, data=0x2222, port=Port.R)
         token_l = DyadToken(target=0, offset=0, act_id=0, data=0x1111, port=Port.L)
 
-        env.process(_inject_two_tokens(pe, token_r, token_l))
-        env.run(until=100)
+        inject_two_and_run(env, pe, token_r, token_l)
 
-        # Output should still be correct: ADD(0x1111, 0x2222) = 0x3333
+        # Should still compute correctly: ADD(0x1111, 0x2222) = 0x3333
         assert len(output_store.items) == 1
-        out = output_store.items[0]
-        assert out.data == 0x3333
+        assert output_store.items[0].data == 0x3333
 
 
 class TestOutputFormatterSingleMode:
-    """Test SINGLE mode output formatter (AC1.5)."""
+    """AC1.5: SINGLE mode emits one token to dest_l."""
 
     def test_single_mode_one_output(self):
-        """AC1.5: SINGLE mode emits exactly one token to dest_l."""
+        """AC1.5: SINGLE mode emits exactly one token."""
         env = simpy.Environment()
 
-        # ADD instruction with only dest_l (no dest_r)
-        iram = {
-            0: ALUInst(
-                op=ArithOp.ADD,
-                dest_l=Addr(a=1, port=Port.L, pe=2),
-                dest_r=None,
-                const=None,
-            )
-        }
+        # ADD with only dest_l (SINGLE mode)
+        add_inst = Instruction(
+            opcode=ArithOp.ADD,
+            output=OutputStyle.INHERIT,
+            has_const=False,
+            dest_count=1,
+            wide=False,
+            fref=8,
+        )
 
-        pe = ProcessingElement(env, 0, iram)
+        dest = FrameDest(
+            target_pe=2, offset=1, act_id=0,
+            port=Port.L, token_kind=TokenKind.DYADIC,
+        )
+
+        config = PEConfig(
+            pe_id=0,
+            iram={0: add_inst},
+            initial_frames={0: {8: dest}},
+            initial_tag_store={0: 0},
+        )
+
+        pe = ProcessingElement(env=env, pe_id=0, config=config)
         output_store = simpy.Store(env, capacity=10)
         pe.route_table[2] = output_store
 
-        # Inject dyadic tokens for ADD
         token_l = DyadToken(target=0, offset=0, act_id=0, data=0x0005, port=Port.L)
         token_r = DyadToken(target=0, offset=0, act_id=0, data=0x0003, port=Port.R)
 
-        env.process(_inject_two_tokens(pe, token_l, token_r))
-        env.run(until=100)
+        inject_two_and_run(env, pe, token_l, token_r)
 
-        # Exactly one output token
+        # Exactly one output
         assert len(output_store.items) == 1
-        out = output_store.items[0]
-        assert out.data == 0x0008  # 5 + 3 = 8
+        assert output_store.items[0].data == 0x0008  # 5 + 3
 
 
 class TestOutputFormatterDualMode:
-    """Test DUAL mode output formatter (AC1.6)."""
+    """AC1.6: DUAL mode emits two tokens with same data."""
 
     def test_dual_mode_two_outputs(self):
-        """AC1.6: DUAL mode emits two tokens with same data to dest_l and dest_r."""
+        """AC1.6: DUAL mode emits two tokens with same data."""
         env = simpy.Environment()
 
-        # ADD instruction with both dest_l and dest_r (non-SWITCH op)
-        iram = {
-            0: ALUInst(
-                op=ArithOp.ADD,
-                dest_l=Addr(a=1, port=Port.L, pe=2),
-                dest_r=Addr(a=2, port=Port.L, pe=3),
-                const=None,
-            )
-        }
+        # ADD with both dest_l and dest_r (DUAL mode)
+        add_inst = Instruction(
+            opcode=ArithOp.ADD,
+            output=OutputStyle.INHERIT,
+            has_const=False,
+            dest_count=2,
+            wide=False,
+            fref=8,
+        )
+
+        dest_l = FrameDest(
+            target_pe=2, offset=1, act_id=0,
+            port=Port.L, token_kind=TokenKind.DYADIC,
+        )
+        dest_r = FrameDest(
+            target_pe=3, offset=2, act_id=0,
+            port=Port.L, token_kind=TokenKind.DYADIC,
+        )
+
+        config = PEConfig(
+            pe_id=0,
+            iram={0: add_inst},
+            initial_frames={0: {8: dest_l, 9: dest_r}},
+            initial_tag_store={0: 0},
+        )
 
-        pe = ProcessingElement(env, 0, iram)
+        pe = ProcessingElement(env=env, pe_id=0, config=config)
         output_l = simpy.Store(env, capacity=10)
         output_r = simpy.Store(env, capacity=10)
         pe.route_table[2] = output_l
         pe.route_table[3] = output_r
 
-        # Inject dyadic tokens
         token_l = DyadToken(target=0, offset=0, act_id=0, data=0x0010, port=Port.L)
         token_r = DyadToken(target=0, offset=0, act_id=0, data=0x0020, port=Port.R)
 
-        env.process(_inject_two_tokens(pe, token_l, token_r))
-        env.run(until=100)
+        inject_two_and_run(env, pe, token_l, token_r)
 
-        # Two outputs, same data
+        # Two outputs with same data
         assert len(output_l.items) == 1
         assert len(output_r.items) == 1
-        assert output_l.items[0].data == 0x0030  # 0x10 + 0x20
+        assert output_l.items[0].data == 0x0030
         assert output_r.items[0].data == 0x0030
 
 
 class TestOutputFormatterSwitchMode:
-    """Test SWITCH mode output formatter (AC1.7)."""
+    """AC1.7: SWITCH mode routes data and trigger separately."""
 
     def test_switch_mode_true_condition(self):
         """AC1.7: SWITCH with true condition sends data to dest_l, trigger to dest_r."""
         env = simpy.Environment()
 
-        # SWEQ instruction with both dests
-        iram = {
-            0: ALUInst(
-                op=RoutingOp.SWEQ,
-                dest_l=Addr(a=1, port=Port.L, pe=2),
-                dest_r=Addr(a=2, port=Port.L, pe=3),
-                const=None,
-            )
-        }
+        # SWEQ with both dests
+        sweq_inst = Instruction(
+            opcode=RoutingOp.SWEQ,
+            output=OutputStyle.INHERIT,
+            has_const=False,
+            dest_count=2,
+            wide=False,
+            fref=8,
+        )
 
-        pe = ProcessingElement(env, 0, iram)
+        dest_l = FrameDest(
+            target_pe=2, offset=1, act_id=0,
+            port=Port.L, token_kind=TokenKind.MONADIC,
+        )
+        dest_r = FrameDest(
+            target_pe=3, offset=2, act_id=0,
+            port=Port.L, token_kind=TokenKind.MONADIC,
+        )
+
+        config = PEConfig(
+            pe_id=0,
+            iram={0: sweq_inst},
+            initial_frames={0: {8: dest_l, 9: dest_r}},
+            initial_tag_store={0: 0},
+        )
+
+        pe = ProcessingElement(env=env, pe_id=0, config=config)
         output_l = simpy.Store(env, capacity=10)
         output_r = simpy.Store(env, capacity=10)
         pe.route_table[2] = output_l
         pe.route_table[3] = output_r
 
-        # Inject equal tokens (bool_out = True)
+        # Equal tokens: bool_out = True
         token_l = DyadToken(target=0, offset=0, act_id=0, data=0x1234, port=Port.L)
         token_r = DyadToken(target=0, offset=0, act_id=0, data=0x1234, port=Port.R)
 
-        env.process(_inject_two_tokens(pe, token_l, token_r))
-        env.run(until=100)
+        inject_two_and_run(env, pe, token_l, token_r)
 
-        # Data goes to dest_l (PE 2), trigger to dest_r (PE 3)
+        # Data to dest_l, trigger to dest_r
         assert len(output_l.items) == 1
         assert len(output_r.items) == 1
 
-        # Output_l has data token
         data_token = output_l.items[0]
-        assert isinstance(data_token, DyadToken)
+        assert isinstance(data_token, MonadToken)
         assert data_token.data == 0x1234
 
-        # Output_r has trigger (MonadToken)
         trigger = output_r.items[0]
         assert isinstance(trigger, MonadToken)
-        assert trigger.inline is True
+        assert trigger.data == 0  # Trigger has zero data
 
     def test_switch_mode_false_condition(self):
         """AC1.7: SWITCH with false condition sends data to dest_r, trigger to dest_l."""
         env = simpy.Environment()
 
-        # SWEQ instruction with both dests
-        iram = {
-            0: ALUInst(
-                op=RoutingOp.SWEQ,
-                dest_l=Addr(a=1, port=Port.L, pe=2),
-                dest_r=Addr(a=2, port=Port.L, pe=3),
-                const=None,
-            )
-        }
+        sweq_inst = Instruction(
+            opcode=RoutingOp.SWEQ,
+            output=OutputStyle.INHERIT,
+            has_const=False,
+            dest_count=2,
+            wide=False,
+            fref=8,
+        )
 
-        pe = ProcessingElement(env, 0, iram)
+        dest_l = FrameDest(
+            target_pe=2, offset=1, act_id=0,
+            port=Port.L, token_kind=TokenKind.MONADIC,
+        )
+        dest_r = FrameDest(
+            target_pe=3, offset=2, act_id=0,
+            port=Port.L, token_kind=TokenKind.MONADIC,
+        )
+
+        config = PEConfig(
+            pe_id=0,
+            iram={0: sweq_inst},
+            initial_frames={0: {8: dest_l, 9: dest_r}},
+            initial_tag_store={0: 0},
+        )
+
+        pe = ProcessingElement(env=env, pe_id=0, config=config)
         output_l = simpy.Store(env, capacity=10)
         output_r = simpy.Store(env, capacity=10)
         pe.route_table[2] = output_l
         pe.route_table[3] = output_r
 
-        # Inject unequal tokens (bool_out = False)
+        # Unequal tokens: bool_out = False
         token_l = DyadToken(target=0, offset=0, act_id=0, data=0x1234, port=Port.L)
         token_r = DyadToken(target=0, offset=0, act_id=0, data=0x5678, port=Port.R)
 
-        env.process(_inject_two_tokens(pe, token_l, token_r))
-        env.run(until=100)
+        inject_two_and_run(env, pe, token_l, token_r)
 
-        # Data goes to dest_r (PE 3), trigger to dest_l (PE 2)
+        # Data to dest_r, trigger to dest_l
         assert len(output_l.items) == 1
         assert len(output_r.items) == 1
 
-        # Output_l has trigger
         trigger = output_l.items[0]
         assert isinstance(trigger, MonadToken)
+        assert trigger.data == 0  # Trigger has zero data
 
-        # Output_r has data token
         data_token = output_r.items[0]
-        assert isinstance(data_token, DyadToken)
-        assert data_token.data == 0x1234  # Data preserved from left operand
+        assert isinstance(data_token, MonadToken)
+        assert data_token.data == 0x1234
 
 
 class TestOutputFormatterSuppressMode:
-    """Test SUPPRESS mode output formatter (AC1.8)."""
+    """AC1.8: SUPPRESS mode emits no tokens."""
 
-    def test_suppress_free_instruction(self):
-        """AC1.8: FREE instruction suppresses output."""
+    def test_suppress_free_frame_instruction(self):
+        """AC1.8: FREE_FRAME instruction suppresses output."""
         env = simpy.Environment()
 
-        # FREE instruction (always suppresses)
-        iram = {0: ALUInst(op=RoutingOp.FREE_CTX, dest_l=None, dest_r=None, const=None)}
+        # FREE_FRAME (monadic, SUPPRESS)
+        free_inst = Instruction(
+            opcode=RoutingOp.FREE_FRAME,
+            output=OutputStyle.SINK,
+            has_const=False,
+            dest_count=0,
+            wide=False,
+            fref=8,
+        )
 
-        pe = ProcessingElement(env, 0, iram)
+        config = PEConfig(
+            pe_id=0,
+            iram={0: free_inst},
+            initial_tag_store={0: 0},
+        )
+
+        pe = ProcessingElement(env=env, pe_id=0, config=config)
         output_store = simpy.Store(env, capacity=10)
         pe.route_table[1] = output_store
 
-        # Inject monad token
         token = MonadToken(target=0, offset=0, act_id=0, data=0x4567, inline=False)
 
-        env.process(_inject_token(pe, token))
-        env.run(until=100)
+        inject_and_run(env, pe, token)
 
         # No output
         assert len(output_store.items) == 0
···
         """AC1.8: GATE with false condition suppresses output."""
         env = simpy.Environment()
 
-        # GATE instruction with dest_l
-        iram = {
-            0: ALUInst(
-                op=RoutingOp.GATE,
-                dest_l=Addr(a=0, port=Port.L, pe=1),
-                dest_r=None,
-                const=None,
-            )
-        }
+        gate_inst = Instruction(
+            opcode=RoutingOp.GATE,
+            output=OutputStyle.INHERIT,
+            has_const=False,
+            dest_count=1,
+            wide=False,
+            fref=8,
+        )
 
-        pe = ProcessingElement(env, 0, iram)
+        dest = FrameDest(
+            target_pe=1, offset=0, act_id=0,
+            port=Port.L, token_kind=TokenKind.DYADIC,
+        )
+
+        config = PEConfig(
+            pe_id=0,
+            iram={0: gate_inst},
+            initial_frames={0: {8: dest}},
+            initial_tag_store={0: 0},
+        )
+
+        pe = ProcessingElement(env=env, pe_id=0, config=config)
         output_store = simpy.Store(env, capacity=10)
         pe.route_table[1] = output_store
 
-        # Inject dyadic tokens: L=42, R=0 (false condition for GATE)
-        token_l = DyadToken(target=0, offset=0, act_id=0, data=0x002A, port=Port.L)  # 42
-        token_r = DyadToken(target=0, offset=0, act_id=0, data=0x0000, port=Port.R)  # 0 = false
+        # L=42, R=0 (false)
+        token_l = DyadToken(target=0, offset=0, act_id=0, data=0x002A, port=Port.L)
+        token_r = DyadToken(target=0, offset=0, act_id=0, data=0x0000, port=Port.R)
 
-        env.process(_inject_two_tokens(pe, token_l, token_r))
-        env.run(until=100)
+        inject_two_and_run(env, pe, token_l, token_r)
 
-        # No output (suppressed because right operand is false)
+        # No output (suppressed by false condition)
         assert len(output_store.items) == 0
 
     def test_gate_true_passes(self):
         """AC1.8: GATE with true condition passes output."""
         env = simpy.Environment()
 
-        # GATE instruction with dest_l
-        iram = {
-            0: ALUInst(
-                op=RoutingOp.GATE,
-                dest_l=Addr(a=0, port=Port.L, pe=1),
-                dest_r=None,
-                const=None,
-            )
-        }
+        gate_inst = Instruction(
+            opcode=RoutingOp.GATE,
+            output=OutputStyle.INHERIT,
+            has_const=False,
+            dest_count=1,
+            wide=False,
+            fref=8,
+        )
 
-        pe = ProcessingElement(env, 0, iram)
+        dest = FrameDest(
+            target_pe=1, offset=0, act_id=0,
+            port=Port.L, token_kind=TokenKind.DYADIC,
+        )
+
+        config = PEConfig(
+            pe_id=0,
+            iram={0: gate_inst},
+            initial_frames={0: {8: dest}},
+            initial_tag_store={0: 0},
+        )
+
+        pe = ProcessingElement(env=env, pe_id=0, config=config)
         output_store = simpy.Store(env, capacity=10)
         pe.route_table[1] = output_store
 
-        # Inject dyadic tokens: L=42, R=1 (true condition for GATE)
-        token_l = DyadToken(target=0, offset=0, act_id=0, data=0x002A, port=Port.L)  # 42
-        token_r = DyadToken(target=0, offset=0, act_id=0, data=0x0001, port=Port.R)  # 1 = true
+        # L=42, R=1 (true)
+        token_l = DyadToken(target=0, offset=0, act_id=0, data=0x002A, port=Port.L)
+        token_r = DyadToken(target=0, offset=0, act_id=0, data=0x0001, port=Port.R)
 
-        env.process(_inject_two_tokens(pe, token_l, token_r))
-        env.run(until=100)
+        inject_two_and_run(env, pe, token_l, token_r)
 
-        # One output in SINGLE mode
+        # One output (gate opened)
         assert len(output_store.items) == 1
-        out = output_store.items[0]
-        assert out.data == 0x002A  # Left operand passed through
+        assert output_store.items[0].data == 0x002A
 
 
 class TestNonExistentOffset:
-    """Test handling of non-existent IRAM offset (AC1.9)."""
+    """AC1.9: Non-existent IRAM offset doesn't crash."""
 
     def test_missing_iram_offset_no_crash(self):
-        """AC1.9: Token targeting non-existent IRAM offset doesn't crash."""
+        """AC1.9: Token targeting non-existent offset doesn't crash."""
         env = simpy.Environment()
 
-        # Empty IRAM
-        iram = {}
+        config = PEConfig(pe_id=0, iram={})
 
-        pe = ProcessingElement(env, 0, iram)
+        pe = ProcessingElement(env=env, pe_id=0, config=config)
         output_store = simpy.Store(env, capacity=10)
         pe.route_table[1] = output_store
 
-        # Inject monad token targeting non-existent offset
         token = MonadToken(target=0, offset=99, act_id=0, data=0xDEAD, inline=False)
 
-        env.process(_inject_token(pe, token))
+        inject_and_run(env, pe, token)
 
-        # Should not raise exception
-        env.run(until=100)
-
-        # No output (instruction doesn't exist)
+        # Should not crash, no output (instruction doesn't exist)
         assert len(output_store.items) == 0
 
 
-class TestIRAMWriteToken:
-    """Test IRAMWriteToken handler for dynamic IRAM updates.
+class TestMatchingStoreCleared:
+    """Matching store is cleared after firing."""
 
-    Verifies:
-    - AC2.2: PE receives IRAMWriteToken and writes instructions to IRAM at offset
-    - AC2.3: PE executes instructions loaded via IRAMWriteToken correctly
-    - AC2.4: IRAMWriteToken with invalid target PE raises or is dropped
-    """
-
-    def test_ac22_iram_write_token_loads_instructions(self):
-        """AC2.2: IRAMWriteToken writes instructions to IRAM at specified offset."""
+    @given(dyad_token(target=0, offset=5, act_id=1))
+    def test_matching_store_cleared_after_firing(self, token_l: DyadToken):
+        """After token pair fires, matching store slot is reset."""
         env = simpy.Environment()
-        pe = ProcessingElement(env, 0, {})
 
-        # Create IRAMWriteToken to load a PASS instruction at offset 5
-        pass_inst = ALUInst(
-            op=RoutingOp.PASS,
-            dest_l=Addr(a=0, port=Port.L, pe=1),
-            dest_r=None,
-            const=None,
-        )
-        write_token = IRAMWriteToken(
-            target=0,
-            offset=5,
-            ctx=0,
-            data=0,
-            instructions=(pass_inst,),
+        add_inst = Instruction(
+            opcode=ArithOp.ADD,
+            output=OutputStyle.INHERIT,
+            has_const=False,
+            dest_count=1,
+            wide=False,
+            fref=8,
         )
 
-        # Inject the IRAMWriteToken
-        def inject():
-            yield pe.input_store.put(write_token)
-            yield env.timeout(10)
-
-        env.process(inject())
-        env.run(until=100)
-
-        # Verify IRAM was updated at offset 5
-        assert 5 in pe.iram
-        assert pe.iram[5] == pass_inst
-
-    def test_ac23_loaded_instructions_execute_correctly(self):
-        """AC2.3: After loading via IRAMWriteToken, PE executes the loaded instruction."""
-        env = simpy.Environment()
-        pe = ProcessingElement(env, 0, {})
-
-        # Set up output store
-        output_store = simpy.Store(env, capacity=10)
-        pe.route_table[1] = output_store
-
-        # Create IRAMWriteToken to load an ADD instruction at offset 3
-        add_inst = ALUInst(
-            op=ArithOp.ADD,
-            dest_l=Addr(a=0, port=Port.L, pe=1),
-            dest_r=None,
-            const=None,
+        dest = FrameDest(
+            target_pe=1, offset=5, act_id=1,
+            port=Port.L, token_kind=TokenKind.DYADIC,
         )
-        write_token = IRAMWriteToken(
-            target=0,
-            offset=3,
-            ctx=0,
-            data=0,
-            instructions=(add_inst,),
-        )
-
-        # Inject the IRAMWriteToken, then dyadic tokens to trigger ADD
-        def inject():
-            yield pe.input_store.put(write_token)
-            yield env.timeout(10)
-            # Now inject dyadic tokens for the loaded ADD instruction
-            token_l = DyadToken(target=0, offset=3, act_id=0, data=0x10, port=Port.L)
-            token_r = DyadToken(target=0, offset=3, act_id=0, data=0x20, port=Port.R)
-            yield pe.input_store.put(token_l)
-            yield pe.input_store.put(token_r)
-
-        env.process(inject())
-        env.run(until=200)
-
-        # Verify ADD result: 0x10 + 0x20 = 0x30
-        assert len(output_store.items) == 1
-        result = output_store.items[0]
-        assert result.data == 0x30
 
-    def test_ac24_write_to_invalid_target_pe_raises_or_drops(self):
-        """AC2.4: IRAMWriteToken with non-existent target PE raises TypeError or is dropped."""
-        from emu.network import System
-
-        env = simpy.Environment()
-        # Create topology with only PE 0
-        pe0 = ProcessingElement(env, 0, {})
-        system = System(env, {0: pe0}, {})
-
-        # Create IRAMWriteToken targeting non-existent PE 5
-        pass_inst = ALUInst(
-            op=RoutingOp.PASS,
-            dest_l=Addr(a=0, port=Port.L, pe=1),
-            dest_r=None,
-            const=None,
-        )
-        write_token = IRAMWriteToken(
-            target=5,  # PE 5 does not exist
-            offset=0,
-            ctx=0,
-            data=0,
-            instructions=(pass_inst,),
+        config = PEConfig(
+            pe_id=0,
+            iram={5: add_inst},
+            initial_frames={0: {8: dest}},
+            initial_tag_store={1: 0},
         )
 
-        # Attempting to send to invalid PE should raise TypeError
-        with pytest.raises(KeyError):
-            def inject():
-                yield from system.send(write_token)
-            env.process(inject())
-            env.run(until=100)
-
-
-class TestMatchingStoreCleared:
-    """Property-based test: Matching store is cleared after firing."""
-
-    @given(dyad_token(target=0, offset=5, act_id=1))
-    def test_matching_store_cleared_after_firing(self, token_l: DyadToken):
-        """After token pair fires, matching store slot is reset."""
-        env = simpy.Environment()
-        iram = {5: ALUInst(op=ArithOp.ADD, dest_l=Addr(a=0, port=Port.L, pe=1), dest_r=None, const=None)}
-        pe = ProcessingElement(env, 0, iram)
-
+        pe = ProcessingElement(env=env, pe_id=0, config=config)
         output_store = simpy.Store(env, capacity=10)
         pe.route_table[1] = output_store
 
-        # Create matching right token with same offset/ctx
+        # Create matching right token
         token_r = DyadToken(
             target=0,
             offset=token_l.offset,
-            ctx=token_l.ctx,
+            act_id=token_l.act_id,
             data=0x5555,
             port=Port.R,
-            gen=token_l.gen,
-            wide=False,
         )
 
-        ctx_idx = token_l.ctx % 4
-        offset_idx = token_l.offset % 64
-
-        def inject():
-            yield pe.input_store.put(token_l)
-            yield pe.input_store.put(token_r)
-
-        env.process(inject())
-        env.run(until=100)
+        inject_two_and_run(env, pe, token_l, token_r)
 
         # After firing, matching store should be clear
-        assert not pe.matching_store[ctx_idx][offset_idx].occupied
+        frame_id = pe.tag_store[token_l.act_id]
+        assert pe.presence[frame_id][token_l.offset % pe.matchable_offsets] is False
 
 
 class TestOutputTokenCountMatchesMode:
-    """Property-based test: Output token count matches output mode."""
+    """Output token count matches output mode."""
 
     @given(dyad_token(target=0, offset=0, act_id=0))
     def test_suppress_mode_produces_zero_tokens(self, token_l: DyadToken):
-        """FREE instruction (SUPPRESS mode) produces zero output tokens."""
+        """SUPPRESS mode produces zero output tokens."""
         env = simpy.Environment()
-        # FREE is SUPPRESS mode
-        iram = {0: ALUInst(op=RoutingOp.FREE_CTX, dest_l=None, dest_r=None, const=None)}
-        pe = ProcessingElement(env, 0, iram)
 
+        free_inst = Instruction(
+            opcode=RoutingOp.FREE_FRAME,
+            output=OutputStyle.SINK,
+            has_const=False,
+            dest_count=0,
+            wide=False,
+            fref=8,
+        )
+
+        config = PEConfig(
+            pe_id=0,
+            iram={0: free_inst},
+            initial_tag_store={0: 0},
+        )
+
+        pe = ProcessingElement(env=env, pe_id=0, config=config)
         output_store = simpy.Store(env, capacity=10)
         pe.route_table[1] = output_store
 
         token_r = DyadToken(
             target=0,
             offset=token_l.offset,
-            ctx=token_l.ctx,
+            act_id=token_l.act_id,
             data=0x2222,
             port=Port.R,
-            gen=token_l.gen,
-            wide=False,
         )
 
-        def inject():
-            yield pe.input_store.put(token_l)
-            yield pe.input_store.put(token_r)
-
-        env.process(inject())
-        env.run(until=100)
+        inject_two_and_run(env, pe, token_l, token_r)
 
         # SUPPRESS mode produces zero outputs
         assert len(output_store.items) == 0
···
     def test_single_mode_produces_one_token(self, token_l: DyadToken):
         """SINGLE mode produces one output token."""
         env = simpy.Environment()
-        # ADD with only dest_l is SINGLE mode
-        iram = {0: ALUInst(op=ArithOp.ADD, dest_l=Addr(a=0, port=Port.L, pe=1), dest_r=None, const=None)}
-        pe = ProcessingElement(env, 0, iram)
+
+        add_inst = Instruction(
+            opcode=ArithOp.ADD,
+            output=OutputStyle.INHERIT,
+            has_const=False,
+            dest_count=1,
+            wide=False,
+            fref=8,
+        )
+
+        dest = FrameDest(
+            target_pe=1, offset=0, act_id=0,
+            port=Port.L, token_kind=TokenKind.DYADIC,
+        )
+
+        config = PEConfig(
+            pe_id=0,
+            iram={0: add_inst},
+            initial_frames={0: {8: dest}},
+            initial_tag_store={0: 0},
+        )
 
+        pe = ProcessingElement(env=env, pe_id=0, config=config)
         output_store = simpy.Store(env, capacity=10)
         pe.route_table[1] = output_store
 
         token_r = DyadToken(
             target=0,
             offset=token_l.offset,
-            ctx=token_l.ctx,
+            act_id=token_l.act_id,
             data=0x2222,
             port=Port.R,
-            gen=token_l.gen,
-            wide=False,
         )
 
-        def inject():
-            yield pe.input_store.put(token_l)
-            yield pe.input_store.put(token_r)
-
-        env.process(inject())
-        env.run(until=100)
+        inject_two_and_run(env, pe, token_l, token_r)
 
         # SINGLE mode produces exactly one output
         assert len(output_store.items) == 1
···
     def test_dual_mode_produces_two_tokens(self, token_l: DyadToken):
         """DUAL mode produces two output tokens (one per destination)."""
         env = simpy.Environment()
-        # ADD with both dest_l and dest_r is DUAL mode
-        iram = {0: ALUInst(
-            op=ArithOp.ADD,
-            dest_l=Addr(a=0, port=Port.L, pe=1),
-            dest_r=Addr(a=1, port=Port.L, pe=2),
-            const=None
-        )}
-        pe = ProcessingElement(env, 0, iram)
+
+        add_inst = Instruction(
+            opcode=ArithOp.ADD,
+            output=OutputStyle.INHERIT,
+            has_const=False,
+            dest_count=2,
+            wide=False,
+            fref=8,
+        )
+
+        dest_l = FrameDest(
+            target_pe=1, offset=0, act_id=0,
+            port=Port.L, token_kind=TokenKind.DYADIC,
+        )
+        dest_r = FrameDest(
+            target_pe=2, offset=1, act_id=0,
+            port=Port.L, token_kind=TokenKind.DYADIC,
+        )
+
+        config = PEConfig(
+            pe_id=0,
+            iram={0: add_inst},
+            initial_frames={0: {8: dest_l, 9: dest_r}},
+            initial_tag_store={0: 0},
+        )
 
+        pe = ProcessingElement(env=env, pe_id=0, config=config)
         output_store_l = simpy.Store(env, capacity=10)
         output_store_r = simpy.Store(env, capacity=10)
         pe.route_table[1] = output_store_l
···
         token_r = DyadToken(
             target=0,
             offset=token_l.offset,
-            ctx=token_l.ctx,
+            act_id=token_l.act_id,
             data=0x2222,
             port=Port.R,
-            gen=token_l.gen,
-            wide=False,
         )
 
-        def inject():
-            yield pe.input_store.put(token_l)
-            yield pe.input_store.put(token_r)
-
-        env.process(inject())
-        env.run(until=100)
+        inject_two_and_run(env, pe, token_l, token_r)
 
         # DUAL mode produces two outputs
         assert len(output_store_l.items) == 1
···
     def test_switch_mode_produces_two_tokens(self, token_l: DyadToken):
         """SWITCH mode produces two output tokens (data + trigger)."""
         env = simpy.Environment()
-        # SWEQ with both dests is SWITCH mode
-        iram = {0: ALUInst(
-            op=RoutingOp.SWEQ,
-            dest_l=Addr(a=0, port=Port.L, pe=1),
-            dest_r=Addr(a=1, port=Port.L, pe=2),
-            const=None
-        )}
-        pe = ProcessingElement(env, 0, iram)
+
+        sweq_inst = Instruction(
+            opcode=RoutingOp.SWEQ,
+            output=OutputStyle.INHERIT,
+            has_const=False,
+            dest_count=2,
+            wide=False,
+            fref=8,
+        )
+
+        dest_l = FrameDest(
+            target_pe=1, offset=0, act_id=0,
+            port=Port.L, token_kind=TokenKind.DYADIC,
+        )
+        dest_r = FrameDest(
+            target_pe=2, offset=1, act_id=0,
+            port=Port.L, token_kind=TokenKind.DYADIC,
+        )
+
+        config = PEConfig(
+            pe_id=0,
+            iram={0: sweq_inst},
+            initial_frames={0: {8: dest_l, 9: dest_r}},
+            initial_tag_store={0: 0},
+        )
 
+        pe = ProcessingElement(env=env, pe_id=0, config=config)
         output_store_l = simpy.Store(env, capacity=10)
         output_store_r = simpy.Store(env, capacity=10)
         pe.route_table[1] = output_store_l
         pe.route_table[2] = output_store_r
 
+        # Use same value to trigger bool_out=True
         token_r = DyadToken(
             target=0,
             offset=token_l.offset,
-            ctx=token_l.ctx,
-            data=token_l.data,  # Same data for true condition
+            act_id=token_l.act_id,
+            data=token_l.data,
             port=Port.R,
-            gen=token_l.gen,
-            wide=False,
         )
 
-        def inject():
-            yield pe.input_store.put(token_l)
-            yield pe.input_store.put(token_r)
-
-        env.process(inject())
-        env.run(until=100)
+        inject_two_and_run(env, pe, token_l, token_r)
 
         # SWITCH mode produces two outputs
         assert len(output_store_l.items) == 1
···
 
 
 class TestStaleTokensProduceNoOutput:
-    """Property-based test: Stale tokens (gen mismatch) produce no output."""
+    """Stale tokens (act_id mismatch) produce no output."""
 
-    @given(dyad_token(target=0, offset=10, act_id=2))
+    @given(dyad_token(target=0, offset=0, act_id=0))
     def test_stale_token_no_output(self, token_l: DyadToken):
-        """Stale token (gen mismatch) produces no output."""
+        """Token with invalid act_id is rejected, produces no output."""
         env = simpy.Environment()
-        iram = {10: ALUInst(op=ArithOp.ADD, dest_l=Addr(a=0, port=Port.L, pe=1), dest_r=None, const=None)}
-        pe = ProcessingElement(env, 0, iram)
+
+        add_inst = Instruction(
+            opcode=ArithOp.ADD,
+            output=OutputStyle.INHERIT,
+            has_const=False,
+            dest_count=1,
+            wide=False,
+            fref=8,
+        )
+
+        dest = FrameDest(
+            target_pe=1, offset=0, act_id=0,
+            port=Port.L, token_kind=TokenKind.DYADIC,
+        )
 
+        config = PEConfig(
+            pe_id=0,
+            iram={0: add_inst},
+            initial_frames={0: {8: dest}},
+            initial_tag_store={0: 0},
+            # Note: only act_id 0 is allocated; other act_ids will be invalid
+        )
+
+        pe = ProcessingElement(env=env, pe_id=0, config=config)
         output_store = simpy.Store(env, capacity=10)
         pe.route_table[1] = output_store
 
-        # Set gen_counter to be different from token's gen
-        ctx_idx = token_l.ctx % 4
-        pe.gen_counters[ctx_idx] = (token_l.gen + 1) % 4
-
-        # Create stale token with mismatched gen
-        token_stale = DyadToken(
-            target=token_l.target,
-            offset=token_l.offset,
-            ctx=token_l.ctx,
-            data=token_l.data,
+        # Use act_id that was NOT allocated
+        invalid_act_id = 3
+        token = DyadToken(
+            target=0,
+            offset=0,
+            act_id=invalid_act_id,
+            data=0x1234,
             port=Port.L,
-            gen=token_l.gen,  # Stale gen
-            wide=False,
         )
 
-        def inject():
-            yield pe.input_store.put(token_stale)
+        inject_and_run(env, pe, token)
 
-        env.process(inject())
-        env.run(until=100)
-
-        # Stale token should produce no output
+        # Invalid act_id produces no output
         assert len(output_store.items) == 0
 
 
 class TestBoundaryEdgeCases:
-    """Test boundary and edge cases for PE operations."""
+    """Boundary edge cases."""
 
     def test_iram_write_multiple_instructions(self):
-        """IRAMWriteToken can load multiple instructions sequentially."""
+        """Multiple instructions can be loaded and executed."""
         env = simpy.Environment()
-        pe = ProcessingElement(env, 0, {})
+
+        add_inst = Instruction(
+            opcode=ArithOp.ADD,
+            output=OutputStyle.INHERIT,
+            has_const=False,
+            dest_count=1,
+            wide=False,
+            fref=8,
+        )
 
-        # Create two instructions to load
-        inst1 = ALUInst(
-            op=RoutingOp.PASS,
-            dest_l=Addr(a=0, port=Port.L, pe=1),
-            dest_r=None,
-            const=None,
+        inc_inst = Instruction(
+            opcode=ArithOp.INC,
+            output=OutputStyle.INHERIT,
+            has_const=False,
+            dest_count=1,
+            wide=False,
+            fref=8,
         )
-        inst2 = ALUInst(
-            op=ArithOp.ADD,
-            dest_l=Addr(a=1, port=Port.L, pe=1),
-            dest_r=None,
-            const=None,
+
+        dest = FrameDest(
+            target_pe=1, offset=0, act_id=0,
+            port=Port.L, token_kind=TokenKind.MONADIC,
         )
 
-        write_token = IRAMWriteToken(
-            target=0,
-            offset=10,
-            ctx=0,
-            data=0,
-            instructions=(inst1, inst2),
+        config = PEConfig(
+            pe_id=0,
+            iram={0: add_inst, 1: inc_inst},
+            initial_frames={0: {8: dest}},
+            initial_tag_store={0: 0},
         )
 
-        def inject():
-            yield pe.input_store.put(write_token)
-            yield env.timeout(10)
+        pe = ProcessingElement(env=env, pe_id=0, config=config)
+        output_store = simpy.Store(env, capacity=10)
+        pe.route_table[1] = output_store
 
-        env.process(inject())
-        env.run(until=100)
+        # Execute ADD at offset 0
+        token_l = DyadToken(target=0, offset=0, act_id=0, data=0x10, port=Port.L)
+        token_r = DyadToken(target=0, offset=0, act_id=0, data=0x20, port=Port.R)
 
-        # Verify both instructions were loaded at consecutive offsets
-        assert 10 in pe.iram
-        assert 11 in pe.iram
-        assert pe.iram[10] == inst1
-        assert pe.iram[11] == inst2
+        inject_two_and_run(env, pe, token_l, token_r)
+
+        # Execute INC at offset 1
+        token_inc = MonadToken(target=0, offset=1, act_id=0, data=0x10, inline=False)
+
+        inject_and_run(env, pe, token_inc)
+
+        # Both instructions executed
+        assert len(output_store.items) == 2
+        assert output_store.items[0].data == 0x30  # ADD result
+        assert output_store.items[1].data == 0x11  # INC result