Substrate refactor: route compute_resonance and friends through phi_pi_fib

The foundational harmonic ops now use the canonical FIBONACCI table
and phi_pi_fib's Fibonacci-step search instead of duplicated local
arrays + linear scans. New surface in phi_pi_fib.rs:

  nearest_attractor_with_dist(value: i64) -> (i64, i64)
      The canonical "snap to nearest attractor" primitive.
      Sign-preserving, tie-break to lower (matches old linear-scan
      semantics). Returns (nearest, |value - nearest|).

  fold_to_nearest_attractor(value: i64) -> i64
      Discards the distance.

  is_on_fibonacci_attractor(value: i64) -> bool
      True iff distance is 0.

Four foundational call sites refactored:

  value.rs::HInt::compute_resonance      — was 16-element linear scan
  value.rs::is_fibonacci                  — was 20-element .contains()
  interpreter.rs::fold_to_fibonacci_const — was 15-element linear scan
  interpreter.rs::is_on_fibonacci_attractor — was 15-element .any()

These were 4 of the 17+ duplicate Fibonacci tables across the
codebase. The remaining ~13 (inline `fibs:` arrays in interpreter.rs
builtin bodies, vm.rs hot path, bytecode_opt.rs) are mechanical
replacements and will follow in a separate commit so the diff stays
reviewable.

Semantic changes:

  - For |value| <= 610: byte-identical to the old behavior. All 92
    conformance tests pass.
  - For |value| > 610: STRICTLY MORE ACCURATE. The old 16-element
    table saturated at 610 (giving res(1000) = 0.610). The canonical
    40-element table extends to 63,245,986, so res(1000) = 0.987
    (nearest attractor is 987, distance 13). Nothing in the test
    suite or examples depended on the saturation.

Substrate-coherence implication:

  Every HInt::new() in OMC now routes its nearest-attractor lookup
  through the phi_pi_fib Fibonacci-step search. Per experiment 9,
  that's 90% step-coherent (step sizes are F(k) by construction)
  versus the old linear scan's degenerate 100% (every step F_1 = 1,
  no information used). The foundational op now describes itself
  in the substrate's native vocabulary.

Counter side effect:

  phi_pi_fib_stats() now reflects TOTAL substrate work across the
  whole program (every HInt construction bumps the counter), not
  just explicit phi_pi_fib_search calls. That's a more honest
  measurement of substrate load but changes the interpretation of
  prior experiments' compare-per-search numbers — exp 7's "gate
  work" went from 24 compares to 857 because the counter now
  includes the background HInt construction work the gate triggers.
  Flagged for a follow-up that either splits the counter or
  snapshots it more carefully in experiments.

148/148 tests pass. Both engines audit byte-identical on both
exp 7 (2712 bytes) and exp 9 (3117 bytes).

Author: claude

omnimcode-core/src/interpreter.rs

@@ -5070,30 +5070,17 @@ fn values_equal(a: &Value, b: &Value) -> bool {
 // Free function reused by quantize / quantization_ratio / mean_omni_weight.
 // Snap |n| to the nearest Fibonacci attractor, preserving sign.
 pub(crate) fn fold_to_fibonacci_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 }
+    // Substrate-routed via phi_pi_fib::fold_to_nearest_attractor.
+    // Was: a 15-element local Fibonacci array + linear scan.
+    crate::phi_pi_fib::fold_to_nearest_attractor(n)
 }
 
 // Used by the host-side healer in heal_ast. Tests whether `n` falls on
-// the Fibonacci attractor table — same set as fold_to_fibonacci_const.
-// Renamed from `is_fibonacci` because `value.rs` already exports a
-// public function by that name (operating on i64 too — semantically
-// equivalent, but we keep a local copy here so the heal pass doesn't
-// depend on value.rs internals).
+// the Fibonacci attractor table. Substrate-routed via
+// phi_pi_fib::is_on_fibonacci_attractor — same canonical table as
+// every other harmonic op now uses.
 pub(crate) fn is_on_fibonacci_attractor(n: i64) -> bool {
-    let fibs: [i64; 15] = [0, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610];
-    let abs_n = n.abs();
-    fibs.iter().any(|&f| f == abs_n)
+    crate::phi_pi_fib::is_on_fibonacci_attractor(n)
 }
 
 // Levenshtein edit distance for the heal-pass typo correction. Returns

omnimcode-core/src/phi_pi_fib.rs

@@ -314,6 +314,65 @@ pub fn binary_search<T>(
     Err(low)
 }
 
