Phase H.5.1: close the safe arr_set bytecode-VM gap

examples/self_healing_h5.omc — `safe arr_set(VAR, idx, val)` now
works through the OMC bytecode VM, not just under tree-walk.

The gap: H.5 emitted `CALL_BUILTIN safe_arr_set` for safe-wrapped
array writes. The bytecode VM's CALL_BUILTIN handler routes
through a synthetic-scope shim (vm_call_builtin → __vm_arg_N
synthetic Variables) that copies the array argument, so the
mutation lived in a temp scope and never propagated back to the
caller's binding.

The fix is the exact pattern V.7c used for ARR_SET_NAMED: take
the variable name out of the value stack and put it on the opcode.

Encoder change:
  - SAFE_EXPR branch's arr_set handler now detects bare-VAR first
    arg and emits SAFE_ARR_SET_NAMED varname (after pushing idx
    and val). Falls back to CALL_BUILTIN for non-VAR shapes
    (e.g. nested-array writes), which is no-mutation by design.

Executor change:
  - New SAFE_ARR_SET_NAMED handler: pop val, pop raw_idx, look up
    arr in current scope by name. Compute healed index via
    nearest_fib (already in the file) and Euclidean mod by
    arr_len. arr_set on the local clone, scope_set writes back.
    Leaves the (mutated) array on the value stack as result.

New demo 4b: `safe arr_set(buf, idx, val)` on a 5-element zero
buffer with idx ∈ {0, 100, -1, 6}. Result: [55, 13, 0, 0, 34] —
every write landed at the fold-and-mod position, every output
has φ=1.000.

Six demos, six convergences. The "known limit" note in the
observation block is replaced with a description of how the
gap was closed.

The Rust VM doesn't need this fix because it already has
ArrSetNamed; H.5's tree-walk path also already worked (it just
didn't reach the bytecode VM). H.5.1 specifically closes the
OMC-written-executor path.

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

Author: RandomCoder-lab

examples/self_healing_h5.omc

