Phase H.5.2: Op::SafeArrSetNamed — close the last safe keyword gap

The host-level `safe` keyword shipped yesterday (commit 6e1b5f4)
worked correctly through tree-walk but `safe arr_set(VAR, ...)`
compiled to bytecode lost the mutation when run through the Rust
VM — same shape gap V.7c originally closed for plain arr_set with
Op::ArrSetNamed.

The fix is structurally identical: take the variable name off the
value stack and put it on the opcode itself, bypassing
vm_call_builtin's synthetic-arg shim that copies array arguments.

  bytecode.rs:  New Op::SafeArrSetNamed(String) variant.
  vm.rs:        Dispatch handler — pop val, pop raw_idx, fold raw_idx
                onto nearest Fibonacci attractor via the new
                pub(crate) interpreter::fold_to_fibonacci_const,
                Euclidean-mod by arr_len, mutate, write back.
                Empty arrays silently drop the write (total semantics).
  compiler.rs:  Safe(Call("arr_set", [Variable, idx, val])) emits
                SafeArrSetNamed; non-Variable first arg falls through
                to Op::Call("safe_arr_set", 3) which still loses
                mutation (same semantics as plain arr_set on non-VAR).
  disasm.rs:    Disassembly format for the new op.
  interpreter.rs: fold_to_fibonacci_const promoted to pub(crate)
                  so vm.rs can call it.

Verified end-to-end: examples/safe_keyword_host.omc produces
identical output under tree-walk and OMC_VM=1. The Rust VM
disassembly shows `0027: SAFE_ARR_SET_NAMED xs` for the
`safe arr_set(xs, 999, 99)` call — the mutation lands at
xs[fold(999) % 3] = xs[1], propagating through VM scope correctly.

Phase H is now end-to-end clean on BOTH interpretation paths.
Self-healing semantics work the same way whether you're tree-
walking or compiling-and-running, for every documented shape:
safe divide, safe arr_get, safe arr_set.

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

Author: RandomCoder-lab

omnimcode-core/src/bytecode.rs

@@ -109,6 +109,13 @@ pub enum Op {
     /// Mutating array store: pop value, pop index, store at named array's
     /// index. Same rationale as ArrPushNamed.
     ArrSetNamed(String),
+    /// H.5.2: self-healing mutating array store. Pop value, pop raw_idx,
+    /// fold raw_idx onto the nearest Fibonacci attractor, Euclidean-mod by
+    /// arr_len, then store at the healed index. Out-of-bounds writes
+    /// become attractor-landing in-bounds writes. Same name-on-opcode trick
+    /// as ArrSetNamed — required so the mutation propagates back through
+    /// the VM scope instead of getting lost in vm_call_builtin's shim.
+    SafeArrSetNamed(String),
 
     // Special harmonic operations (short-circuit to built-in semantics
     // without the call overhead — these are the hot ones).

omnimcode-core/src/compiler.rs

@@ -437,10 +437,22 @@ impl Compiler {
                         self.emit(Op::Call("safe_arr_get".to_string(), 2));
                     }
                     Expression::Call { name, args } if name == "arr_set" && args.len() == 3 => {
-                        for arg in args {
-                            self.compile_expr(arg)?;
+                        // H.5.2: bare-VAR first arg → emit SafeArrSetNamed
+                        // so the mutation propagates back through VM scope.
+                        // Non-VAR shapes (e.g. nested array) fall through
+                        // to the synthetic-arg call shim, which loses the
+                        // mutation (same semantics as plain arr_set on a
+                        // non-VAR).
+                        if let Expression::Variable(arr_name) = &args[0] {
+                            self.compile_expr(&args[1])?; // index
+                            self.compile_expr(&args[2])?; // value
+                            self.emit(Op::SafeArrSetNamed(arr_name.clone()));
+                        } else {
+                            for arg in args {
+                                self.compile_expr(arg)?;
+                            }
+                            self.emit(Op::Call("safe_arr_set".to_string(), 3));
                         }
-                        self.emit(Op::Call("safe_arr_set".to_string(), 3));
                     }
                     _ => self.compile_expr(inner)?,
                 }

omnimcode-core/src/disasm.rs

@@ -75,6 +75,7 @@ fn op_mnemonic(op: &Op, ip: usize, constants: &[Const]) -> String {
         Op::ArrayIndexAssign(name) => format!("ARRAY_INDEX_ASSIGN {}", name),
         Op::ArrPushNamed(name) => format!("ARR_PUSH_NAMED  {}", name),
         Op::ArrSetNamed(name) => format!("ARR_SET_NAMED   {}", name),
+        Op::SafeArrSetNamed(name) => format!("SAFE_ARR_SET_NAMED {}", name),
 
         Op::Resonance => "RESONANCE".to_string(),
         Op::Fold1 => "FOLD".to_string(),

omnimcode-core/src/interpreter.rs

@@ -1843,7 +1843,7 @@ 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.
-fn fold_to_fibonacci_const(n: i64) -> i64 {
+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];

omnimcode-core/src/vm.rs

@@ -289,6 +289,32 @@ impl Vm {
                         ));
                     }
                 }
+                Op::SafeArrSetNamed(name) => {
+                    let val = stack.pop().ok_or("stack underflow")?;
+                    let raw_idx = stack.pop().ok_or("stack underflow")?.to_int();
+                    if let Some(Value::Array(mut a)) = self.interp.vm_get_var(name) {
+                        let len = a.items.len();
+                        if len > 0 {
+                            // Fold onto nearest Fibonacci attractor, then
+                            // Euclidean mod by len.
+                            let folded = crate::interpreter::fold_to_fibonacci_const(raw_idx);
+                            let len_i = len as i64;
+                            let mut healed = folded % len_i;
+                            if healed < 0 {
+                                healed += len_i;
+                            }
+                            a.items[healed as usize] = val;
+                            self.interp.vm_set_local(name, Value::Array(a));
+                        }
+                        // Empty arrays: silently drop the write (total
+                        // semantics — never errors).
+                    } else {
+                        return Err(format!(
+                            "SafeArrSetNamed: {} is not an array variable",
+                            name
+                        ));
+                    }
+                }
                 Op::ArrayIndexAssign(name) => {
                     let idx = stack.pop().ok_or("stack underflow")?.to_int() as usize;
                     let val = stack.pop().ok_or("stack underflow")?;