Phase L+M: resonance caching + typed HIR with specialized dispatch

## Phase L — Resonance / portal caching

New unary_cache_pass in bytecode_opt.rs. Precomputes pure-unary
harmonic ops on constants at compile time, before the constant folder
so chained arithmetic sees a single constant:

  LoadConst(N); Resonance   → LoadConst(precomputed_float)
  LoadConst(N); Fold1       → LoadConst(snapped_int)
  LoadConst(N); IsFibonacci → LoadConst(1 or 0)
  LoadConst(N); Fibonacci   → LoadConst(fib(N))
  LoadConst(N); HimScore    → LoadConst(precomputed_float)
  LoadConst(N); Neg         → LoadConst(-N)
  LoadConst(N); BitNot      → LoadConst(!N)
  LoadConst(B); Not         → LoadConst(!B)

Mixed example: res(89) + 0.5 folds in two passes — cache res(89) -> 1.0,
then fold 1.0 + 0.5 -> 1.5, collapsing two ops to a single LoadConst.

New stats counter unary_calls_cached. Aggregated into total via a new
accumulate() helper (previously each stat was added by hand, easy to
miss).

## Phase M — Typed HIR with specialized dispatch

Compiler now tracks variable types as it lowers AST to bytecode.
TypeTag = Option<&'static str> over "int" / "float" / "string" / "bool"
/ "array" (None = couldn't prove statically; runtime polymorphism
applies as before).

Sources of type info:
- Typed function parameters: fn add(x: int, y: int)
- Return-type annotations: fn foo() -> int
- Variable decls inferred from value: h x = 89 ⇒ int
- Arithmetic on known-typed operands: int + int ⇒ int
- Comparisons / bitwise: always bool / int
- Built-in call sites: large catalog of fixed return types
  (fibonacci -> int, sqrt -> float, str_uppercase -> string, etc.)

New typed-fast-path opcodes that skip the runtime is_float() check:
  Op::AddInt, Op::SubInt, Op::MulInt
  Op::AddFloat, Op::SubFloat, Op::MulFloat

Compiler emits these in place of polymorphic Op::Add etc. when BOTH
operands' inferred types match. The constant folder learned to fold
the typed variants too — `1 + 2 + 3` with both operands int still
folds end-to-end.

CompiledFunction gained param_types: Vec<Option<String>> and
return_type: Option<String> so cross-function type info survives
into the compiled module (useful for future passes and debugging).

## Consistency fix
Tree-walk is_fibonacci() now returns HInt(0)/HInt(1) instead of Bool,
matching the VM's Op::IsFibonacci and the canonical Python OMC idiom
`if is_fibonacci(x) == 1`. Both paths now agree on the wire format.

## Tests
125 passing across the workspace (was 118). +7 new unit tests in
bytecode_opt::tests for the caching pass:
- caches_resonance_of_constant
- caches_phi_fold_of_constant
- caches_fibonacci_of_constant
- caches_is_fibonacci_of_constant
- caches_unary_minus_of_constant
- caches_bitnot_of_constant
- chains_unary_cache_then_constant_fold

## Compatibility
Canonical sweep still 22/30 in both tree-walk and VM. No regressions.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: RandomCoder-lab

CHANGELOG.md

@@ -4,6 +4,40 @@ All notable changes to OMNIcode will be documented in this file.
 
 ## [Unreleased]
 
