feat(jit): substrate ops inline + HBit β-divergence + Nop compaction

JIT scalar lowerer (lib.rs):
- Add `module` field to FunctionLowerer so it can look up registered externs
- Wire Op::Fold1 → omc_fold, Op::IsFibonacci → omc_is_attractor,
  Op::Fibonacci → omc_nth_fibonacci (already registered), plus
  Op::Resonance → omc_resonance_bits, Op::HimScore → omc_him_score_bits
  (new shims added this session) via emit_unary_extern_call helper
- Functions using substrate ops are now JIT-eligible without falling to
  the "Session B doesn't yet lower" error arm

HBit dual-band lowerer (dual_band.rs):
- PhiShadow step: every StoreVar/AssignVar now re-derives β = fold(α)
  so the β band tracks the nearest Fibonacci attractor of the live value
  rather than being a stale splatted copy from function entry
- Adds phi_shadow_store() helper using omc_fold via module.get_function

Bytecode optimizer (bytecode_opt.rs):
- New compact_nops() pass removes Op::Nop holes after the peephole
  fixpoint and rewrites all Jump/JumpIfFalse/JumpIfTrue offsets
- Adds nops_compacted field to OptStats; compact_nops runs once at the
  end of optimize_function (not inside the loop)
- 5 new tests: direct Nop removal, branch/loop jump bounds, integration
  with constant-folding pipeline

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: RandomCoder-lab

omnimcode-codegen/src/dual_band.rs

@@ -316,9 +316,14 @@ impl<'ctx, 'a> DualBandLowerer<'ctx, 'a> {
                 }
                 Op::StoreVar(name) | Op::AssignVar(name) => {
                     let v = self.pop(&mut stack, i, "Store/AssignVar")?;
+                    // PhiShadow: on every store, re-derive β = fold(α).
+                    // This makes β track the nearest Fibonacci attractor of
+                    // the live α value so that harmony() reads a meaningful
+                    // substrate distance rather than a stale splatted copy.
+                    let diverged = self.phi_shadow_store(v, i)?;
                     let slot = self.get_or_create_slot(name)?;
                     self.builder
-                        .build_store(slot, v)
+                        .build_store(slot, diverged)
                         .map_err(|e| format!("hbit store {} at op{}: {}", name, i, e))?;
                 }
 
@@ -1329,6 +1334,54 @@ impl<'ctx, 'a> DualBandLowerer<'ctx, 'a> {
         Ok(new_v)
     }
 
