feat: v1.3.0 stdlib + recursive self-improvement demo suite

OMC stdlib (examples/lib/):
- llm.omc: ReAct agent, CoT, cot_verify, few_shot, chain, critique_revise, gen_and_test
- cache.omc: memoize, memoize2, LRU cache, TTL cache, disk cache, batch_cached
- graph.omc: BFS, DFS, Dijkstra, toposort, PageRank, connected_components, has_cycle
- text.omc: tokenize, TF-IDF, BM25, Levenshtein, closest, chunk_fixed, chunk_sentences, ngrams
- schema.omc: validate, coerce, assert_valid, schema_string/number/object/array/enum
- cli.omc: ANSI colors, parse_args, progress_bar, table formatter, box drawer, confirm

Recursive self-improvement demos (examples/demos/):
- self_improving_agent.omc: OMC asks Claude to write OMC, tests it, repairs until passing
- code_gen_loop.omc: generate → run → evaluate → improve multi-generation loop
- recursive_improve.omc: meta-improver that improves itself then improves programs
- auto_improve_daemon.omc: 24/7 continuous improvement daemon with quality scoring
- population_evolve.omc: genetic programming with Claude as mutation operator
- code_evolution_loop.omc: multi-lineage evolution + crossbreeding
- substrate_rag.omc: phi-pi-fibonacci RAG with cosine similarity retrieval
- benchmark_dashboard.omc: perf regression tracker with baseline comparison
- mcp_tool_gen.omc: auto-generate MCP tool schemas from OMC function signatures

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

Author: RandomCoder-lab

AGENT_TASKS/task_33_http_builtins.md