+### Added (Phase L + M: resonance caching + typed HIR, 2026-05-13)
+
+**Phase L — Resonance / portal caching**
+New `unary_cache_pass` in `bytecode_opt.rs`. Folds pure-unary harmonic ops on constants at compile time, before the constant folder runs (so subsequent chained arithmetic sees a single constant):
+
+- `LoadConst(N); Resonance` → `LoadConst(precomputed_float)` — `res(89)` becomes the literal `1.0`
+- `LoadConst(N); Fold1` → `LoadConst(snapped_int)` — `phi.fold(90)` becomes `89`
+- `LoadConst(N); IsFibonacci` → `LoadConst(1 or 0)`
+- `LoadConst(N); Fibonacci` → `LoadConst(fib(N))`
+- `LoadConst(N); HimScore` → `LoadConst(precomputed_float)`
+- `LoadConst(N); Neg` / `BitNot` / `Not` → precomputed inverse
+
+New stats counter `unary_calls_cached`. The omnicc Python compiler calls this "resonance caching"; same semantics, scoped to bytecode. Mixed example: `res(89) + 0.5` folds in two passes — cache `res(89) → 1.0`, then fold `1.0 + 0.5 → 1.5` — collapsing two ops to a single LoadConst.
+
+**Phase M — Typed HIR with specialized dispatch**
+
+The compiler now tracks a `var_types: HashMap<String, &'static str>` populated from:
+- Typed function parameters (`fn add(x: int, y: int)`)
+- Return-type annotations of user-defined functions (looked up across boundaries)
+- Variable declarations whose value's type is statically known (`h x = 89;` ⇒ int)
+- Arithmetic on known-typed operands (int + int ⇒ int)
+- Comparisons and bitwise ops (always bool / int)
+- Built-in function call sites with fixed return types
+
+New typed-fast-path opcodes that skip the runtime `is_float()` check:
+- `Op::AddInt`, `Op::SubInt`, `Op::MulInt`
+- `Op::AddFloat`, `Op::SubFloat`, `Op::MulFloat`
+
+The compiler emits these in place of polymorphic `Op::Add` / `Op::Sub` / `Op::Mul` when **both** operands' static types match. The optimizer's constant folder also knows them — `1 + 2 + 3` with both operands int folds through the typed path, then collapses to a single constant.
+
+`CompiledFunction` gained `param_types: Vec<Option<String>>` and `return_type: Option<String>` fields so cross-function type info is preserved through compilation.
+
+**Tests:** +7 unit tests for resonance caching (covers res, phi.fold, is_fibonacci, fibonacci, unary minus, bitnot, chained cache+fold). 125 total tests passing (was 118).
+
 ### Added (Phase K: bytecode optimizer, 2026-05-13)
 New module `omnimcode-core/src/bytecode_opt.rs`. Runs after compile, before VM execution. On by default in VM mode; disable with `OMC_OPT=0`. Show stats with `OMC_OPT_STATS=1`.
 

omnimcode-core/src/bytecode.rs

