diff --git a/test_engine.c b/test_engine.c
index 3f8c1ce..bfbc9b0 100644
--- a/test_engine.c
+++ b/test_engine.c
@@ -86,6 +86,7 @@ void test_trigger_empty_starts_recording(void) {
     Engine *engine = create_test_engine();
     
     engine_trigger_clip(engine, 0);
+    engine_process_commands(engine);
     assert(engine->clips[0].state == CLIP_RECORDING);
     assert(engine->clips[0].write_position == 0);
     
@@ -100,6 +101,7 @@ void test_trigger_recording_starts_looping(void) {
     
     // Start recording
     engine_trigger_clip(engine, 0);
+    engine_process_commands(engine);
     assert(engine->clips[0].state == CLIP_RECORDING);
     
     // Simulate some recording
@@ -107,6 +109,7 @@ void test_trigger_recording_starts_looping(void) {
     
     // Trigger again to stop recording and start looping
     engine_trigger_clip(engine, 0);
+    engine_process_commands(engine);
     assert(engine->clips[0].state == CLIP_LOOPING);
     assert(engine->clips[0].buffer_size == 100);
     assert(engine->clips[0].read_position == 0);
@@ -126,6 +129,7 @@ void test_trigger_looping_stops(void) {
     engine->clips[0].read_position = 50;
     
     engine_trigger_clip(engine, 0);
+    engine_process_commands(engine);
     assert(engine->clips[0].state == CLIP_STOPPED);
     assert(engine->clips[0].read_position == 0);
     
@@ -143,6 +147,7 @@ void test_trigger_stopped_resumes_looping(void) {
     engine->clips[0].buffer_size = 100;
     
     engine_trigger_clip(engine, 0);
+    engine_process_commands(engine);
     assert(engine->clips[0].state == CLIP_LOOPING);
     assert(engine->clips[0].read_position == 0);
     
@@ -157,20 +162,24 @@ void test_full_cycle(void) {
     
     // Empty -> Recording
     engine_trigger_clip(engine, 0);
+    engine_process_commands(engine);
     assert(engine->clips[0].state == CLIP_RECORDING);
     
     // Recording -> Looping
     engine->clips[0].write_position = 200;
     engine_trigger_clip(engine, 0);
+    engine_process_commands(engine);
     assert(engine->clips[0].state == CLIP_LOOPING);
     assert(engine->clips[0].buffer_size == 200);
     
     // Looping -> Stopped
     engine_trigger_clip(engine, 0);
+    engine_process_commands(engine);
     assert(engine->clips[0].state == CLIP_STOPPED);
     
     // Stopped -> Looping
     engine_trigger_clip(engine, 0);
+    engine_process_commands(engine);
     assert(engine->clips[0].state == CLIP_LOOPING);
     
     destroy_test_engine(engine);
@@ -184,20 +193,24 @@ void test_multiple_clips(void) {
     
     // Clip 0: Empty -> Recording
     engine_trigger_clip(engine, 0);
+    engine_process_commands(engine);
     assert(engine->clips[0].state == CLIP_RECORDING);
     
     // Clip 1: Empty -> Recording
     engine_trigger_clip(engine, 1);
+    engine_process_commands(engine);
     assert(engine->clips[1].state == CLIP_RECORDING);
     
     // Clip 0: Recording -> Looping
     engine->clips[0].write_position = 100;
     engine_trigger_clip(engine, 0);
+    engine_process_commands(engine);
     assert(engine->clips[0].state == CLIP_LOOPING);
     assert(engine->clips[1].state == CLIP_RECORDING);  // Clip 1 unaffected
     
     // Clip 2: Empty -> Recording
     engine_trigger_clip(engine, 2);
+    engine_process_commands(engine);
     assert(engine->clips[2].state == CLIP_RECORDING);
     
     destroy_test_engine(engine);
@@ -216,6 +229,7 @@ void test_reset_clip(void) {
     engine->clips[0].read_position = 50;
     
     engine_reset_clip(engine, 0);
+    engine_process_commands(engine);
     assert(engine->clips[0].state == CLIP_EMPTY);
     assert(engine->clips[0].buffer_size == 0);
     assert(engine->clips[0].write_position == 0);
@@ -274,6 +288,7 @@ void test_buffer_overflow(void) {
     
     // Start recording
     engine_trigger_clip(engine, 0);
+    engine_process_commands(engine);
     assert(engine->clips[0].state == CLIP_RECORDING);
     
     // Fill buffer to max
@@ -281,6 +296,7 @@ void test_buffer_overflow(void) {
     
     // Trigger should stop recording and start looping
     engine_trigger_clip(engine, 0);
+    engine_process_commands(engine);
     assert(engine->clips[0].state == CLIP_LOOPING);
     assert(engine->clips[0].buffer_size == MAX_BUFFER_SIZE);
     
@@ -316,6 +332,7 @@ void test_transport_reset(void) {
     engine->transport.sample_position = 10000;
     
     engine_reset_transport(engine);
+    engine_process_commands(engine);
     
     assert(engine->transport.rolling == false);
     assert(engine->transport.clock_count == 0);
@@ -335,12 +352,15 @@ void test_quantize_mode_setting(void) {
     assert(engine->quantize_mode == QUANTIZE_OFF);
     
     engine_set_quantize_mode(engine, QUANTIZE_BEAT);
+    engine_process_commands(engine);
     assert(engine->quantize_mode == QUANTIZE_BEAT);
     
     engine_set_quantize_mode(engine, QUANTIZE_BAR);
+    engine_process_commands(engine);
     assert(engine->quantize_mode == QUANTIZE_BAR);
     
     engine_set_quantize_mode(engine, QUANTIZE_OFF);
+    engine_process_commands(engine);
     assert(engine->quantize_mode == QUANTIZE_OFF);
     
     destroy_test_engine(engine);
@@ -366,9 +386,11 @@ void test_quantize_threshold_setting(void) {
     assert(engine->quantize_threshold == 0);
     
     engine_set_quantize_threshold(engine, 1000);
+    engine_process_commands(engine);
     assert(engine->quantize_threshold == 1000);
     
     engine_set_quantize_threshold(engine, 0);
+    engine_process_commands(engine);
     assert(engine->quantize_threshold == 0);
     
     destroy_test_engine(engine);
diff --git a/test_tui.c b/test_tui.c
index 6bc432f..87bbc35 100644
--- a/test_tui.c
+++ b/test_tui.c
@@ -86,6 +86,7 @@ void test_trigger_via_grid(void) {
     // Simulate pressing 't' on grid position (3, 4) = clip 28
     int clip_idx = 3 * 8 + 4;
     engine_trigger_clip(engine, clip_idx);
+    engine_process_commands(engine);
     assert(engine->clips[clip_idx].state == CLIP_RECORDING);
     
     destroy_test_engine(engine);
@@ -104,6 +105,7 @@ void test_reset_via_grid(void) {
     
     // Simulate pressing 'r'
     engine_reset_clip(engine, clip_idx);
+    engine_process_commands(engine);
     assert(engine->clips[clip_idx].state == CLIP_EMPTY);
     assert(engine->clips[clip_idx].buffer_size == 0);
     
@@ -119,6 +121,7 @@ void test_scene_via_grid(void) {
     // Simulate pressing 's' on row 3
     int scene_index = 3;
     engine_trigger_scene(engine, scene_index);
+    engine_process_commands(engine);
     
     // All clips in scene 3 should be recording
     for (int ch = 0; ch < MAX_CHANNELS; ch++) {
@@ -140,14 +143,17 @@ void test_quantize_cycling(void) {
     
     // Cycle: OFF -> BEAT
     engine_set_quantize_mode(engine, QUANTIZE_BEAT);
+    engine_process_commands(engine);
     assert(engine->quantize_mode == QUANTIZE_BEAT);
     
     // Cycle: BEAT -> BAR
     engine_set_quantize_mode(engine, QUANTIZE_BAR);
+    engine_process_commands(engine);
     assert(engine->quantize_mode == QUANTIZE_BAR);
     
     // Cycle: BAR -> OFF
     engine_set_quantize_mode(engine, QUANTIZE_OFF);
+    engine_process_commands(engine);
     assert(engine->quantize_mode == QUANTIZE_OFF);
     
     destroy_test_engine(engine);
@@ -164,10 +170,12 @@ void test_threshold_toggle(void) {
     
     // Toggle to 1000
     engine_set_quantize_threshold(engine, 1000);
+    engine_process_commands(engine);
     assert(engine->quantize_threshold == 1000);
     
     // Toggle back to 0
     engine_set_quantize_threshold(engine, 0);
+    engine_process_commands(engine);
     assert(engine->quantize_threshold == 0);
     
     destroy_test_engine(engine);
@@ -188,6 +196,7 @@ void test_transport_reset_via_tui(void) {
     
     // Simulate pressing 'x'
     engine_reset_transport(engine);
+    engine_process_commands(engine);
     
     assert(engine->transport.rolling == false);
     assert(engine->transport.clock_count == 0);
@@ -332,6 +341,7 @@ void test_full_grid_coverage(void) {
         for (int col = 0; col < 8; col++) {
             int clip_idx = row * 8 + col;
             engine_trigger_clip(engine, clip_idx);
+            engine_process_commands(engine);
             assert(engine->clips[clip_idx].state == CLIP_RECORDING);
         }
     }
@@ -353,6 +363,7 @@ void test_scene_from_each_row(void) {
     // Trigger scene from each row
     for (int row = 0; row < 8; row++) {
         engine_trigger_scene(engine, row);
+        engine_process_commands(engine);
         
         // Verify all clips in this scene are recording
         for (int ch = 0; ch < MAX_CHANNELS; ch++) {
@@ -373,12 +384,15 @@ void test_quantize_full_cycle(void) {
     // Cycle through all modes twice
     for (int cycle = 0; cycle < 2; cycle++) {
         engine_set_quantize_mode(engine, QUANTIZE_OFF);
+        engine_process_commands(engine);
         assert(engine->quantize_mode == QUANTIZE_OFF);
         
         engine_set_quantize_mode(engine, QUANTIZE_BEAT);
+        engine_process_commands(engine);
         assert(engine->quantize_mode == QUANTIZE_BEAT);
         
         engine_set_quantize_mode(engine, QUANTIZE_BAR);
+        engine_process_commands(engine);
         assert(engine->quantize_mode == QUANTIZE_BAR);
     }
     
@@ -395,9 +409,11 @@ void test_multiple_threshold_toggles(void) {
     for (int i = 0; i < 5; i++) {
         if (engine->quantize_threshold == 0) {
             engine_set_quantize_threshold(engine, 1000);
+            engine_process_commands(engine);
             assert(engine->quantize_threshold == 1000);
         } else {
             engine_set_quantize_threshold(engine, 0);
+            engine_process_commands(engine);
             assert(engine->quantize_threshold == 0);
         }
     }
@@ -420,6 +436,7 @@ void test_multiple_transport_resets(void) {
         engine->transport.sample_position = 10000 * i;
         
         engine_reset_transport(engine);
+        engine_process_commands(engine);
         
         assert(engine->transport.rolling == false);
         assert(engine->transport.clock_count == 0);