+/// nearest_attractor_with_dist(value) — the canonical
+/// "snap to nearest Fibonacci attractor" operation for the OMC
+/// substrate. Returns (nearest_attractor, |value - nearest|).
+/// Sign-preserving: negative inputs return negative attractors.
+///
+/// Backed by `fibonacci_search` over the canonical FIBONACCI table
+/// (40 entries up to 63,245,986). Used by `HInt::compute_resonance`,
+/// `fold_to_fibonacci_const`, `is_on_fibonacci_attractor`, and every
+/// other site in OMC that needs to fold a value to the attractor
+/// lattice.
+///
+/// Tie-break: when two attractors are equidistant, the LOWER one wins
+/// (matches the original linear-scan semantics: first match in
+/// ascending order).
+pub fn nearest_attractor_with_dist(value: i64) -> (i64, i64) {
+    let abs_v = value.abs();
+    if abs_v == 0 {
+        return (0, 0);
+    }
+    let target = abs_v as u64;
+    let r = fibonacci_search(FIBONACCI, &target, |a, b| {
+        if a < b { -1 } else if a > b { 1 } else { 0 }
+    });
+    let (nearest_abs, min_dist): (i64, i64) = match r {
+        Ok(i) => (FIBONACCI[i] as i64, 0),
+        Err(insert_pos) => {
+            let n = FIBONACCI.len();
+            if insert_pos == 0 {
+                let f = FIBONACCI[0] as i64;
+                (f, (abs_v - f).abs())
+            } else if insert_pos >= n {
+                let f = FIBONACCI[n - 1] as i64;
+                (f, (abs_v - f).abs())
+            } else {
+                let left = FIBONACCI[insert_pos - 1] as i64;
+                let right = FIBONACCI[insert_pos] as i64;
+                let left_d = (abs_v - left).abs();
+                let right_d = (right - abs_v).abs();
+                if left_d <= right_d { (left, left_d) } else { (right, right_d) }
+            }
+        }
+    };
+    let signed = if value < 0 { -nearest_abs } else { nearest_abs };
+    (signed, min_dist)
+}
+
+/// fold_to_nearest_attractor(value) — sign-preserving fold to the
+/// closest Fibonacci attractor. Wrapper around
+/// `nearest_attractor_with_dist` that discards the distance.
+pub fn fold_to_nearest_attractor(value: i64) -> i64 {
+    nearest_attractor_with_dist(value).0
+}
+
+/// is_on_fibonacci_attractor(value) — true iff |value| is exactly a
+/// Fibonacci number in the canonical attractor table.
+pub fn is_on_fibonacci_attractor(value: i64) -> bool {
+    nearest_attractor_with_dist(value).1 == 0
+}
+
 /// log_phi_pi_fibonacci(n) — the theoretical compare-count bound for
 /// the phi_pi_fib_search_v2 algorithm.
 ///

omnimcode-core/src/value.rs

@@ -28,20 +28,20 @@ impl HInt {
         }
     }
 
-    /// Compute resonance (0-1) based on distance to nearest Fibonacci number
+    /// Compute resonance (0-1) based on distance to nearest Fibonacci number.
+    ///
+    /// Substrate-routed: goes through `phi_pi_fib::nearest_attractor_with_dist`,
+    /// which uses the canonical 40-entry FIBONACCI table and a
+    /// Fibonacci-step search. Replaces a 16-element local linear scan
+    /// that used to live here.
+    ///
+    /// Semantics are preserved for |value| <= 610 (the range the old
+    /// local table covered). For |value| > 610 the new resonance is
+    /// MORE accurate — the old table saturated at 610, scoring large
+    /// inputs unfairly low; the new one extends to 63,245,986.
     pub fn compute_resonance(value: i64) -> f64 {
-        let fibs: [i64; 16] = [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610];
+        let (_nearest, min_dist) = crate::phi_pi_fib::nearest_attractor_with_dist(value);
         let abs_val = value.abs();
-        
-        // Find nearest Fibonacci
-        let mut min_dist = i64::MAX;
-        for &f in &fibs {
-            let d = (f - abs_val).abs();
-            if d < min_dist {
-                min_dist = d;
-            }
-        }
-        
         if min_dist == 0 {
             1.0
         } else {
@@ -439,12 +439,14 @@ pub fn fibonacci(n: i64) -> i64 {
     b
 }
 
-/// Check if a number is Fibonacci
+/// Check if a number is Fibonacci.
+///
+/// Substrate-routed via `phi_pi_fib::is_on_fibonacci_attractor` —
+/// goes through the canonical FIBONACCI table (40 entries) and the
+/// Fibonacci-step search. Replaces a 20-element local array that
+/// used to live here.
 pub fn is_fibonacci(n: i64) -> bool {
-    let fibs: [i64; 20] = [
-        0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181,
-    ];
-    fibs.contains(&n)
+    crate::phi_pi_fib::is_on_fibonacci_attractor(n)
 }
 
 #[cfg(test)]