@@ -52,6 +52,16 @@ pub enum Op {
     Mod,
     Neg,
 
+    // Typed fast-path arithmetic: skip the runtime is_float() check when the
+    // compiler proves both operands are int-typed. Emitted by Phase M's HIR.
+    AddInt,
+    SubInt,
+    MulInt,
+    // Typed fast-path arithmetic for floats (both operands provably float).
+    AddFloat,
+    SubFloat,
+    MulFloat,
+
     Eq,
     Ne,
     Lt,
@@ -112,6 +122,12 @@ pub enum Op {
 pub struct CompiledFunction {
     pub name: String,
     pub params: Vec<String>,
+    /// Optional type annotation per parameter ("int" / "float" / "string" / "bool" / etc.)
+    /// Phase M: used by the compiler to specialize arithmetic on known-int args.
+    pub param_types: Vec<Option<String>>,
+    /// Optional return-type annotation. Used by the type-inference helper
+    /// when a call's return type is statically known.
+    pub return_type: Option<String>,
     pub ops: Vec<Op>,
     pub constants: Vec<Const>,
 }
@@ -129,6 +145,8 @@ impl Default for Module {
             main: CompiledFunction {
                 name: "__main__".to_string(),
                 params: Vec::new(),
+                param_types: Vec::new(),
+                return_type: None,
                 ops: Vec::new(),
                 constants: Vec::new(),
             },

omnimcode-core/src/bytecode_opt.rs

@@ -17,6 +17,9 @@ pub struct OptStats {
     pub dead_loads_removed: usize,
     pub double_nots_collapsed: usize,
     pub double_negs_collapsed: usize,
+    /// Pure-unary ops on constants folded: res(89), phi.fold(N), fibonacci(N),
+    /// is_fibonacci(N), HimScore(N), -N, !N, ~N, etc.
+    pub unary_calls_cached: usize,
 }
 
 impl OptStats {
@@ -25,6 +28,7 @@ impl OptStats {
             + self.dead_loads_removed
             + self.double_nots_collapsed
             + self.double_negs_collapsed
+            + self.unary_calls_cached
     }
 }
 
@@ -34,6 +38,10 @@ pub fn optimize_function(func: &mut CompiledFunction) -> OptStats {
     // Run passes until a fixpoint is reached. In practice 2-3 iterations.
     loop {
         let before = stats.total();
+        // Resonance caching FIRST — turns `LoadConst(89); Resonance` into a
+        // single constant, which the constant folder can then absorb into
+        // surrounding arithmetic.
+        unary_cache_pass(func, &mut stats);
         constant_fold_pass(func, &mut stats);
         dead_load_pass(func, &mut stats);
         double_unary_pass(func, &mut stats);
@@ -98,6 +106,83 @@ fn dead_load_pass(func: &mut CompiledFunction, stats: &mut OptStats) {
     }
 }
 
+/// Cache pure-unary harmonic ops on constants:
+///   LoadConst(N); Resonance   → LoadConst(precomputed_float)
+///   LoadConst(N); Fold1       → LoadConst(snapped_int)
+///   LoadConst(N); IsFibonacci → LoadConst(1 or 0)
+///   LoadConst(N); Fibonacci   → LoadConst(fib(N))
+///   LoadConst(N); HimScore    → LoadConst(precomputed_float)
+///   LoadConst(N); Neg         → LoadConst(-N)
+///   LoadConst(N); BitNot      → LoadConst(!N)
+///   LoadConst(B); Not         → LoadConst(!B)
+///
+/// These are pure functions of a single constant — they cannot fail and
+/// cannot observe runtime state. The omnicc Python compiler calls this
+/// "resonance caching"; same idea, scoped to bytecode.
+fn unary_cache_pass(func: &mut CompiledFunction, stats: &mut OptStats) {
+    let n = func.ops.len();
+    if n < 2 {
+        return;
+    }
+    for i in 0..(n - 1) {
+        let const_idx = match &func.ops[i] {
+            Op::LoadConst(idx) => *idx,
+            _ => continue,
+        };
+        let c = match func.constants.get(const_idx) {
+            Some(c) => c.clone(),
+            None => continue,
+        };
+        let result = match (&func.ops[i + 1], &c) {
+            (Op::Resonance, Const::Int(n)) => {
+                Some(Const::Float(crate::value::HInt::compute_resonance(*n)))
+            }
+            (Op::Resonance, Const::Float(f)) => Some(Const::Float(
+                crate::value::HInt::compute_resonance(*f as i64),
+            )),
+            (Op::Fold1, Const::Int(n)) => Some(Const::Int(fold_to_fib_const(*n))),
+            (Op::Fold1, Const::Float(f)) => Some(Const::Int(fold_to_fib_const(*f as i64))),
+            (Op::IsFibonacci, Const::Int(n)) => {
+                Some(Const::Int(if crate::value::is_fibonacci(*n) { 1 } else { 0 }))
+            }
+            (Op::Fibonacci, Const::Int(n)) => {
+                Some(Const::Int(crate::value::fibonacci(*n)))
+            }
+            (Op::HimScore, Const::Int(n)) => {
+                Some(Const::Float(crate::value::HInt::compute_him(*n)))
+            }
+            (Op::Neg, Const::Int(n)) => Some(Const::Int(-*n)),
+            (Op::Neg, Const::Float(f)) => Some(Const::Float(-*f)),
+            (Op::BitNot, Const::Int(n)) => Some(Const::Int(!*n)),
+            (Op::Not, Const::Bool(b)) => Some(Const::Bool(!*b)),
+            (Op::Not, Const::Int(n)) => Some(Const::Bool(*n == 0)),
+            _ => None,
+        };
+        if let Some(folded) = result {
+            let new_idx = func.constants.len();
+            func.constants.push(folded);
+            func.ops[i] = Op::Nop;
+            func.ops[i + 1] = Op::LoadConst(new_idx);
+            stats.unary_calls_cached += 1;
+        }
+    }
+}
+
+fn fold_to_fib_const(n: i64) -> i64 {
+    let fibs: [i64; 15] = [0, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610];
+    let abs_val = n.abs();
+    let mut nearest = fibs[0];
+    let mut min_dist = abs_val;
+    for &f in &fibs {
+        let d = (f - abs_val).abs();
+        if d < min_dist {
+            min_dist = d;
+            nearest = f;
+        }
+    }
+    if n < 0 { -nearest } else { nearest }
+}
+
 /// Collapse `Not; Not` (and similar double-unary ops) to no-op.
 fn double_unary_pass(func: &mut CompiledFunction, stats: &mut OptStats) {
     let n = func.ops.len();
@@ -131,9 +216,9 @@ fn fold_binary(a: &Const, b: &Const, op: &Op) -> Option<Const> {
         let af = const_to_float(a)?;
         let bf = const_to_float(b)?;
         return match op {
-            Op::Add => Some(Const::Float(af + bf)),
-            Op::Sub => Some(Const::Float(af - bf)),
-            Op::Mul => Some(Const::Float(af * bf)),
+            Op::Add | Op::AddFloat => Some(Const::Float(af + bf)),
+            Op::Sub | Op::SubFloat => Some(Const::Float(af - bf)),
+            Op::Mul | Op::MulFloat => Some(Const::Float(af * bf)),
             Op::Div => {
                 if bf == 0.0 {
                     None // can't fold div-by-zero (produces Singularity)
@@ -153,9 +238,9 @@ fn fold_binary(a: &Const, b: &Const, op: &Op) -> Option<Const> {
     let ai = const_to_int(a)?;
     let bi = const_to_int(b)?;
     match op {
-        Op::Add => Some(Const::Int(ai.wrapping_add(bi))),
-        Op::Sub => Some(Const::Int(ai.wrapping_sub(bi))),
-        Op::Mul => Some(Const::Int(ai.wrapping_mul(bi))),
+        Op::Add | Op::AddInt => Some(Const::Int(ai.wrapping_add(bi))),
+        Op::Sub | Op::SubInt => Some(Const::Int(ai.wrapping_sub(bi))),
+        Op::Mul | Op::MulInt => Some(Const::Int(ai.wrapping_mul(bi))),
         Op::Div => {
             if bi == 0 {
                 None
@@ -204,21 +289,21 @@ fn const_to_float(c: &Const) -> Option<f64> {
 
 pub fn optimize_module(module: &mut Module) -> OptStats {
     let mut total = OptStats::default();
-    let stats_main = optimize_function(&mut module.main);
-    total.constants_folded += stats_main.constants_folded;
-    total.dead_loads_removed += stats_main.dead_loads_removed;
-    total.double_nots_collapsed += stats_main.double_nots_collapsed;
-    total.double_negs_collapsed += stats_main.double_negs_collapsed;
+    accumulate(&mut total, optimize_function(&mut module.main));
     for (_, func) in module.functions.iter_mut() {
-        let s = optimize_function(func);
-        total.constants_folded += s.constants_folded;
-        total.dead_loads_removed += s.dead_loads_removed;
-        total.double_nots_collapsed += s.double_nots_collapsed;
-        total.double_negs_collapsed += s.double_negs_collapsed;
+        accumulate(&mut total, optimize_function(func));
     }
     total
 }
 
+fn accumulate(total: &mut OptStats, s: OptStats) {
+    total.constants_folded += s.constants_folded;
+    total.dead_loads_removed += s.dead_loads_removed;
+    total.double_nots_collapsed += s.double_nots_collapsed;
+    total.double_negs_collapsed += s.double_negs_collapsed;
+    total.unary_calls_cached += s.unary_calls_cached;
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -307,4 +392,97 @@ mod tests {
             .any(|c| matches!(c, Const::Bool(true))),
         );
     }
+
+    // ----- Phase L: resonance / portal caching -----
+
+    #[test]
+    fn caches_resonance_of_constant() {
+        // res(89) on a constant — 89 is Fibonacci so resonance = 1.0
+        let (m, stats) = compile_and_opt("h x = res(89);");
+        assert!(stats.unary_calls_cached >= 1);
+        assert!(m
+            .main
+            .constants
+            .iter()
+            .any(|c| matches!(c, Const::Float(f) if (f - 1.0).abs() < 1e-9)));
+    }
+
+    #[test]
+    fn caches_phi_fold_of_constant() {
+        // phi.fold(90) → 89 (snap to nearest Fibonacci)
+        let (m, stats) = compile_and_opt("h x = phi.fold(90);");
+        assert!(stats.unary_calls_cached >= 1);
+        assert!(m
+            .main
+            .constants
+            .iter()
+            .any(|c| matches!(c, Const::Int(89))));
+    }
+
+    #[test]
+    fn caches_fibonacci_of_constant() {
+        let (m, stats) = compile_and_opt("h x = fibonacci(10);");
+        assert!(stats.unary_calls_cached >= 1);
+        assert!(m
+            .main
+            .constants
+            .iter()
+            .any(|c| matches!(c, Const::Int(55))));
+    }
+
+    #[test]
+    fn caches_is_fibonacci_of_constant() {
+        let (m, stats) = compile_and_opt("h x = is_fibonacci(89);");
+        assert!(stats.unary_calls_cached >= 1);
+        assert!(m
+            .main
+            .constants
+            .iter()
+            .any(|c| matches!(c, Const::Int(1))));
+
+        let (m2, stats2) = compile_and_opt("h x = is_fibonacci(90);");
+        assert!(stats2.unary_calls_cached >= 1);
+        assert!(m2
+            .main
+            .constants
+            .iter()
+            .any(|c| matches!(c, Const::Int(0))));
+    }
+
+    #[test]
+    fn caches_unary_minus_of_constant() {
+        let (m, stats) = compile_and_opt("h x = -42;");
+        assert!(stats.unary_calls_cached >= 1 || stats.constants_folded >= 1);
+        // -42 should appear as a constant after folding (the parser desugars
+        // unary minus to `0 - 42`, which the constant folder reduces).
+        assert!(m
+            .main
+            .constants
+            .iter()
+            .any(|c| matches!(c, Const::Int(-42))));
+    }
+
+    #[test]
+    fn caches_bitnot_of_constant() {
+        let (m, stats) = compile_and_opt("h x = ~0;");
+        assert!(stats.unary_calls_cached >= 1);
+        assert!(m
+            .main
+            .constants
+            .iter()
+            .any(|c| matches!(c, Const::Int(-1))));
+    }
+
+    #[test]
+    fn chains_unary_cache_then_constant_fold() {
+        // res(89) folds to 1.0, then `1.0 + 0.5` folds to 1.5.
+        let (m, stats) = compile_and_opt("h x = res(89) + 0.5;");
+        assert!(stats.unary_calls_cached >= 1);
+        assert!(stats.constants_folded >= 1, "should fold the chained add");
+        assert!(m
+            .main
+            .constants
+            .iter()
+            .any(|c| matches!(c, Const::Float(f) if (f - 1.5).abs() < 1e-9)));
+    }
 }