+    /// PhiShadow: extract α from a `<2 x i64>` and rebuild with β = fold(α).
+    /// β is set to the nearest Fibonacci attractor of α via `omc_fold`.
+    /// Every StoreVar/AssignVar calls this so the β band is never stale.
+    fn phi_shadow_store(
+        &self,
+        v: VectorValue<'ctx>,
+        op_idx: usize,
+    ) -> Result<VectorValue<'ctx>, CodegenError> {
+        let i64_type = self.ctx.i64_type();
+        // Extract α (lane 0).
+        let alpha_bv = self
+            .builder
+            .build_extract_element(v, i64_type.const_int(0, false), "ps_alpha")
+            .map_err(|e| format!("phi_shadow extract α at op{}: {}", op_idx, e))?;
+        let alpha_iv = match alpha_bv {
+            inkwell::values::BasicValueEnum::IntValue(iv) => iv,
+            _ => return Err(format!("phi_shadow: α not int at op{}", op_idx)),
+        };
+        // β = fold(α).
+        let fold_fn = self
+            .module
+            .get_function("omc_fold")
+            .ok_or_else(|| format!("omc_fold not declared (phi_shadow at op{})", op_idx))?;
+        let call = self
+            .builder
+            .build_call(fold_fn, &[alpha_iv.into()], "ps_fold")
+            .map_err(|e| format!("phi_shadow fold call at op{}: {}", op_idx, e))?;
+        let beta_bv = call
+            .try_as_basic_value()
+            .left()
+            .ok_or_else(|| format!("phi_shadow fold no return at op{}", op_idx))?;
+        let beta_iv = match beta_bv {
+            inkwell::values::BasicValueEnum::IntValue(iv) => iv,
+            _ => return Err(format!("phi_shadow: fold returned non-int at op{}", op_idx)),
+        };
+        // Rebuild <2 x i64> = [α, β].
+        let undef = self.v2i64.get_undef();
+        let with_alpha = self
+            .builder
+            .build_insert_element(undef, alpha_iv, i64_type.const_int(0, false), "ps_a")
+            .map_err(|e| format!("phi_shadow insert α at op{}: {}", op_idx, e))?;
+        let with_beta = self
+            .builder
+            .build_insert_element(with_alpha, beta_iv, i64_type.const_int(1, false), "ps_b")
+            .map_err(|e| format!("phi_shadow insert β at op{}: {}", op_idx, e))?;
+        Ok(with_beta)
+    }
+
     fn splat(&self, scalar: IntValue<'ctx>, name: &str) -> Result<VectorValue<'ctx>, CodegenError> {
         let i64_type = self.ctx.i64_type();
         let undef = self.v2i64.get_undef();

omnimcode-codegen/src/lib.rs

@@ -272,6 +272,22 @@ pub extern "C" fn omc_value_danger(n_bits: i64) -> i64 {
     (-f.abs()).exp().to_bits() as i64
 }
 
+/// resonance(n) -> f64 bits as i64.
+/// Harmonic resonance score: 1.0 for exact Fibonacci attractor, decays with distance.
+/// Op::Resonance in the JIT scalar lowerer.
+#[no_mangle]
+pub extern "C" fn omc_resonance_bits(n: i64) -> i64 {
+    omnimcode_core::value::HInt::compute_resonance(n).to_bits() as i64
+}
+
+/// him_score(n) -> f64 bits as i64.
+/// Harmonic Integer Map score: fractional part of n*phi, clamped to [0, 0.5].
+/// Op::HimScore in the JIT scalar lowerer.
+#[no_mangle]
+pub extern "C" fn omc_him_score_bits(n: i64) -> i64 {
+    omnimcode_core::value::HInt::compute_him(n).to_bits() as i64
+}
+
 // ---------------------------------------------------------------------------
 // Binary i64,i64 -> i64 harmonic primitives
 // ---------------------------------------------------------------------------
@@ -641,6 +657,9 @@ impl<'ctx> JitContext<'ctx> {
             ("omc_harmonic_unalign",   omc_harmonic_unalign as *const () as usize),
             ("omc_harmony_value",      omc_harmony_value as *const () as usize),
             ("omc_value_danger",       omc_value_danger as *const () as usize),
+            // Op::Resonance / Op::HimScore — f64 result packed as i64 bits.
+            ("omc_resonance_bits",     omc_resonance_bits as *const () as usize),
+            ("omc_him_score_bits",     omc_him_score_bits as *const () as usize),
             // Array-input intrinsics — same i64 -> i64 signature; the
             // input i64 is the L1.6 length-prefixed buffer pointer.
             ("omc_arr_sum_int",        omc_arr_sum_int as *const () as usize),
@@ -1030,6 +1049,7 @@ struct FunctionLowerer<'ctx, 'a> {
     builder: Builder<'ctx>,
     function: FunctionValue<'ctx>,
     f: &'a CompiledFunction,
+    module: &'a LlvmModule<'ctx>,
 
     /// One LLVM basic block per op-index leader, plus the entry block.
     /// Map: bytecode op-index -> the LLVM block whose body begins there.
@@ -1066,6 +1086,7 @@ impl<'ctx, 'a> FunctionLowerer<'ctx, 'a> {
             builder,
             function,
             f,
+            module,
             blocks: HashMap::new(),
             var_slots: HashMap::new(),
             cleanup_pops: std::collections::HashSet::new(),
@@ -1524,6 +1545,43 @@ impl<'ctx, 'a> FunctionLowerer<'ctx, 'a> {
                     }
                 }
 
+                // ── Substrate ops ─────────────────────────────────────────
+                // All delegate to extern C shims already registered in the
+                // JIT engine. omc_fold/omc_is_attractor/omc_nth_fibonacci
+                // were registered in an earlier session; omc_resonance_bits
+                // and omc_him_score_bits were added this session.
+                // Resonance and HimScore return f64-as-i64-bits (same
+                // convention as the i64 register file for floats).
+                Op::Fold1 => {
+                    let x = pop(&mut stack, i, "Fold1")?;
+                    let result = self.emit_unary_extern_call("omc_fold", x, i)?;
+                    stack.push(result);
+                }
+
+                Op::IsFibonacci => {
+                    let x = pop(&mut stack, i, "IsFibonacci")?;
+                    let result = self.emit_unary_extern_call("omc_is_attractor", x, i)?;
+                    stack.push(result);
+                }
+
+                Op::Fibonacci => {
+                    let x = pop(&mut stack, i, "Fibonacci")?;
+                    let result = self.emit_unary_extern_call("omc_nth_fibonacci", x, i)?;
+                    stack.push(result);
+                }
+
+                Op::Resonance => {
+                    let x = pop(&mut stack, i, "Resonance")?;
+                    let result = self.emit_unary_extern_call("omc_resonance_bits", x, i)?;
+                    stack.push(result);
+                }
+
+                Op::HimScore => {
+                    let x = pop(&mut stack, i, "HimScore")?;
+                    let result = self.emit_unary_extern_call("omc_him_score_bits", x, i)?;
+                    stack.push(result);
+                }
+
                 other => {
                     return Err(format!(
                         "Session B doesn't yet lower op: {:?} at op{}",
@@ -1701,6 +1759,33 @@ impl<'ctx, 'a> FunctionLowerer<'ctx, 'a> {
         stack.push(i64v);
         Ok(())
     }
+
+    /// Emit a call to a pre-registered unary extern `fn(i64) -> i64`.
+    /// The function must already be declared in `self.module` (done during
+    /// JitContext initialisation). Returns the i64 result value.
+    fn emit_unary_extern_call(
+        &self,
+        name: &str,
+        arg: IntValue<'ctx>,
+        op_idx: usize,
+    ) -> Result<IntValue<'ctx>, CodegenError> {
+        let ext_fn = self
+            .module
+            .get_function(name)
+            .ok_or_else(|| format!("{} not declared in module at op{}", name, op_idx))?;
+        let call = self
+            .builder
+            .build_call(ext_fn, &[arg.into()], &format!("{}_ret", name))
+            .map_err(|e| format!("{} call at op{}: {}", name, op_idx, e))?;
+        let ret = call
+            .try_as_basic_value()
+            .left()
+            .ok_or_else(|| format!("{} returned void at op{}", name, op_idx))?;
+        match ret {
+            inkwell::values::BasicValueEnum::IntValue(iv) => Ok(iv),
+            _ => Err(format!("{} returned non-int at op{}", name, op_idx)),
+        }
+    }
 }
 
 fn pop<'ctx>(