@@ -811,6 +811,21 @@ fn enc_expr(ast) {
             }
             if name == "arr_set" {
                 if arr_len(args) == 3 {
+                    # H.5.1: when the array argument is a bare VAR, emit
+                    # SAFE_ARR_SET_NAMED so the mutation propagates back
+                    # through the bytecode VM's scope (same trick V.7c
+                    # used for ARR_SET_NAMED). Without this, CALL_BUILTIN
+                    # routes through a synthetic-scope shim that copies
+                    # the array argument and loses the write.
+                    h target = arr_get(args, 0);
+                    if arr_get(target, 0) == "VAR" {
+                        out = arr_concat(out, enc_expr(arr_get(args, 1)));  # idx
+                        out = arr_concat(out, enc_expr(arr_get(args, 2)));  # val
+                        arr_push(out, ["SAFE_ARR_SET_NAMED", arr_get(target, 1)]);
+                        return out;
+                    }
+                    # Fallback: not a bare VAR (e.g. nested array). Goes
+                    # through CALL_BUILTIN — works under tree-walk only.
                     out = arr_concat(out, enc_expr(arr_get(args, 0)));
                     out = arr_concat(out, enc_expr(arr_get(args, 1)));
                     out = arr_concat(out, enc_expr(arr_get(args, 2)));
@@ -1244,6 +1259,31 @@ fn execute(prog) {
                 pc = pc + 1;
                 handled = 1;
             }
+            if kind == "SAFE_ARR_SET_NAMED" {
+                # H.5.1: like ARR_SET_NAMED but fold-and-mod the index so
+                # an out-of-bounds write becomes an in-bounds write at the
+                # nearest Fibonacci-attractor position. The named-store
+                # form is required (vs CALL_BUILTIN safe_arr_set) because
+                # the bytecode VM's CALL_BUILTIN shim copies array args
+                # and loses the mutation.
+                h pr1 = pop1(stack); h val = arr_get(pr1, 0); stack = arr_get(pr1, 1);
+                h pr2 = pop1(stack); h raw_idx = arr_get(pr2, 0); stack = arr_get(pr2, 1);
+                h name = arr_get(op, 1);
+                h arr = scope_get(scope, name);
+                h len = arr_len(arr);
+                if len > 0 {
+                    h folded = nearest_fib(raw_idx);
+                    # Euclidean mod — OMC's % can return negatives for
+                    # negative operands; this normalises into [0, len).
+                    h healed = folded - (folded / len) * len;
+                    if healed < 0 { healed = healed + len; }
+                    arr_set(arr, healed, val);
+                    scope = scope_set(scope, name, arr);
+                }
+                arr_push(stack, arr);
+                pc = pc + 1;
+                handled = 1;
+            }
             if kind == "MAKE_ARR" {
                 h len = to_int(arr_get(op, 1));
                 h pr = pop_n_ordered(stack, len);
@@ -2246,12 +2286,10 @@ print(lookup(xs, 7));";
 h outcome_3 = run_h3("Demo 3 (with safe): arr_get with various OOB indices",
                      GUARDED_ARRAY, 5);
 
-# -------- Demo 4: safe arr_get inside a loop walking off the end -----------
-# Walk indices 0 through 9 against a 5-element array. Without `safe`, the
-# loop crashes at idx=5. With `safe`, every iteration produces a finite
-# value via fold-and-mod. The wrap is deterministic, so the second pass
-# (idx=5..9) traces a pattern through the array driven by the Fibonacci
-# attractor structure.
+# -------- Demo 4a: safe arr_get inside a loop walking off the end ----------
+# Walk indices 0 through 9 against a 5-element array via safe arr_get.
+# Every iteration produces a finite, attractor-landing value via fold-
+# and-mod. Confirms reads compose cleanly via the bytecode VM.
 
 h SAFE_WALK = "fn read(xs, idx) {
     return safe arr_get(xs, idx);
@@ -2263,9 +2301,36 @@ while i < 10 {
     i = i + 1;
 }";
 
-h outcome_4 = run_h3("Demo 4: safe arr_get walking off the end",
+h outcome_4 = run_h3("Demo 4a: safe arr_get walking off the end",
                      SAFE_WALK, 5);
 
+# -------- Demo 4b: safe arr_set with H.5.1 named-store op ------------------
+# Treat a 5-element buffer as a circular write target. Each `safe arr_set`
+# call folds the index onto the nearest Fibonacci attractor and modulos
+# by arr_len, then mutates. The encoder emits SAFE_ARR_SET_NAMED (not
+# CALL_BUILTIN safe_arr_set) when the first arg is a bare VAR, so the
+# mutation propagates back through the bytecode VM's scope.
+#   idx=0   → fold to 0 → 1 (no-zero rule) → buf[1] = 11.
+#       But fold_to_fibonacci_const(0) returns 0; nearest_fib in OMC has
+#       the no-zero rule which makes it 1. So writes target index 1.
+#   idx=100 → fold to 89 → 89 % 5 = 4 → buf[4] = 22.
+#   idx=-1  → fold to -1 → fold inside nearest_fib gives -1; (-1 - (-1/5)*5) = -1; +5 = 4 → buf[4] = 33 (overwrites).
+#   idx=6   → fold to 5 → 5 % 5 = 0 → buf[0] = 55 (matches the 55 in original list, harmonic).
+
+h SAFE_SET = "h buf = [0, 0, 0, 0, 0];
+safe arr_set(buf, 0, 11);
+safe arr_set(buf, 100, 22);
+safe arr_set(buf, 0 - 1, 33);
+safe arr_set(buf, 6, 55);
+h i = 0;
+while i < arr_len(buf) {
+    print(arr_get(buf, i));
+    i = i + 1;
+}";
+
+h outcome_4b = run_h3("Demo 4b: safe arr_set (H.5.1 named-store op)",
+                      SAFE_SET, 5);
+
 # -------- Demo 5: composed with H.4 in one program -------------------------
 # Both `safe a/b` and `safe arr_get(a, i)` in the same function. The
 # program survives both a singular divisor and an OOB index.
@@ -2288,8 +2353,9 @@ print("############################################################");
 print(concat_many("  Demo 1 (H.4 regression):       ", outcome_1));
 print(concat_many("  Demo 2 (no safe arr_get):      ", outcome_2));
 print(concat_many("  Demo 3 (safe arr_get OOB):     ", outcome_3));
-print(concat_many("  Demo 4 (safe arr_get loop):    ", outcome_4));
-print(concat_many("  Demo 5 (H.4 + H.5 composed):   ", outcome_5));
+print(concat_many("  Demo 4a (safe arr_get loop):   ", outcome_4));
+print(concat_many("  Demo 4b (safe arr_set H.5.1):  ", outcome_4b));
+print(concat_many("  Demo 5  (H.4 + H.5 composed):  ", outcome_5));
 print("");
 print("# Observations");
 print("#");
@@ -2311,14 +2377,12 @@ print("#   in call_builtin, extend the SAFE_EXPR rewrite to recognize the");
 print("#   call shape. The substrate carries the heavy semantics; H.5 is");
 print("#   structural composition, not new invention.");
 print("#");
-print("# - Known limit: `safe arr_set(VAR, ...)` works under tree-walk but");
-print("#   not via the OMC bytecode VM. The bytecode VM routes CALL_BUILTIN");
-print("#   through a synthetic-scope shim that copies array arguments,");
-print("#   losing the mutation back to the caller's variable. The Rust VM");
-print("#   solved this with ARR_SET_NAMED opcodes; H.5.1 would add an");
-print("#   SAFE_ARR_SET_NAMED variant. Reads (safe arr_get) compose cleanly");
-print("#   through either path because they return a value rather than");
-print("#   mutating a binding.");
+print("# - H.5.1 closed the named-write gap. `safe arr_set(VAR, idx, val)`");
+print("#   now emits SAFE_ARR_SET_NAMED (not CALL_BUILTIN), bypassing the");
+print("#   synthetic-scope shim that lost the mutation. Demo 4b verifies");
+print("#   this end-to-end through the OMC bytecode VM. The pattern is the");
+print("#   exact same one V.7c used for ARR_SET_NAMED: take the variable");
+print("#   name out of the value stack and put it on the opcode.");
 print("############################################################");