release: v1.8.2 — HBit real at the Value level (pervasive dual-band)

Phase 6 step 2: every value can now carry a β (harmonic-shadow) band that rides
alongside α through arithmetic. α is always the exact answer; β records harmonic drift.

value.rs: HInt gains `beta: Option<i64>` (None = single-band, byte-identical to before;
  Some = dual-band). with_beta() + Value::beta_band(). PartialEq unchanged (compares α).
interpreter.rs: db_int() threads β through Add/Sub/Mul/Div/Mod/Power — no-β path is exactly
  HInt::new(α), so ordinary code is unaffected (172/172 tests pass).
Builtins now real (were stubs): phi_shadow(v) attaches β = nearest Fibonacci attractor;
  harmony(v) = 1000·harmony(α,β). New: bands(v) -> [α,β], value_divergence(v).

Verified (valueband_demo.omc): phi_shadow(10)+3 -> bands [13,11]; (phi_shadow(50)+1)*3 ->
[153,105], divergence 933; result == 153 (α exact, β never alters).

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

Author: The Architect

Cargo.lock

@@ -21,7 +21,7 @@ exclude = ["omnimcode-python"]
 resolver = "2"
 
 [workspace.package]
-version = "1.8.1"
+version = "1.8.2"
 edition = "2021"
 authors = ["The Architect <architect@sovereign-lattice.io>"]
 license = "MIT"

Cargo.toml

@@ -655,3 +655,22 @@ PHASES 1-5 CONTINUATION (no-side-tracks pass, post-v1.8.0, 2026-05-30)
   domain (retrieve+compose+verify over a corpus); P1's correctness≈coverage is exact-retrieval (the
   held-out/composition gap — generalizing BEYOND the store — is still bounded by generator quality, but
   that too is CPU: grammar-gen + verify, not GPU). Task #43 (NEXT-7) DONE on CPU.
+
+PHASE 6 (step 2) — HBit REAL AT THE VALUE LEVEL [DONE + VERIFIED] (pervasive per-value dual-band)
+- value.rs: HInt gained `beta: Option<i64>` (β shadow band). None (default for ALL ordinary values)
+  = single-band, byte-identical to before. with_beta() constructor; Value::beta_band() accessor.
+  PartialEq still compares α only (no equality breakage). Only 2 struct literals touched; 413
+  HInt::new callers unaffected.
+- interpreter.rs: db_int() helper threads β through ALL six integer ops (Add/Sub/Mul/Div/Mod/Power):
+  NEITHER operand has β → exactly HInt::new(α) (unchanged); either has β → result β = op(lβ,rβ) with
+  α-fallback, div/mod zero-guarded. α is ALWAYS exact; β never alters a result — only records drift.
+- Builtins now REAL (were stubs): phi_shadow(v) attaches β = nearest Fibonacci attractor of α (was
+  identity); harmony(v) = 1000·harmony(α,β) if β present else 1000 (was constant 1000). NEW:
+  bands(v)->[α,β], value_divergence(v)->1000·(1-harmony).
+- VERIFIED (valueband_demo.omc): 7+3=10 harmony 1000 (single-band unchanged); phi_shadow(10) bands
+  [10,8]; phi_shadow(10)+3 → [13,11] (β rode through +); (phi_shadow(50)+1)*3 → [153,105],
+  value_divergence 933 (off-lattice); w==153 true (α exact). 172/172 core tests pass — the additive
+  Option<i64> field changed nothing for non-shadowed values.
+- The user's HBit dual-band model [[omc_hbit_dualband_vision]] made pervasive at the Value level:
+  every value CAN carry its β shadow, it propagates through arithmetic, divergence readable anywhere,
+  α always correct. Next horizons: value-granular SKIP form, then kernel/microcode HBit.

experiments/transformerless_lm/AUTONOMOUS_LOG.md