@@ -0,0 +1,148 @@
+# Task 33: Native HTTP builtins — http_get, http_post, http_put, http_delete
+
+## Goal
+Add 4 native HTTP builtins to the OMC interpreter using the already-available `ureq` crate.
+ureq is already a dependency (feature `native-llm`) and is available in the workspace.
+
+## Working directory
+/home/thearchitect/OMC
+
+## What already exists
+- `omnimcode-core/src/llm_builtins.rs` — already uses ureq for HTTP in llm_call
+- ureq 2.x is in Cargo.toml under `native-llm` feature
+- `omnimcode-core/src/interpreter.rs` — the main interpreter, ~14000+ lines
+
+## Functions to add
+
+### 1. http_get(url, headers?)
+- url: string
+- headers: optional dict {header_name: header_value}
+- returns: dict {status: int, body: string, ok: bool}
+
+### 2. http_post(url, body, headers?)
+- url: string  
+- body: string (raw body)
+- headers: optional dict
+- returns: dict {status: int, body: string, ok: bool}
+
+### 3. http_post_json(url, data, headers?)
+- url: string
+- data: dict or array (will be json_stringify'd)
+- headers: optional dict  
+- returns: dict {status: int, body: string, json: parsed_json_or_null, ok: bool}
+
+### 4. http_put(url, body, headers?)
+- Same signature as http_post but uses PUT
+
+### 5. http_delete(url, headers?)
+- url: string
+- headers: optional dict
+- returns: dict {status: int, body: string, ok: bool}
+
+## Implementation steps
+
+### Step 1: Add to llm_builtins.rs (or create http_builtins.rs)
+Add a new file `omnimcode-core/src/http_builtins.rs` with these functions:
+
+```rust
+use crate::interpreter::Value;
+use std::collections::HashMap;
+use std::rc::Rc;
+use std::cell::RefCell;
+
+pub fn http_get(args: &[Value]) -> Result<Value, String> {
+    // args[0] = url string
+    // args[1] = optional headers dict
+    // Use ureq::get(url).call()
+    // Return Value::Dict with status, body, ok
+}
+
+pub fn http_post(args: &[Value]) -> Result<Value, String> { ... }
+pub fn http_post_json(args: &[Value]) -> Result<Value, String> { ... }
+pub fn http_put(args: &[Value]) -> Result<Value, String> { ... }
+pub fn http_delete(args: &[Value]) -> Result<Value, String> { ... }
+```
+
+### Step 2: Wire into interpreter.rs
+
+In the builtin match guard (around line 2219 where "llm_call" | "llm_chat" are listed), add:
+```
+| "http_get" | "http_post" | "http_post_json" | "http_put" | "http_delete"
+```
+
+Add dispatch arms that call `crate::http_builtins::http_get(args)` etc.
+
+### Step 3: Add to ALL_BUILTINS and HEAL_BUILTIN_NAMES
+
+Search for where `"llm_call"` is listed in the ALL_BUILTINS array or similar, add the new names there too.
+
+### Step 4: Add to docs.rs
+
+Add a category "http" with doc entries for each function.
+
+### Step 5: Write a test
+
+Create `examples/test_http.omc`:
+```omc
+h result = http_get("https://httpbin.org/get", null)
+print(result["status"])
+print(result["ok"])
+
+h post_result = http_post_json("https://httpbin.org/post", {key: "value"}, null)
+print(post_result["status"])
+```
+
+## Important ureq patterns
+
+```rust
+// GET
+let resp = ureq::get(&url)
+    .call()
+    .map_err(|e| format!("http_get failed: {e}"))?;
+let status = resp.status();
+let body = resp.into_string().map_err(|e| format!("read body: {e}"))?;
+
+// POST with JSON body
+let resp = ureq::post(&url)
+    .set("Content-Type", "application/json")
+    .send_string(&json_body)
+    .map_err(|e| format!("http_post failed: {e}"))?;
+
+// Add custom headers
+let mut req = ureq::get(&url);
+for (k, v) in &headers {
+    req = req.set(k, v);
+}
+```
+
+## Value dict construction pattern (from existing llm_builtins.rs)
+
+```rust
+fn make_response_dict(status: u16, body: String) -> Value {
+    let mut map = HashMap::new();
+    map.insert("status".to_string(), Value::Int(status as i64));
+    map.insert("body".to_string(), Value::Str(body));
+    map.insert("ok".to_string(), Value::Bool(status >= 200 && status < 300));
+    Value::Dict(Rc::new(RefCell::new(map)))
+}
+```
+
+## After implementing
+
+Run:
+```bash
+cd /home/thearchitect/OMC
+cargo build -p omnimcode-core 2>&1 | tail -20
+```
+
+Fix any compile errors. When it builds clean, commit:
+```bash
+git add omnimcode-core/src/http_builtins.rs omnimcode-core/src/interpreter.rs omnimcode-core/src/docs.rs omnimcode-core/src/lib.rs examples/test_http.omc
+git commit -m "feat: http_get + http_post + http_post_json + http_put + http_delete native HTTP builtins"
+```
+
+## DO NOT
+- Do not use async/tokio — ureq is synchronous
+- Do not change Cargo.toml (ureq is already there)
+- Do not launch sub-agents
+- Do not modify any other files beyond what's listed above

AGENT_TASKS/task_34_introspection_builtins.md

@@ -0,0 +1,122 @@
+# Task 34: Introspection builtins — get_scope_vars, list_defined_fns, fn_arity, fn_source
+
+## Goal
+Add 4 runtime introspection builtins to the OMC interpreter.
+These let OMC programs inspect themselves at runtime — critical for self-improvement and meta-programming.
+
+## Working directory
+/home/thearchitect/OMC
+
+## Functions to add
+
+### 1. get_scope_vars() → dict
+Returns all currently-defined variables in scope as a dict {name: value}.
+Useful for debugging and inspection.
+
+### 2. list_defined_fns() → array of strings
+Returns all currently-defined function names as an array.
+Example: ["fib", "is_palindrome", "my_fn"]
+
+### 3. fn_arity(fn_name) → int or null
+Given a function name string, returns the number of parameters.
+Returns null if the function doesn't exist.
+Example: fn_arity("fib") → 1 (because fn fib(n))
+
+### 4. fn_source(fn_name) → string or null
+Given a function name string, returns the source-reconstructed OMC code for that function.
+Reconstructs from the AST — "fn name(params) { ... }"
+Returns null if the function doesn't exist.
+
+## Where to make changes
+
+### interpreter.rs
+The interpreter has an `env` / environment/scope structure. You need to:
+
+1. Find where variables are stored (likely a HashMap<String, Value> or similar)
+2. Find where functions are stored (likely a separate map of function definitions)
+
+Look for patterns like:
+- `self.env` or `env` HashMap
+- `self.functions` or `module.functions` 
+- `FunctionDef`, `CompiledFunction`, or `UserFunction` variants
+
+The interpreter is large (~14000 lines). Search for:
+- `"fn_arity"` (may not exist yet)
+- `BuiltinFunction` or `Builtin` match arms
+- Where `"llm_call"` is dispatched (near line 2219)
+
+### Implementation approach
+
+For `get_scope_vars()`:
+- The interpreter likely has access to the current environment frame
+- Return a dict copy of all bindings visible in the current scope
+- Filter out function objects (only return data values)
+
+For `list_defined_fns()`:
+- Look at where user-defined functions are stored
+- Return their names as an array of strings
+
+For `fn_arity(name)`:
+- Find the function definition by name
+- Return the parameter count
+
+For `fn_source(name)`:
+- Find the function definition
+- Reconstruct "fn name(p1, p2) { <body as OMC string> }"
+- You can do a simple AST-to-string reconstruction for the signature, 
+  and use "{ <native body> }" for the body if full reconstruction is too complex
+- At minimum: return "fn name(p1, p2) { ... }"
+
+## Wire into interpreter.rs
+
+In the builtin match guard, add:
+```
+| "get_scope_vars" | "list_defined_fns" | "fn_arity" | "fn_source"
+```
+
+Add dispatch arms.
+
+## Add to ALL_BUILTINS and docs
+
+Add these 4 names to the ALL_BUILTINS list and add doc entries in the "meta" or "introspection" category.
+
+## Test file
+
+Create `examples/test_introspection.omc`:
+```omc
+fn my_func(a, b, c) { return a + b + c }
+fn other(x) { return x * 2 }
+
+h fns = list_defined_fns()
+print(fns)
+
+h arity = fn_arity("my_func")
+print(arity)
+
+h src = fn_source("my_func")
+print(src)
+
+h vars = get_scope_vars()
+print(dict_keys(vars))
+```
+
+Expected output:
+- fns should contain "my_func" and "other"
+- arity should be 3
+- src should show the function signature
+- vars should show defined variables
+
+## Build and commit
+
+```bash
+cd /home/thearchitect/OMC
+cargo build -p omnimcode-core 2>&1 | tail -20
+# fix errors
+git add omnimcode-core/src/interpreter.rs omnimcode-core/src/docs.rs examples/test_introspection.omc
+git commit -m "feat: get_scope_vars + list_defined_fns + fn_arity + fn_source introspection builtins"
+```
+
+## DO NOT
+- Do not launch sub-agents
+- Do not break existing tests
+- Keep changes focused to interpreter.rs and docs.rs only