feat(core): tape stability fixes, heal→MAPE-K, JIT LLVM-IR optimization

- autograd tape: ε-clamp tape_log, overflow-clamp tape_exp, fix tape_pow_int
  backward 0·∞→NaN poison; stability sweep (div/softmax/mean/sigmoid verified safe)
- self-healer → MAPE-K: persistent cross-pass Knowledge (HealClassCounts.add /
  last_fixpoint_knowledge) + set-signature convergence; surfaced as heal-summary
  in --check and OMC_HEAL
- HEAL as generator-repair operator: tests/heal_as_generator.rs (corrupt→heal recovery)
- safe self-mod: fn_swap_verified determinism gate + invariant SET (array 3rd arg)
- addressing: fns_on_subface (3-level HAddr descent); memo cache FIFO-bounded (memo_put)
- JIT: omnimcode-codegen optimize() — curated scalar pass pipeline (mem2reg/instcombine/
  gvn/simplifycfg), LSR excluded (known segfault), env-gated in dispatch (OMC_HBIT_JIT_OPT)
- tests: substrate_v18 (18), heal_fixpoint (4), heal_as_generator, jit_optimize — all green
- gitignore: knowledge-web data (knowledge.db/derived.db/caches/corpora) never committed

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

Author: RandomCoder-lab

.gitignore

@@ -67,3 +67,25 @@ logs/security/
 # Python virtualenvs
 **/.venv/
 **/venv/
