diff --git a/src/backend/mir_interpreter/handlers/boxes.rs b/src/backend/mir_interpreter/handlers/boxes.rs
index be563e91..84f44699 100644
--- a/src/backend/mir_interpreter/handlers/boxes.rs
+++ b/src/backend/mir_interpreter/handlers/boxes.rs
@@ -152,28 +152,16 @@ impl MirInterpreter {
         // e.g., `A or not last.is_eof()` should not crash when last is absent.
         match self.reg_load(box_val)? {
             VMValue::Void => {
-                match method {
-                    "is_eof" => { if let Some(d) = dst { self.regs.insert(d, VMValue::Bool(false)); } return Ok(()); }
-                    "length" => { if let Some(d) = dst { self.regs.insert(d, VMValue::Integer(0)); } return Ok(()); }
-                    "substring" => { if let Some(d) = dst { self.regs.insert(d, VMValue::String(String::new())); } return Ok(()); }
-                    "push" => { if let Some(d) = dst { self.regs.insert(d, VMValue::Void); } return Ok(()); }
-                    "get_position" => { if let Some(d) = dst { self.regs.insert(d, VMValue::Integer(0)); } return Ok(()); }
-                    "get_line" => { if let Some(d) = dst { self.regs.insert(d, VMValue::Integer(1)); } return Ok(()); }
-                    "get_column" => { if let Some(d) = dst { self.regs.insert(d, VMValue::Integer(1)); } return Ok(()); }
-                    _ => {}
+                if let Some(val) = super::boxes_void_guards::handle_void_method(method) {
+                    if let Some(d) = dst { self.regs.insert(d, val); }
+                    return Ok(());
                 }
             }
             VMValue::BoxRef(ref b) => {
                 if b.as_any().downcast_ref::<crate::box_trait::VoidBox>().is_some() {
-                    match method {
-                        "is_eof" => { if let Some(d) = dst { self.regs.insert(d, VMValue::Bool(false)); } return Ok(()); }
-                        "length" => { if let Some(d) = dst { self.regs.insert(d, VMValue::Integer(0)); } return Ok(()); }
-                        "substring" => { if let Some(d) = dst { self.regs.insert(d, VMValue::String(String::new())); } return Ok(()); }
-                        "push" => { if let Some(d) = dst { self.regs.insert(d, VMValue::Void); } return Ok(()); }
-                        "get_position" => { if let Some(d) = dst { self.regs.insert(d, VMValue::Integer(0)); } return Ok(()); }
-                        "get_line" => { if let Some(d) = dst { self.regs.insert(d, VMValue::Integer(1)); } return Ok(()); }
-                        "get_column" => { if let Some(d) = dst { self.regs.insert(d, VMValue::Integer(1)); } return Ok(()); }
-                        _ => {}
+                    if let Some(val) = super::boxes_void_guards::handle_void_method(method) {
+                        if let Some(d) = dst { self.regs.insert(d, val); }
+                        return Ok(());
                     }
                 }
             }
diff --git a/src/backend/mir_interpreter/handlers/boxes_void_guards.rs b/src/backend/mir_interpreter/handlers/boxes_void_guards.rs
new file mode 100644
index 00000000..7361de76
--- /dev/null
+++ b/src/backend/mir_interpreter/handlers/boxes_void_guards.rs
@@ -0,0 +1,21 @@
+// Void/VoidBox graceful method guards
+// Extracted from boxes.rs to eliminate duplication (28 lines → 6 lines)
+
+use super::super::VMValue;
+
+/// Handle common methods on Void/VoidBox with graceful fallback values.
+/// Used for short-circuit patterns like `A or not last.is_eof()` where `last` may be absent.
+///
+/// Returns Some(VMValue) if the method is a known void-safe method, None otherwise.
+pub(super) fn handle_void_method(method: &str) -> Option<VMValue> {
+    match method {
+        "is_eof" => Some(VMValue::Bool(false)),
+        "length" => Some(VMValue::Integer(0)),
+        "substring" => Some(VMValue::String(String::new())),
+        "push" => Some(VMValue::Void),
+        "get_position" => Some(VMValue::Integer(0)),
+        "get_line" => Some(VMValue::Integer(1)),
+        "get_column" => Some(VMValue::Integer(1)),
+        _ => None,
+    }
+}
diff --git a/src/backend/mir_interpreter/handlers/mod.rs b/src/backend/mir_interpreter/handlers/mod.rs
index 1f12bc69..80a3a90c 100644
--- a/src/backend/mir_interpreter/handlers/mod.rs
+++ b/src/backend/mir_interpreter/handlers/mod.rs
@@ -8,6 +8,7 @@ mod boxes_map;
 mod boxes_object_fields;
 mod boxes_instance;
 mod boxes_plugin;
+mod boxes_void_guards;
 mod calls;
 mod externals;
 mod memory;
diff --git a/src/mir/builder.rs b/src/mir/builder.rs
index 4426b6e9..fb3ebda5 100644
--- a/src/mir/builder.rs
+++ b/src/mir/builder.rs
@@ -434,6 +434,14 @@ impl MirBuilder {
         }
 
         if let Some(ref mut function) = self.current_function {
+            // Pre-capture branch/jump targets for predecessor update after we finish
+            // mutably borrowing the current block.
+            let (then_t, else_t, jump_t) = match &instruction {
+                MirInstruction::Branch { then_bb, else_bb, .. } => (Some(*then_bb), Some(*else_bb), None),
+                MirInstruction::Jump { target } => (None, None, Some(*target)),
+                _ => (None, None, None),
+            };
+
             if let Some(block) = function.get_block_mut(block_id) {
                 if utils::builder_debug_enabled() {
                     eprintln!(
@@ -484,12 +492,23 @@ impl MirBuilder {
                     );
                 }
                 block.add_instruction(instruction);
-                Ok(())
-            } else {
-                Err(format!("Basic block {} does not exist", block_id))
+                // Drop the mutable borrow of `block` before updating other blocks
+                }
+            // Update predecessor sets for branch/jump immediately so that
+            // debug_verify_phi_inputs can observe a consistent CFG without
+            // requiring a full function.update_cfg() pass.
+            if let Some(t) = then_t {
+                if let Some(succ) = function.get_block_mut(t) { succ.add_predecessor(block_id); }
             }
+            if let Some(t) = else_t {
+                if let Some(succ) = function.get_block_mut(t) { succ.add_predecessor(block_id); }
+            }
+            if let Some(t) = jump_t {
+                if let Some(succ) = function.get_block_mut(t) { succ.add_predecessor(block_id); }
+            }
+            Ok(())
         } else {
-            Err("No current function".to_string())
+            Err(format!("Basic block {} does not exist", block_id))
         }
     }