runtime + compiler: dharma, match, cgi blocks, VBD, agentic LLM

Two parallel agent sweeps closing the remaining structural gaps.

== Compiler completions ==

- match codegen: lowers Match into GCC/Clang statement-expression
  ({ ... }). Patterns: Wildcard, Binding, LitInt (==), LitStr
  (str_eq), LitBool. Per-match unique label via state counter.
  Verified: classify(0)→"zero", classify(1)→"one", classify(7)→"other".

- cgi block parsing: `cgi "name" { dharma_id, principal, network,
  engram }` → CgiBlock AST node → el_cgi_init() emitted as the first
  call in main() after el_runtime_init_args. Multiple cgi blocks per
  program emit a #error directive. Missing optional fields → EL_NULL.

- VBD compile-time enforcement: parser attaches `decorator: <name>`
  to FnDef. Codegen recursively walks fn bodies (Call/BinOp/Not/Neg/
  Field/Index/Try/Array/Map/If/For/Match plus Let/Return/Expr/While/
  For). If a non-@manager function calls dharma_emit or dharma_field,
  emit `#error "VBD violation: ... fn '<name>'"` before the function
  body. Verified: @engine fn calling dharma_emit → cc fails with the
  message. @manager fn calling dharma_emit → compiles clean.

Three-stage closure: stage1.c == stage2.c == stage3.c (2791 lines
each, byte-identical). dist/platform/elc rebuilt at 165 KB; .prev5
preserved.

== Runtime completions ==

- Real dharma_* primitives, no more stubs. Channel registry,
  request/response over HTTP, network-wide spreading activation,
  fire-and-forget event emission, blocking dharma_field with
  pthread_cond_timedwait (30s default), Hebbian relationship
  weights stored as Engram edges between dharma:self and
  dharma:peer:<id>, sorted-by-weight peer list. URL/ID arrays
  snapshotted before network I/O so mutexes never block on socket.

- New public C contract: el_runtime_dharma_event_arrive(type, payload,
  source) — application HTTP handler calls this when /dharma/event
  arrives, runtime broadcasts on _dharma_event_cv. Keeps the HTTP
  server generic; events flow through the application's router.

- llm_call_agentic real multi-turn loop. Tool registry (mutex-
  protected, dlsym-resolved, mirroring http_set_handler). Loop:
  build request with tools+messages → POST → dispatch on stop_reason.
  end_turn → return text. max_tokens → text + "[truncated]". tool_use
  → walk content[], call registered handler per block, build
  tool_result message, append to conversation, loop. Iteration cap
  10. Tools not registered return {"error":"tool not registered: X"}
  with is_error: true.

- New builtin: llm_register_tool(name, handler_fn_name).

Compile clean: cc -std=c11 -Wall -Wextra -c → zero warnings, zero
errors. Smoke test exercises every new dharma_* primitive +
llm_register_tool round-trip.

Runtime grew 3309→4079 lines (.c, ~155 KB), 312→342 lines (.h).

== Integration ==

Engram rebuilt against the new runtime: 130 KB binary, daemon
swapped on :8742 cleanly, /health and /api/stats both returning
correctly under launchd. No regressions.

== Status of "planned" items in language.md ==

- match codegen → IMPLEMENTED
- cgi block parsing → IMPLEMENTED
- VBD enforcement → IMPLEMENTED
- % operator → IMPLEMENTED (earlier today)
- vessel keyword → lexed (codegen uses package compatible)
- activate construct → still planned (low priority; engram_activate
  builtin covers the use case for now)
- sealed block → still planned
- dharma_emit fanout parallelization → potential future work, current
  serial behavior matches spec

el-compiler/src/parser.el

@@ -736,12 +736,93 @@ fn parse_stmt(tokens: [Map<String, Any>], pos: Int) -> Map<String, Any> {
         return make_result({ "stmt": "For", "item": item_name, "list": list_expr, "body": body }, p)
     }
 
-    // @decorator — skip and parse next stmt
+    // @decorator — capture decorator name and attach to following stmt
     if k == "At" {
         let p = pos + 1
-        // skip decorator name
+        let dec_name = tok_value(tokens, p)
         let p = p + 1
-        return parse_stmt(tokens, p)
+        let r = parse_stmt(tokens, p)
+        let inner = r["node"]
+        let p2 = r["pos"]
+        let inner_kind: String = inner["stmt"]
+        if str_eq(inner_kind, "FnDef") {
+            let with_dec = {
+                "stmt": "FnDef",
+                "name": inner["name"],
+                "params": inner["params"],
+                "body": inner["body"],
+                "ret_type": inner["ret_type"],
+                "decorator": dec_name
+            }
+            return make_result(with_dec, p2)
+        }
+        return r
+    }
+
+    // cgi block: cgi "name" { field: "val", ... }
+    if k == "Cgi" {
+        let p = pos + 1
+        let name = tok_value(tokens, p)
+        let p = p + 1
+        let p = expect(tokens, p, "LBrace")
+        let dharma_id = ""
+        let principal = ""
+        let network = ""
+        let engram = ""
+        let has_dharma_id = false
+        let has_principal = false
+        let has_network = false
+        let has_engram = false
+        let running = true
+        while running {
+            let k2 = tok_kind(tokens, p)
+            if k2 == "RBrace" {
+                let running = false
+            } else {
+                if k2 == "Eof" {
+                    let running = false
+                } else {
+                    let fname = tok_value(tokens, p)
+                    let p = p + 1
+                    let p = expect(tokens, p, "Colon")
+                    let fval = tok_value(tokens, p)
+                    let p = p + 1
+                    if str_eq(fname, "dharma_id") {
+                        let dharma_id = fval
+                        let has_dharma_id = true
+                    }
+                    if str_eq(fname, "principal") {
+                        let principal = fval
+                        let has_principal = true
+                    }
+                    if str_eq(fname, "network") {
+                        let network = fval
+                        let has_network = true
+                    }
+                    if str_eq(fname, "engram") {
+                        let engram = fval
+                        let has_engram = true
+                    }
+                    let k3 = tok_kind(tokens, p)
+                    if k3 == "Comma" {
+                        let p = p + 1
+                    }
+                }
+            }
+        }
+        let p = expect(tokens, p, "RBrace")
+        return make_result({
+            "stmt": "CgiBlock",
+            "name": name,
+            "dharma_id": dharma_id,
+            "principal": principal,
+            "network": network,
+            "engram": engram,
+            "has_dharma_id": has_dharma_id,
+            "has_principal": has_principal,
+            "has_network": has_network,
+            "has_engram": has_engram
+        }, p)
     }
 
     // bare expression or if/match statement