kernel: Phase 3 $vau/$lambda/wrap/unwrap + 34 tests [shapes-reflective]

User-defined operatives via $vau; applicatives via $lambda (wrap ∘ $vau).
wrap/unwrap as Kernel-level applicatives. kernel-call-operative forks
on :impl (primitive) vs :body (user) tag. kernel-base-env wires the
four combiners + operative?/applicative? predicates. Env-param sentinel
`_` / `#ignore` → :knl-ignore (skip dyn-env bind). Flat parameter list
only; destructuring later. Headline test: custom applicative + custom
operative composed from user code.

lib/kernel/eval.sx

@@ -1,8 +1,8 @@
-;; lib/kernel/eval.sx — Kernel evaluator (Phase 2 skeleton).
+;; lib/kernel/eval.sx — Kernel evaluator.
 ;;
 ;; The evaluator is `lookup-and-combine`: there are no hardcoded special
-;; forms. Even $if / $define! / $lambda will be ordinary operatives bound
-;; in the standard environment (Phase 4). This file builds the dispatch
+;; forms. Even $if / $define! / $lambda are ordinary operatives bound in
+;; the standard environment (Phase 4). This file builds the dispatch
 ;; machinery and the operative/applicative tagged-value protocol.
 ;;
 ;; Tagged values
@@ -12,24 +12,31 @@
 ;;     keyed by symbol name; parent walks up the lookup chain.
 ;;
 ;;   {:knl-tag :operative :impl FN}
-;;     A primitive operative. FN receives (args dyn-env) — args are the
+;;     Primitive operative. FN receives (args dyn-env) — args are the
 ;;     UN-evaluated argument expressions, dyn-env is the calling env.
 ;;
-;;   {:knl-tag :applicative :underlying OP}
-;;     An applicative wraps an operative. Calls evaluate args first, then
-;;     forward to the underlying operative.
+;;   {:knl-tag :operative :params P :env-param EP :body B :static-env SE}
+;;     User-defined operative (built by $vau). Same tag; dispatch in
+;;     kernel-call-operative forks on which keys are present.
 ;;
-;; User-defined ($vau) operatives are added in Phase 3 — same tag, with
-;; extra fields :params :env-param :body :static-env.
+;;   {:knl-tag :applicative :underlying OP}
+;;     An applicative wraps an operative. Calls evaluate args first,
+;;     then forward to the underlying operative.
+;;
+;; The env-param of a user operative may be the sentinel :knl-ignore,
+;; in which case the dynamic env is not bound.
 ;;
 ;; Public API
 ;;   (kernel-eval EXPR ENV)                     — primary entry
-;;   (kernel-combine COMBINER ARGS DYN-ENV)     — apply a combiner
+;;   (kernel-combine COMBINER ARGS DYN-ENV)
+;;   (kernel-call-operative OP ARGS DYN-ENV)
+;;   (kernel-bind-params! ENV PARAMS ARGS)
 ;;   (kernel-make-env) / (kernel-extend-env P)
 ;;   (kernel-env-bind! E N V) / (kernel-env-lookup E N)
 ;;   (kernel-env-has? E N) / (kernel-env? V)
 ;;   (kernel-make-primitive-operative IMPL)
-;;   (kernel-make-primitive-applicative IMPL)   — IMPL receives evaled args
+;;   (kernel-make-primitive-applicative IMPL)
+;;   (kernel-make-user-operative PARAMS EPARAM BODY STATIC-ENV)
 ;;   (kernel-wrap OP) / (kernel-unwrap APP)
 ;;   (kernel-operative? V) / (kernel-applicative? V) / (kernel-combiner? V)
 ;;
@@ -72,6 +79,10 @@
 
 (define kernel-make-primitive-operative (fn (impl) {:impl impl :knl-tag :operative}))
 
+(define
+  kernel-make-user-operative
+  (fn (params eparam body static-env) {:knl-tag :operative :static-env static-env :params params :body body :env-param eparam}))
+
 (define
   kernel-operative?
   (fn (v) (and (dict? v) (= (get v :knl-tag) :operative))))
@@ -100,8 +111,6 @@
       ((kernel-applicative? app) (get app :underlying))
       (:else (error "kernel-unwrap: argument must be an applicative")))))
 
-;; A primitive applicative: sugar for (wrap (primitive-operative …)) where
-;; the impl receives already-evaluated args.
 (define
   kernel-make-primitive-applicative
   (fn
@@ -136,7 +145,8 @@
   (fn
     (combiner args dyn-env)
     (cond
-      ((kernel-operative? combiner) ((get combiner :impl) args dyn-env))
+      ((kernel-operative? combiner)
+        (kernel-call-operative combiner args dyn-env))
       ((kernel-applicative? combiner)
         (kernel-combine
           (get combiner :underlying)
@@ -144,6 +154,44 @@
           dyn-env))
       (:else (error (str "kernel-eval: not a combiner: " combiner))))))
 
+;; Operatives may be primitive (:impl is a host fn) or user-defined
+;; (carry :params / :env-param / :body / :static-env). The dispatch
+;; fork is here so kernel-combine stays small.
+(define
+  kernel-call-operative
+  (fn
+    (op args dyn-env)
+    (cond
+      ((dict-has? op :impl) ((get op :impl) args dyn-env))
+      ((dict-has? op :body)
+        (let
+          ((local (kernel-extend-env (get op :static-env))))
+          (kernel-bind-params! local (get op :params) args)
+          (let
+            ((eparam (get op :env-param)))
+            (when
+              (not (= eparam :knl-ignore))
+              (kernel-env-bind! local eparam dyn-env)))
+          (kernel-eval (get op :body) local)))
+      (:else (error "kernel-call-operative: malformed operative")))))
+
+;; Phase 3 supports a flat parameter list only — destructuring later.
+(define
+  kernel-bind-params!
+  (fn
+    (env params args)
+    (cond
+      ((or (nil? params) (= (length params) 0))
+        (cond
+          ((or (nil? args) (= (length args) 0)) nil)
+          (:else (error "kernel-call: too many arguments"))))
+      ((or (nil? args) (= (length args) 0))
+        (error "kernel-call: too few arguments"))
+      (:else
+        (begin
+          (kernel-env-bind! env (first params) (first args))
+          (kernel-bind-params! env (rest params) (rest args)))))))
+
 (define
   kernel-eval-args
   (fn
@@ -155,7 +203,6 @@
           (kernel-eval (first args) env)
           (kernel-eval-args (rest args) env))))))
 
-;; Evaluate a sequence of forms in env, returning the value of the last.
 (define
   kernel-eval-program
   (fn