+
+# regenerable built-web caches (dictweb/mind)
+experiments/transformerless_lm/.dictcache/
+experiments/transformerless_lm/.mindcache/
+experiments/transformerless_lm/library/
+
+# Knowledge-web DATA + caches — regenerable and FAR over GitHub's 100MB limit. NEVER commit.
+# knowledge.db (~5-9GB), derived.db, *.textbak / *.prefold_bak backups, WAL/SHM, embedding + fluency
+# caches, run logs/ledgers. The CODE (*.py) that builds them IS tracked; the data is shared elsewhere.
+experiments/transformerless_lm/*.db
+experiments/transformerless_lm/*.db-wal
+experiments/transformerless_lm/*.db-shm
+experiments/transformerless_lm/*.db.textbak
+experiments/transformerless_lm/*.prefold_bak
+experiments/transformerless_lm/knowledge_compressed.db*
+experiments/transformerless_lm/.kwebcache
+experiments/transformerless_lm/.fluencycache_*
+experiments/transformerless_lm/selfimprove_ledger.jsonl
+experiments/transformerless_lm/*.log
+# seed corpora (input data, downloadable/regenerable — e.g. dict_webster.txt is 27MB) + regenerable node lists
+experiments/transformerless_lm/corpora/
+experiments/transformerless_lm/nodes_new.json

omnimcode-cli/src/main.rs

@@ -1,7 +1,7 @@
 // omnimcode-core/src/main.rs - OMNIcode Standalone Executable Entry Point
 
 use omnimcode_core::parser::Parser;
-use omnimcode_core::interpreter::Interpreter;
+use omnimcode_core::interpreter::{Interpreter, last_fixpoint_knowledge};
 use omnimcode_core::ast::{Expression, Statement};
 
 use std::env;
@@ -1602,6 +1602,12 @@ fn check_program(path: &str) -> i32 {
                  path, total_fail, fail_diags.len(), lint.len(), total_warn,
                  iters, outcome);
     }
+    // MAPE-K: the cross-pass Knowledge breakdown (what the healer did over ALL
+    // passes — the per-pass counter only sees the final clean pass).
+    let heal_summary = last_fixpoint_knowledge().summary();
+    if !heal_summary.is_empty() {
+        println!("  heal-summary (all passes): {}", heal_summary);
+    }
     for d in &fail_diags {
         println!("  heal: {}", d);
     }
@@ -1659,6 +1665,10 @@ fn execute_program(source: &str) -> Result<(), String> {
                 "--- OMC_HEAL: {} diagnostic(s) across {} iteration(s) ({}) ---",
                 diagnostics.len(), iters, outcome
             );
+            let heal_summary = last_fixpoint_knowledge().summary();
+            if !heal_summary.is_empty() {
+                eprintln!("  heal-summary (all passes): {}", heal_summary);
+            }
             for d in &diagnostics {
                 eprintln!("  {}", d);
             }

omnimcode-codegen/src/lib.rs

@@ -730,6 +730,49 @@ impl<'ctx> JitContext<'ctx> {
     /// `FunctionValue` so callers can verify it.
     ///
     /// Session B constraints:
+    /// Run a curated LLVM IR optimization pipeline over the module (mem2reg + scalar
+    /// peephole/redundancy passes) using LLVM's new pass manager. Run ONCE after all
+    /// functions are lowered, before extraction/execution.
+    ///
+    /// DELIBERATELY excludes Loop Strength Reduction and all loop passes: LSR crashed
+    /// non-deterministically at `OptimizationLevel::Default` on the LCSSA-form loops the
+    /// dual-band lowerer emits (see `new`), which is why the JIT engine itself runs at
+    /// `None`. These scalar passes recover most of that traded-away peephole optimization
+    /// WITHOUT touching the loop machinery that crashes.
+    ///
+    /// Conservative + non-fatal: only optimizes a module that VERIFIES (never hands
+    /// malformed IR to the optimizer — that's exactly the case that segfaults), and any
+    /// pass-pipeline error leaves the module untouched (the JIT still works, unoptimized).
+    pub fn optimize(&self) -> Result<(), CodegenError> {
+        use inkwell::passes::PassBuilderOptions;
+        use inkwell::targets::{CodeModel, InitializationConfig, RelocMode, Target, TargetMachine};
+        if let Err(msg) = self.module.verify() {
+            return Err(format!("module did not verify; optimization skipped: {}", msg.to_string()));
+        }
+        Target::initialize_native(&InitializationConfig::default())
+            .map_err(|e| format!("initialize_native: {}", e))?;
+        let triple = TargetMachine::get_default_triple();
+        let target = Target::from_triple(&triple).map_err(|e| e.to_string())?;
+        let tm = target
+            .create_target_machine(
+                &triple,
+                "", // generic CPU — IR-level passes don't need host tuning
+                "",
+                OptimizationLevel::None,
+                RelocMode::Default,
+                CodeModel::Default,
+            )
+            .ok_or_else(|| "create_target_machine returned None".to_string())?;
+        // Scalar pipeline ONLY — no loop passes, no LSR (the known crasher).
+        self.module
+            .run_passes(
+                "mem2reg,instcombine,reassociate,gvn,simplifycfg",
+                &tm,
+                PassBuilderOptions::create(),
+            )
+            .map_err(|e| e.to_string())
+    }
+
     /// - All params and the return type are `i64`.
     /// - Only the int-flavored op subset listed in the crate docs.
     /// - `Op::Call(name, _)` must target the function being lowered
@@ -984,6 +1027,17 @@ impl<'ctx> JitContext<'ctx> {
             eprintln!("[OMC_HBIT_JIT_DUMP_IR]");
             eprintln!("{}", self.module.print_to_string().to_string());
         }
+        // L1.5+ optional IR optimization (opt-in via OMC_HBIT_JIT_OPT=1): recover the
+        // peephole optimization traded away when the engine was lowered to
+        // OptimizationLevel::None (see `new`), via a scalar pipeline that EXCLUDES the LSR
+        // pass that crashed. Default OFF out of respect for that segfault history; verify-gated
+        // and non-fatal (a pass error leaves the module unoptimized-but-working). Runs ONCE here,
+        // after all functions are lowered + cleaned, before extraction triggers MCJIT codegen.
+        if std::env::var("OMC_HBIT_JIT_OPT").as_deref() == Ok("1") {
+            if let Err(e) = self.optimize() {
+                eprintln!("[OMC_HBIT_JIT_OPT] optimization skipped: {}", e);
+            }
+        }
         // Phase 3: extract fn pointers for everything that survived
         // both lowering and dependency cleanup.
         let mut out: HashMap<String, JittedFn> = HashMap::new();

omnimcode-codegen/tests/jit_optimize.rs

@@ -0,0 +1,119 @@
+//! JIT IR-optimization tests (JitContext::optimize).
+//!
+//! optimize() runs a curated scalar pass pipeline (mem2reg + instcombine/reassociate/
+//! gvn/simplifycfg) via LLVM's new pass manager. The pipeline DELIBERATELY excludes Loop
+//! Strength Reduction — LSR crashed at OptimizationLevel::Default on the dual-band lowerer's
+//! LCSSA-form loops (why the engine runs at None). These tests prove the pipeline (a) runs
+//! without crashing on real lowered IR including a LOOP-with-locals (the danger zone), and
+//! (b) PRESERVES semantics — the optimized JIT'd function still returns the correct value.
+
+#![cfg(feature = "llvm-jit")]
+
+use inkwell::context::Context;
+use omnimcode_codegen::JitContext;
+use omnimcode_core::ast::Pos;
+use omnimcode_core::bytecode::{CompiledFunction, Const, Op};
+use omnimcode_core::parser::Parser;
+
+fn skeleton(name: &str, params: Vec<&str>, ops: Vec<Op>, constants: Vec<Const>) -> CompiledFunction {
+    let n = ops.len();
+    let param_types = vec![None; params.len()];
+    CompiledFunction {
+        name: name.to_string(),
+        params: params.into_iter().map(String::from).collect(),
+        param_types,
+        return_type: None,
+        op_positions: vec![Pos::unknown(); n],
+        pragmas: Vec::new(),
+        call_cache: (0..n).map(|_| std::cell::Cell::new(0)).collect(),
+        ops,
+        constants,
+    }
+}
+
+#[test]
+fn optimize_preserves_simple_arithmetic() {
+    let f = skeleton(
+        "double",
+        vec!["x"],
+        vec![Op::LoadParam(0), Op::LoadParam(0), Op::Add, Op::Return],
+        vec![],
+    );
+    let ctx = Context::create();
+    let jit = JitContext::new(&ctx).expect("jit ctx");
+    jit.lower_function(&f).expect("lower");
+    jit.optimize().expect("optimize ok");
+    unsafe {
+        let native = jit.get_i64_i64("double").expect("jit fn");
+        assert_eq!(native.call(21), 42, "optimized fn must still double");
+        assert_eq!(native.call(-5), -10);
+    }
+}
+
+#[test]
+fn optimize_preserves_loop_with_locals() {
+    // sum_to_n: allocas (StoreVar/LoadVar/AssignVar → mem2reg promotes) + a while LOOP
+    // (the LSR danger zone). The scalar pipeline must survive it AND keep the result exact.
+    let f = skeleton(
+        "sum_to_n",
+        vec!["n"],
+        vec![
+            Op::LoadConst(0),
+            Op::StoreVar("s".into()),
+            Op::LoadConst(1),
+            Op::StoreVar("k".into()),
+            Op::LoadVar("k".into()),
+            Op::LoadParam(0),
+            Op::Le,
+            Op::JumpIfFalse(10),
+            Op::Pop,
+            Op::LoadVar("s".into()),
+            Op::LoadVar("k".into()),
+            Op::Add,
+            Op::AssignVar("s".into()),
+            Op::LoadVar("k".into()),
+            Op::LoadConst(1),
+            Op::Add,
+            Op::AssignVar("k".into()),
+            Op::Jump(-14),
+            Op::Pop,
+            Op::LoadVar("s".into()),
+            Op::Return,
+        ],
+        vec![Const::Int(0), Const::Int(1)],
+    );
+    let ctx = Context::create();
+    let jit = JitContext::new(&ctx).expect("jit ctx");
+    jit.lower_function(&f).expect("lower");
+    jit.optimize().expect("optimize must not error on a loop+locals fn");
+    unsafe {
+        let native = jit.get_i64_i64("sum_to_n").expect("jit fn");
+        assert_eq!(native.call(10), 55, "optimized loop must still sum 1..10");
+        assert_eq!(native.call(100), 5050);
+        assert_eq!(native.call(0), 0);
+        assert_eq!(native.call(1), 1);
+    }
+}
+
+#[test]
+fn jit_module_dispatch_with_opt_env_preserves_results() {
+    // The DISPATCH path (jit_module) wires optimize() behind OMC_HBIT_JIT_OPT=1. With it on,
+    // a cross-fn-call program must still build a correct dispatch table. Env leakage to other
+    // parallel tests is benign — the passes preserve semantics, so any test still passes.
+    std::env::set_var("OMC_HBIT_JIT_OPT", "1");
+    let source = r#"
+        fn helper(x) { return x * 2; }
+        fn caller(x) { return helper(x) + 1; }
+    "#;
+    let mut parser = Parser::new(source);
+    let statements = parser.parse().expect("parse");
+    let module = omnimcode_core::compiler::compile_program(&statements).expect("compile");
+    let ctx = Context::create();
+    let jit = JitContext::new(&ctx).expect("jit");
+    let jitted = jit.jit_module(&module).expect("jit_module (opt path)");
+    let caller = jitted.get("caller").expect("caller fn");
+    assert_eq!(caller.call(&[10]).expect("call"), 21, "opt dispatch must preserve caller=helper(x)+1");
+    assert_eq!(caller.call(&[100]).expect("call"), 201);
+    assert_eq!(caller.call(&[0]).expect("call"), 1);
+    std::env::remove_var("OMC_HBIT_JIT_OPT");
+}