@@ -0,0 +1,23 @@
+// Phase 6 — HBit real at the VALUE level: β shadow rides through arithmetic.
+print("-- ordinary values are single-band (β = α): unchanged behavior --");
+h x = 7 + 3;
+print(x);                       // 10
+print(harmony(x));              // 1000 (in tune with itself — no shadow)
+
+print("-- phi_shadow attaches the harmonic shadow band; it then RIDES through math --");
+h s = phi_shadow(10);           // α=10, β=nearest attractor of 10 = 8
+print(bands(s));                // [10, 8]
+h t = s + 3;                    // α=13, β=8+3=11  (β propagated through +)
+print(bands(t));                // [13, 11]
+print(value_divergence(t));     // drift of 13 vs 11 (|13-11|=2 is on-lattice → low)
+
+print("-- a chain that DRIFTS off the lattice raises divergence --");
+h u = phi_shadow(8) * 7;        // α=56, β=8*7=56 ... both same here
+print(bands(u));                // [56, 56]
+print(value_divergence(u));     // 0 (stayed in tune)
+h w = (phi_shadow(50) + 1) * 3; // α: (50+1)*3=153 ; β: (34+1)*3=105
+print(bands(w));                // [153, 105]
+print(value_divergence(w));     // > 0 (drifted — α is the truth, β shows lattice path)
+
+print("-- α is ALWAYS the exact answer; β never changes a result --");
+print(w == 153);                // true

experiments/transformerless_lm/valueband_demo.omc

@@ -2104,7 +2104,7 @@ impl Interpreter {
                 } else if lv.is_float() || rv.is_float() {
                     Ok(Value::HFloat(lv.to_float() + rv.to_float()))
                 } else {
-                    Ok(Value::HInt(HInt::new(lv.to_int().wrapping_add(rv.to_int()))))
+                    Ok(db_int(&lv, &rv, lv.to_int().wrapping_add(rv.to_int()), |a, b| a.wrapping_add(b)))
                 }
             }
             Expression::Sub(l, r) => {
@@ -2113,7 +2113,7 @@ impl Interpreter {
                 if lv.is_float() || rv.is_float() {
                     Ok(Value::HFloat(lv.to_float() - rv.to_float()))
                 } else {
-                    Ok(Value::HInt(HInt::new(lv.to_int().wrapping_sub(rv.to_int()))))
+                    Ok(db_int(&lv, &rv, lv.to_int().wrapping_sub(rv.to_int()), |a, b| a.wrapping_sub(b)))
                 }
             }
             Expression::Mul(l, r) => {
@@ -2122,7 +2122,7 @@ impl Interpreter {
                 if lv.is_float() || rv.is_float() {
                     Ok(Value::HFloat(lv.to_float() * rv.to_float()))
                 } else {
-                    Ok(Value::HInt(HInt::new(lv.to_int().wrapping_mul(rv.to_int()))))
+                    Ok(db_int(&lv, &rv, lv.to_int().wrapping_mul(rv.to_int()), |a, b| a.wrapping_mul(b)))
                 }
             }
             Expression::Div(l, r) => {
@@ -2148,7 +2148,7 @@ impl Interpreter {
                             context: "div".to_string(),
                         })
                     } else {
-                        Ok(Value::HInt(HInt::new(lv.to_int() / divisor)))
+                        Ok(db_int(&lv, &rv, lv.to_int() / divisor, |a, b| if b == 0 { 0 } else { a / b }))
                     }
                 }
             }
@@ -2167,7 +2167,7 @@ impl Interpreter {
                     if divisor == 0 {
                         Ok(Value::HInt(HInt::new(0)))
                     } else {
-                        Ok(Value::HInt(HInt::new(lv.to_int() % divisor)))
+                        Ok(db_int(&lv, &rv, lv.to_int() % divisor, |a, b| if b == 0 { 0 } else { a % b }))
                     }
                 }
             }
@@ -2181,7 +2181,7 @@ impl Interpreter {
                     if e < 0 {
                         Ok(Value::HFloat((bv.to_int() as f64).powi(e as i32)))
                     } else {
-                        Ok(Value::HInt(HInt::new(bv.to_int().pow(e as u32))))
+                        Ok(db_int(&bv, &ev, bv.to_int().pow(e as u32), |a, b| a.wrapping_pow(b.max(0) as u32)))
                     }
                 }
             }
