diff --git a/src/mir/instruction/tests.rs b/src/mir/instruction/tests.rs
index 9b6e5e6a..b9c108f9 100644
--- a/src/mir/instruction/tests.rs
+++ b/src/mir/instruction/tests.rs
@@ -47,6 +47,7 @@ fn test_call_instruction() {
     let inst = MirInstruction::Call {
         dst: Some(dst),
         func,
+        callee: None,  // Legacy mode for test
         args: vec![arg1, arg2],
         effects: EffectMask::IO,
     };
diff --git a/src/mir/phi_core/loopform_builder.rs b/src/mir/phi_core/loopform_builder.rs
index 22462243..369b7f77 100644
--- a/src/mir/phi_core/loopform_builder.rs
+++ b/src/mir/phi_core/loopform_builder.rs
@@ -346,21 +346,21 @@ mod tests {
     #[test]
     fn test_sanitize_phi_inputs() {
         let mut inputs = vec![
-            (BasicBlockId::from(1), ValueId::from(10)),
-            (BasicBlockId::from(2), ValueId::from(20)),
-            (BasicBlockId::from(1), ValueId::from(11)), // Duplicate, should override
+            (BasicBlockId::new(1), ValueId::new(10)),
+            (BasicBlockId::new(2), ValueId::new(20)),
+            (BasicBlockId::new(1), ValueId::new(11)), // Duplicate, should override
         ];
         sanitize_phi_inputs(&mut inputs);
 
         assert_eq!(inputs.len(), 2);
-        assert_eq!(inputs[0], (BasicBlockId::from(1), ValueId::from(11))); // Latest value
-        assert_eq!(inputs[1], (BasicBlockId::from(2), ValueId::from(20)));
+        assert_eq!(inputs[0], (BasicBlockId::new(1), ValueId::new(11))); // Latest value
+        assert_eq!(inputs[1], (BasicBlockId::new(2), ValueId::new(20)));
     }
 
     #[test]
     fn test_loopform_builder_separation() {
-        let preheader = BasicBlockId::from(0);
-        let header = BasicBlockId::from(1);
+        let preheader = BasicBlockId::new(0);
+        let header = BasicBlockId::new(1);
         let mut builder = LoopFormBuilder::new(preheader, header);
 
         // Mock ops
@@ -380,7 +380,7 @@ mod tests {
 
         impl LoopFormOps for MockOps {
             fn new_value(&mut self) -> ValueId {
-                let id = ValueId::from(self.next_value);
+                let id = ValueId::new(self.next_value);
                 self.next_value += 1;
                 id
             }
@@ -429,11 +429,11 @@ mod tests {
 
         // Setup variables: me, limit (params), i, a, b (locals)
         let mut vars = HashMap::new();
-        vars.insert("me".to_string(), ValueId::from(0));
-        vars.insert("limit".to_string(), ValueId::from(1));
-        vars.insert("i".to_string(), ValueId::from(2));
-        vars.insert("a".to_string(), ValueId::from(3));
-        vars.insert("b".to_string(), ValueId::from(4));
+        vars.insert("me".to_string(), ValueId::new(0));
+        vars.insert("limit".to_string(), ValueId::new(1));
+        vars.insert("i".to_string(), ValueId::new(2));
+        vars.insert("a".to_string(), ValueId::new(3));
+        vars.insert("b".to_string(), ValueId::new(4));
 
         // Prepare structure
         builder.prepare_structure(&mut ops, &vars).unwrap();
@@ -455,11 +455,11 @@ mod tests {
         // Verify deterministic allocation order
         // Expected: pinned first (me, limit), then carriers (i, a, b)
         // Each gets preheader_copy, header_phi sequentially
-        assert_eq!(builder.pinned[0].preheader_copy, ValueId::from(100)); // me copy
-        assert_eq!(builder.pinned[0].header_phi, ValueId::from(101));     // me phi
-        assert_eq!(builder.pinned[1].preheader_copy, ValueId::from(102)); // limit copy
-        assert_eq!(builder.pinned[1].header_phi, ValueId::from(103));     // limit phi
-        assert_eq!(builder.carriers[0].preheader_copy, ValueId::from(104)); // i copy
-        assert_eq!(builder.carriers[0].header_phi, ValueId::from(105));     // i phi
+        assert_eq!(builder.pinned[0].preheader_copy, ValueId::new(100)); // me copy
+        assert_eq!(builder.pinned[0].header_phi, ValueId::new(101));     // me phi
+        assert_eq!(builder.pinned[1].preheader_copy, ValueId::new(102)); // limit copy
+        assert_eq!(builder.pinned[1].header_phi, ValueId::new(103));     // limit phi
+        assert_eq!(builder.carriers[0].preheader_copy, ValueId::new(104)); // i copy
+        assert_eq!(builder.carriers[0].header_phi, ValueId::new(105));     // i phi
     }
 }
diff --git a/src/mir/value_id.rs b/src/mir/value_id.rs
index 9f6680bd..da85c341 100644
--- a/src/mir/value_id.rs
+++ b/src/mir/value_id.rs
@@ -11,6 +11,9 @@ use std::fmt;
 pub struct ValueId(pub u32);
 
 impl ValueId {
+    /// Invalid/uninitialized ValueId sentinel
+    pub const INVALID: Self = ValueId(u32::MAX);
+
     /// Create a new ValueId
     pub fn new(id: u32) -> Self {
         ValueId(id)
diff --git a/tests/mir_instruction_unit.rs b/tests/mir_instruction_unit.rs
index e48c70de..96685566 100644
--- a/tests/mir_instruction_unit.rs
+++ b/tests/mir_instruction_unit.rs
@@ -37,6 +37,7 @@ fn test_call_instruction() {
     let inst = MirInstruction::Call {
         dst: Some(dst),
         func,
+        callee: None,  // Legacy mode for test
         args: vec![arg1, arg2],
         effects: EffectMask::IO,
     };