add self_evolve.omc: OMC file that reads and improves its own source

Uses batch_llm_call (parallel N-variant generation) + llm_judge (scoring)
to pick the best improvement over the original. Writes winner back if score
improves. Demonstrates the full recursive self-improvement primitive.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: RandomCoder-lab

examples/demos/self_evolve.omc

@@ -0,0 +1,173 @@
+# self_evolve.omc
+# OMC code that reads its own source, generates N improved variants,
+# judges them with llm_judge, and writes the winner back.
+# The best variant scores higher on correctness, clarity, and efficiency.
+# This is the core of OMC recursive self-improvement.
+
+import "examples/lib/llm.omc"
+
+h MODEL = "claude-opus-4-5"
+h N_VARIANTS = 3
+h TARGET_FILE = "examples/demos/self_evolve.omc"
+
+# ── Helpers ───────────────────────────────────────────────────────────────────
+
+fn strip_fences(text) {
+    if str_contains(text, "```omc") {
+        h a = str_split(text, "```omc")
+        h b = str_split(a[1], "```")
+        return str_trim(b[0])
+    }
+    if str_contains(text, "```") {
+        h a = str_split(text, "```")
+        if arr_len(a) >= 3 { return str_trim(a[1]) }
+    }
+    return str_trim(text)
+}
+
+fn measure_quality(code) {
+    h lines = str_split(code, "\n")
+    h n = arr_len(lines)
+    h fn_count = 0
+    h comment_count = 0
+    h i = 0
+    while i < n {
+        h line = str_trim(lines[i])
+        if str_starts_with(line, "fn ") { fn_count = fn_count + 1 }
+        if str_starts_with(line, "#") { comment_count = comment_count + 1 }
+        i = i + 1
+    }
+    return {lines: n, functions: fn_count, comments: comment_count}
+}
+
+# ── Generate N variant improvements in parallel ───────────────────────────────
+
+fn generate_variants(source_code, n) {
+    h styles = [
+        "Improve clarity and documentation without changing functionality.",
+        "Optimize for performance: reduce redundant operations, tighten loops.",
+        "Improve error handling and edge cases throughout.",
+        "Refactor for modularity: extract repeated patterns into helper functions.",
+        "Add type-safety: validate all function inputs before use."
+    ]
+    h sys = str_concat(
+        "You are an expert OMC programmer. OMC syntax:\n",
+        "  h varname = value  (declare variable)\n",
+        "  fn name(args) { ... return val }  (define function)\n",
+        "  while cond { ... }  (loop)\n",
+        "  arr_push(arr, val), arr_len(arr), str_concat(...)\n",
+        "  llm_call(prompt, model, system), batch_llm_call(prompts, model)\n",
+        "  llm_judge(responses, criteria), substrate_embed(text, dims)\n",
+        "Return ONLY valid OMC code. No markdown, no explanation."
+    )
+    h prompts = []
+    h i = 0
+    while i < n {
+        h style = styles[i % arr_len(styles)]
+        h p = str_concat(
+            style, "\n\n",
+            "Improve this OMC source file:\n\n",
+            source_code
+        )
+        arr_push(prompts, {prompt: p, system: sys})
+        i = i + 1
+    }
+    print(str_concat("Generating ", to_str(n), " variants in parallel..."))
+    h raw = batch_llm_call(prompts, MODEL)
+    h variants = []
+    h ri = 0
+    while ri < arr_len(raw) {
+        arr_push(variants, strip_fences(raw[ri]))
+        ri = ri + 1
+    }
+    return variants
+}
+
+# ── Judge variants and pick best ─────────────────────────────────────────────
+
+fn pick_best_variant(source, variants) {
+    # Include original as baseline (index 0)
+    h candidates = [source]
+    h vi = 0
+    while vi < arr_len(variants) {
+        arr_push(candidates, variants[vi])
+        vi = vi + 1
+    }
+
+    h criteria = str_concat(
+        "This is OMC source code for a self-improvement loop. ",
+        "Score each version 0-10 on: (1) clarity and documentation, ",
+        "(2) correct OMC syntax (h for vars, fn for functions, while for loops), ",
+        "(3) completeness (all original functionality preserved), ",
+        "(4) improvement quality over the original. ",
+        "Penalize heavily for missing functions or broken syntax."
+    )
+
+    print(str_concat("Judging ", to_str(arr_len(candidates)), " candidates (including original)..."))
+    h scores = llm_judge(candidates, criteria, MODEL)
+
+    # Find best non-original
+    h best_idx = 0
+    h best_score = -1.0
+    h si = 0
+    while si < arr_len(scores) {
+        h entry = scores[si]
+        h idx = entry["idx"]
+        h score = entry["score"]
+        print(str_concat("  Candidate ", to_str(idx), " score: ", to_str(score)))
+        if idx > 0 and score > best_score {
+            best_score = score
+            best_idx = idx
+        }
+        si = si + 1
+    }
+
+    h original_score = 0.0
+    h oi = 0
+    while oi < arr_len(scores) {
+        if scores[oi]["idx"] == 0 { original_score = scores[oi]["score"] }
+        oi = oi + 1
+    }
+
+    print(str_concat("Original score: ", to_str(original_score)))
+    print(str_concat("Best variant score: ", to_str(best_score), " (idx=", to_str(best_idx), ")"))
+
+    if best_score > original_score {
+        return {improved: true, code: candidates[best_idx], score: best_score, delta: best_score - original_score}
+    }
+    return {improved: false, code: source, score: original_score, delta: 0.0}
+}
+
+# ── Main: read self, improve, optionally write back ───────────────────────────
+
+print("=== OMC Recursive Self-Evolution ===")
+print(str_concat("Target: ", TARGET_FILE))
+print(str_concat("Variants: ", to_str(N_VARIANTS)))
+print("")
+
+h source = read_file(TARGET_FILE)
+h initial = measure_quality(source)
+print(str_concat("Source: ", to_str(initial["lines"]), " lines, ", to_str(initial["functions"]), " functions"))
+print("")
+
+h variants = generate_variants(source, N_VARIANTS)
+print("")
+
+h result = pick_best_variant(source, variants)
+print("")
+
+if result["improved"] {
+    h final = measure_quality(result["code"])
+    print(str_concat("Improvement delta: +", to_str(result["delta"]), " points"))
+    print(str_concat("Improved: ", to_str(final["lines"]), " lines, ", to_str(final["functions"]), " functions"))
+    print("")
+    print("Writing improved version...")
+    write_file(TARGET_FILE, result["code"])
+    print("Done. The file has improved itself.")
+} else {
+    print("No variant beat the original — source unchanged.")
+    print(str_concat("Original score: ", to_str(result["score"])))
+}
+
+print("")
+print("=== Self-evolution cycle complete ===")