@@ -2512,6 +2512,8 @@ impl Interpreter {
             | "gen_omc" | "gen_at"
             // HBit dual-band gate (Phase 6) — real two-band resonance/divergence
             | "hbit_harmony" | "hbit_divergence" | "band_divergence" | "band_route"
+            // Value-level dual-band (Phase 6 — HBit real at the Value level)
+            | "bands" | "value_divergence"
             // Traced variants — return [result, probe_indices_array]
             | "phi_pi_fib_search_traced" | "phi_pi_fib_nearest_traced"
             // Split-channel stats (explicit vs background substrate work)
@@ -11666,34 +11668,64 @@ impl Interpreter {
             // observation" so subsequent ops carry both bands through
             // computation. A later harmony() check decides whether
             // the value is behaving as predicted.
+            // phi_shadow(value) — Phase 6: HBit real at the Value level. Attaches the harmonic
+            // SHADOW band β = nearest Fibonacci attractor of α. The returned value carries BOTH
+            // bands: α (the exact value, unchanged) and β (the "on-lattice" companion). β then
+            // rides alongside α through arithmetic (db_int); harmony()/band_divergence() read the
+            // accumulated α/β drift. Was an identity stub; now the real dual-band entry point.
             "phi_shadow" => {
                 if args.is_empty() {
                     return Err("phi_shadow requires (value)".to_string());
                 }
                 let v = self.eval_expr(&args[0])?;
-                Ok(v)
-            }
-            // harmony(x) - HBit harmony reading.
-            //
-            // Tree-walk semantics: returns 1000 unconditionally. With
-            // no β to compare against, harmony is trivially perfect.
-            // The value's semantic content fits this — in tree-walk
-            // mode, "harmony" can be read as "agreement between α and
-            // α" which is always exact.
-            //
-            // Dual-band JIT semantics (omnimcode-codegen, Session G):
-            // intercepted as an intrinsic that emits a call to the
-            // extern Rust helper computing harmony from the two lanes.
-            //
-            // Return convention: i64 in [0, 1000]. 1000 = perfect
-            // harmony, 0 = maximally divergent. Floats avoided to
-            // keep the calling convention pure-i64.
+                let a = v.to_int();
+                let (att, _) = crate::phi_pi_fib::nearest_attractor_with_dist(a);
+                Ok(Value::HInt(HInt::with_beta(a, att)))
+            }
+            // harmony(x) -> int 0..1000 — Phase 6: REAL dual-band reading. If x carries a β shadow
+            // (from phi_shadow + dual-band arithmetic), returns 1000·harmony(α,β) = how in-tune the
+            // computation stayed with the attractor lattice. If single-band (no β), returns 1000
+            // (a value is in perfect harmony with itself). Was a constant 1000 stub.
             "harmony" => {
                 if args.is_empty() {
                     return Err("harmony requires (value)".to_string());
                 }
-                let _ = self.eval_expr(&args[0])?;
-                Ok(Value::HInt(HInt::new(1000)))
+                let v = self.eval_expr(&args[0])?;
+                match v.beta_band() {
+                    Some(b) => {
+                        let h = crate::value::HBit::harmony(v.to_int(), b);
+                        Ok(Value::HInt(HInt::new((h * 1000.0).round() as i64)))
+                    }
+                    None => Ok(Value::HInt(HInt::new(1000))),
+                }
+            }
+            // bands(x) -> [α, β] — Phase 6: inspect both bands of a value. β = α when single-band.
+            "bands" => {
+                if args.is_empty() {
+                    return Err("bands requires (value)".to_string());
+                }
+                let v = self.eval_expr(&args[0])?;
+                let a = v.to_int();
+                let b = v.beta_band().unwrap_or(a);
+                Ok(Value::Array(HArray::from_vec(vec![
+                    Value::HInt(HInt::new(a)),
+                    Value::HInt(HInt::new(b)),
+                ])))
+            }
+            // value_divergence(x) -> int 0..1000 — Phase 6: the per-value drift = 1000·(1-harmony).
+            // 0 = on the lattice (trust the β skip); high = dissonant (α is the truth). The gate.
+            "value_divergence" => {
+                if args.is_empty() {
+                    return Err("value_divergence requires (value)".to_string());
+                }
+                let v = self.eval_expr(&args[0])?;
+                match v.beta_band() {
+                    Some(b) => {
+                        let h = crate::value::HBit::harmony(v.to_int(), b);
+                        Ok(Value::HInt(HInt::new(((1.0 - h) * 1000.0).round() as i64)))
+                    }
+                    None => Ok(Value::HInt(HInt::new(0))),
+                }
             }
             // phi_pi_fib_search_v2(sorted_arr, target) -> int
             //   F(k)/φ^(π·k) split-point search. Same return convention
@@ -15633,6 +15665,23 @@ pub(crate) fn stmts_contain_return(stmts: &[Statement]) -> bool {
     false
 }
 
+/// Dual-band integer arithmetic (Phase 6 — HBit real at the Value level). When NEITHER operand
+/// carries a β shadow (the default for all ordinary values), returns exactly `HInt::new(alpha)` —
+/// byte-identical to single-band behavior. When either carries β, the shadow rides alongside:
+/// result β = op(lβ, rβ), with missing bands falling back to the operand's α. α is ALWAYS the exact
+/// answer the caller already computed; β never alters it — it only records harmonic drift.
+#[inline]
+fn db_int(lv: &Value, rv: &Value, alpha: i64, op: impl Fn(i64, i64) -> i64) -> Value {
+    match (lv.beta_band(), rv.beta_band()) {
+        (None, None) => Value::HInt(HInt::new(alpha)),
+        (lb, rb) => {
+            let la = lb.unwrap_or_else(|| lv.to_int());
+            let ra = rb.unwrap_or_else(|| rv.to_int());
+            Value::HInt(HInt::with_beta(alpha, op(la, ra)))
+        }
+    }
+}
+
 /// Builtins whose evaluation has a side effect or is nondeterministic. `@memo`
 /// refuses a function that directly calls any of these (best-effort purity gate).
 const MEMO_IMPURE: &[&str] = &[
@@ -15979,6 +16028,7 @@ pub(crate) const HEAL_BUILTIN_NAMES: &[&str] = &[
     "gen_omc", "gen_at",
     // HBit dual-band gate (Phase 6)
     "hbit_harmony", "hbit_divergence", "band_divergence", "band_route",
+    "bands", "value_divergence",
     "phi_pi_fib_search_traced", "phi_pi_fib_nearest_traced",
     "phi_pi_fib_stats_bg", "phi_pi_fib_stats_all",
     // HBit dual-band intrinsics (Sessions F+G)

omnimcode-core/src/interpreter.rs

@@ -14,6 +14,12 @@ pub struct HInt {
     pub resonance: f64,
     pub him_score: f64,
     pub is_singularity: bool,
+    /// β band (Phase 6): the harmonic SHADOW of this value — the "what if we'd stayed on the
+    /// Fibonacci attractor lattice" companion. `None` (the default for all ordinary values)
+    /// means single-band: behaves EXACTLY as before. `Some(β)` is attached by `phi_shadow` and
+    /// rides alongside α through arithmetic; `harmony`/`band_divergence` read the α/β drift.
+    /// α (the `value` field) is ALWAYS the exact answer — β never changes a result.
+    pub beta: Option<i64>,
 }
 
 impl HInt {
@@ -26,9 +32,18 @@ impl HInt {
             resonance,
             him_score,
             is_singularity: false,
+            beta: None,
         }
     }
 
+    /// Construct a dual-band HInt: exact α `value` + harmonic shadow `beta` (Phase 6).
+    #[inline]
+    pub fn with_beta(value: i64, beta: i64) -> Self {
+        let mut h = Self::new(value);
+        h.beta = Some(beta);
+        h
+    }
+
     /// Compute resonance (0-1) based on distance to nearest Fibonacci number.
     ///
     /// Substrate-routed: goes through `phi_pi_fib::nearest_attractor_with_dist`,
@@ -66,6 +81,7 @@ impl HInt {
             resonance: 0.0,
             him_score: 0.0,
             is_singularity: true,
+            beta: None,
         }
     }
 }
@@ -344,6 +360,16 @@ impl Value {
         h
     }
 
+    /// The β (harmonic-shadow) band of this value, if it carries one (Phase 6). Only dual-band
+    /// HInts (created via phi_shadow / dual-band arithmetic) return Some; everything else is None.
+    #[inline]
+    pub fn beta_band(&self) -> Option<i64> {
+        match self {
+            Value::HInt(h) => h.beta,
+            _ => None,
+        }
+    }
+
     #[inline]
     pub fn to_int(&self) -> i64 {
         match self {