cl: Phase 2 eval — 127 tests, 299 total green

lib/common-lisp/eval.sx: cl-eval-ast implementing quote, if, progn,
let/let*, flet, labels, setq/setf, function, lambda, the, locally,
eval-when, defun, defvar/defparameter/defconstant, built-in arithmetic
(+/-/*//, min/max/abs/evenp/oddp), comparisons, predicates, list ops,
string ops, funcall/apply/mapcar.

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

lib/common-lisp/eval.sx

@@ -0,0 +1,578 @@
+;; Common Lisp evaluator — evaluates CL AST forms.
+;;
+;; Depends on: lib/common-lisp/reader.sx, lib/common-lisp/parser.sx
+;;
+;; Environment:
+;;   {:vars {"NAME" val ...} :fns {"NAME" cl-fn ...}}
+;; CL function:
+;;   {:cl-type "function" :params ll :body forms :env env}
+;;
+;; Public API:
+;;   (cl-make-env)              — create empty environment
+;;   (cl-eval form env)         — evaluate one CL AST form
+;;   (cl-eval-str src env)      — read+eval a CL source string
+;;   (cl-eval-all-str src env)  — read-all+eval-each, return last
+;;   cl-global-env              — global mutable environment
+
+;; ── environment ──────────────────────────────────────────────────
+
+(define cl-make-env (fn () {:vars {} :fns {}}))
+
+(define cl-global-env (cl-make-env))
+
+(define cl-env-get-var  (fn (env name) (get (get env "vars") name)))
+(define cl-env-has-var? (fn (env name) (has-key? (get env "vars") name)))
+(define cl-env-get-fn   (fn (env name) (get (get env "fns") name)))
+(define cl-env-has-fn?  (fn (env name) (has-key? (get env "fns") name)))
+
+(define cl-env-bind-var
+  (fn (env name value)
+    {:vars (assoc (get env "vars") name value)
+     :fns  (get env "fns")}))
+
+(define cl-env-bind-fn
+  (fn (env name fn-obj)
+    {:vars (get env "vars")
+     :fns  (assoc (get env "fns") name fn-obj)}))
+
+;; ── body evaluation ───────────────────────────────────────────────
+
+(define cl-eval-body
+  (fn (forms env)
+    (cond
+      ((= (len forms) 0) nil)
+      ((= (len forms) 1) (cl-eval (nth forms 0) env))
+      (:else
+        (do
+          (cl-eval (nth forms 0) env)
+          (cl-eval-body (rest forms) env))))))
+
+;; ── lambda-list binding helpers ───────────────────────────────────
+
+(define cl-bind-required
+  (fn (names args env)
+    (if (= (len names) 0)
+      env
+      (cl-bind-required
+        (rest names)
+        (if (> (len args) 0) (rest args) args)
+        (cl-env-bind-var env
+          (nth names 0)
+          (if (> (len args) 0) (nth args 0) nil))))))
+
+;; returns {:env e :rest remaining-args}
+(define cl-bind-optional
+  (fn (opts args env)
+    (if (= (len opts) 0)
+      {:env env :rest args}
+      (let ((spec    (nth opts 0))
+            (has-val (> (len args) 0)))
+        (let ((val (if has-val (nth args 0) nil))
+              (rem (if has-val (rest args) args)))
+          (let ((e1 (cl-env-bind-var env (get spec "name")
+                      (if has-val val
+                        (if (get spec "default")
+                          (cl-eval (get spec "default") env) nil)))))
+            (let ((e2 (if (get spec "supplied")
+                        (cl-env-bind-var e1 (get spec "supplied") has-val)
+                        e1)))
+              (cl-bind-optional (rest opts) rem e2))))))))
+
+;; returns {:found bool :value v}
+(define cl-find-kw-arg
+  (fn (kw args i)
+    (if (>= i (len args))
+      {:found false :value nil}
+      (let ((a (nth args i)))
+        (if (and (dict? a)
+                 (= (get a "cl-type") "keyword")
+                 (= (get a "name") kw))
+          {:found true
+           :value (if (< (+ i 1) (len args)) (nth args (+ i 1)) nil)}
+          (cl-find-kw-arg kw args (+ i 2)))))))
+
+(define cl-bind-key
+  (fn (key-specs all-args env)
+    (if (= (len key-specs) 0)
+      env
+      (let ((spec (nth key-specs 0))
+            (r    (cl-find-kw-arg (get (nth key-specs 0) "keyword") all-args 0)))
+        (let ((found (get r "found"))
+              (kval  (get r "value")))
+          (let ((e1 (cl-env-bind-var env (get spec "name")
+                      (if found kval
+                        (if (get spec "default")
+                          (cl-eval (get spec "default") env) nil)))))
+            (let ((e2 (if (get spec "supplied")
+                        (cl-env-bind-var e1 (get spec "supplied") found)
+                        e1)))
+              (cl-bind-key (rest key-specs) all-args e2))))))))
+
+(define cl-bind-aux
+  (fn (aux-specs env)
+    (if (= (len aux-specs) 0)
+      env
+      (let ((spec (nth aux-specs 0)))
+        (cl-bind-aux
+          (rest aux-specs)
+          (cl-env-bind-var env (get spec "name")
+            (if (get spec "init") (cl-eval (get spec "init") env) nil)))))))
+
+;; ── function creation ─────────────────────────────────────────────
+
+;; ll-and-body: (list lambda-list-form body-form ...)
+(define cl-make-lambda
+  (fn (ll-and-body env)
+    {:cl-type "function"
+     :params  (cl-parse-lambda-list (nth ll-and-body 0))
+     :body    (rest ll-and-body)
+     :env     env}))
+
+;; ── function application ──────────────────────────────────────────
+
+(define cl-apply
+  (fn (fn-obj args)
+    (cond
+      ((and (dict? fn-obj) (has-key? fn-obj "builtin-fn"))
+        ((get fn-obj "builtin-fn") args))
+      ((or (not (dict? fn-obj)) (not (= (get fn-obj "cl-type") "function")))
+        {:cl-type "error" :message "Not a function"})
+      (:else
+        (let ((params (get fn-obj "params"))
+            (body   (get fn-obj "body"))
+            (cenv   (get fn-obj "env")))
+        (let ((req       (get params "required"))
+              (opt       (get params "optional"))
+              (rest-name (get params "rest"))
+              (key-specs (get params "key"))
+              (aux-specs (get params "aux")))
+          (let ((e1 (cl-bind-required req args cenv)))
+            (let ((opt-r (cl-bind-optional
+                           opt (slice args (len req) (len args)) e1)))
+              (let ((e2  (get opt-r "env"))
+                    (rem (get opt-r "rest")))
+                (let ((e3 (if rest-name
+                            (cl-env-bind-var e2 rest-name rem)
+                            e2)))
+                  (let ((e4 (cl-bind-key key-specs args e3)))
+                    (let ((e5 (cl-bind-aux aux-specs e4)))
+                      (cl-eval-body body e5)))))))))))))
+
+;; ── built-in functions ────────────────────────────────────────────
+
+(define cl-builtins
+  (dict
+    "+"   (fn (args) (reduce (fn (a b) (+ a b)) 0 args))
+    "-"   (fn (args)
+            (cond
+              ((= (len args) 0) 0)
+              ((= (len args) 1) (- 0 (nth args 0)))
+              (:else (reduce (fn (a b) (- a b)) (nth args 0) (rest args)))))
+    "*"   (fn (args) (reduce (fn (a b) (* a b)) 1 args))
+    "/"   (fn (args)
+            (cond
+              ((= (len args) 0) 1)
+              ((= (len args) 1) (/ 1 (nth args 0)))
+              (:else (reduce (fn (a b) (/ a b)) (nth args 0) (rest args)))))
+    "1+"  (fn (args) (+ (nth args 0) 1))
+    "1-"  (fn (args) (- (nth args 0) 1))
+    "="   (fn (args) (if (= (nth args 0) (nth args 1)) true nil))
+    "/="  (fn (args) (if (not (= (nth args 0) (nth args 1))) true nil))
+    "<"   (fn (args) (if (< (nth args 0) (nth args 1)) true nil))
+    ">"   (fn (args) (if (> (nth args 0) (nth args 1)) true nil))
+    "<="  (fn (args) (if (<= (nth args 0) (nth args 1)) true nil))
+    ">="  (fn (args) (if (>= (nth args 0) (nth args 1)) true nil))
+    "NOT"   (fn (args) (if (nth args 0) nil true))
+    "NULL"  (fn (args) (if (= (nth args 0) nil) true nil))
+    "NUMBERP" (fn (args) (if (number? (nth args 0)) true nil))
+    "STRINGP" (fn (args) (if (string? (nth args 0)) true nil))
+    "SYMBOLP" (fn (args) nil)
+    "LISTP"   (fn (args)
+                 (if (or (list? (nth args 0)) (= (nth args 0) nil)) true nil))
+    "CONSP"   (fn (args)
+                 (let ((x (nth args 0)))
+                   (if (and (dict? x) (= (get x "cl-type") "cons")) true nil)))
+    "ATOM"    (fn (args)
+                 (let ((x (nth args 0)))
+                   (if (and (dict? x) (= (get x "cl-type") "cons")) nil true)))
+    "FUNCTIONP" (fn (args)
+                   (let ((x (nth args 0)))
+                     (if (and (dict? x) (= (get x "cl-type") "function")) true nil)))
+    "ZEROP"  (fn (args) (if (= (nth args 0) 0) true nil))
+    "PLUSP"  (fn (args) (if (> (nth args 0) 0) true nil))
+    "MINUSP" (fn (args) (if (< (nth args 0) 0) true nil))
+    "EVENP"  (fn (args)
+                (let ((n (nth args 0)))
+                  (if (= (mod n 2) 0) true nil)))
+    "ODDP"   (fn (args)
+                (let ((n (nth args 0)))
+                  (if (not (= (mod n 2) 0)) true nil)))
+    "ABS"    (fn (args) (let ((n (nth args 0))) (if (< n 0) (- 0 n) n)))
+    "MAX"    (fn (args) (reduce (fn (a b) (if (> a b) a b)) (nth args 0) (rest args)))
+    "MIN"    (fn (args) (reduce (fn (a b) (if (< a b) a b)) (nth args 0) (rest args)))
+    "CONS"   (fn (args) {:cl-type "cons" :car (nth args 0) :cdr (nth args 1)})
+    "CAR"    (fn (args)
+                (let ((x (nth args 0)))
+                  (if (and (dict? x) (= (get x "cl-type") "cons"))
+                    (get x "car")
+                    (if (and (list? x) (> (len x) 0)) (nth x 0) nil))))
+    "CDR"    (fn (args)
+                (let ((x (nth args 0)))
+                  (if (and (dict? x) (= (get x "cl-type") "cons"))
+                    (get x "cdr")
+                    (if (list? x) (rest x) nil))))
+    "LIST"   (fn (args) args)
+    "APPEND" (fn (args)
+                (if (= (len args) 0) (list)
+                  (reduce (fn (a b)
+                    (if (= a nil) b (if (= b nil) a (concat a b))))
+                  (list) args)))
+    "LENGTH" (fn (args)
+                (let ((x (nth args 0)))
+                  (if (= x nil) 0 (len x))))
+    "NTH"    (fn (args) (nth (nth args 1) (nth args 0)))
+    "FIRST"  (fn (args)
+                (let ((x (nth args 0)))
+                  (if (and (list? x) (> (len x) 0)) (nth x 0) nil)))
+    "SECOND" (fn (args)
+                (let ((x (nth args 0)))
+                  (if (and (list? x) (> (len x) 1)) (nth x 1) nil)))
+    "THIRD"  (fn (args)
+                (let ((x (nth args 0)))
+                  (if (and (list? x) (> (len x) 2)) (nth x 2) nil)))
+    "REST"   (fn (args) (rest (nth args 0)))
+    "REVERSE" (fn (args)
+                 (reduce (fn (acc x) (concat (list x) acc))
+                         (list) (nth args 0)))
+    "IDENTITY" (fn (args) (nth args 0))
+    "VALUES"   (fn (args) (if (> (len args) 0) (nth args 0) nil))
+    "PRINT"    (fn (args) (nth args 0))
+    "PRIN1"    (fn (args) (nth args 0))
+    "PRINC"    (fn (args) (nth args 0))
+    "TERPRI"   (fn (args) nil)
+    "WRITE"    (fn (args) (nth args 0))
+    "STRING-UPCASE"   (fn (args) (upcase (nth args 0)))
+    "STRING-DOWNCASE" (fn (args) (downcase (nth args 0)))
+    "STRING="         (fn (args) (if (= (nth args 0) (nth args 1)) true nil))
+    "CONCATENATE"     (fn (args) (reduce (fn (a b) (str a b)) "" (rest args)))
+    "EQ"    (fn (args) (if (= (nth args 0) (nth args 1)) true nil))
+    "EQL"   (fn (args) (if (= (nth args 0) (nth args 1)) true nil))
+    "EQUAL" (fn (args) (if (= (nth args 0) (nth args 1)) true nil))))
+
+;; Register builtins in cl-global-env so (function #'name) resolves them
+(for-each
+  (fn (name)
+    (dict-set! (get cl-global-env "fns") name
+      {:cl-type "function" :builtin-fn (get cl-builtins name)}))
+  (keys cl-builtins))
+
+;; ── special form evaluators ───────────────────────────────────────
+
+(define cl-eval-if
+  (fn (args env)
+    (let ((cond-val  (cl-eval (nth args 0) env))
+          (then-form (nth args 1))
+          (else-form (if (> (len args) 2) (nth args 2) nil)))
+      (if cond-val
+        (cl-eval then-form env)
+        (if else-form (cl-eval else-form env) nil)))))
+
+(define cl-eval-and
+  (fn (args env)
+    (if (= (len args) 0)
+      true
+      (let ((val (cl-eval (nth args 0) env)))
+        (if (not val)
+          nil
+          (if (= (len args) 1)
+            val
+            (cl-eval-and (rest args) env)))))))
+
+(define cl-eval-or
+  (fn (args env)
+    (if (= (len args) 0)
+      nil
+      (let ((val (cl-eval (nth args 0) env)))
+        (if val
+          val
+          (cl-eval-or (rest args) env))))))
+
+(define cl-eval-cond
+  (fn (clauses env)
+    (if (= (len clauses) 0)
+      nil
+      (let ((clause (nth clauses 0)))
+        (let ((test-val (cl-eval (nth clause 0) env)))
+          (if test-val
+            (if (= (len clause) 1)
+              test-val
+              (cl-eval-body (rest clause) env))
+            (cl-eval-cond (rest clauses) env)))))))
+
+;; Parallel LET and sequential LET*
+(define cl-eval-let
+  (fn (args env sequential)
+    (let ((bindings (nth args 0))
+          (body     (rest args)))
+      (if sequential
+        ;; LET*: each binding sees previous ones
+        (let ((new-env env))
+          (define bind-seq
+            (fn (bs e)
+              (if (= (len bs) 0)
+                e
+                (let ((b (nth bs 0)))
+                  (let ((name (if (list? b) (nth b 0) b))
+                        (init (if (and (list? b) (> (len b) 1)) (nth b 1) nil)))
+                    (bind-seq (rest bs)
+                      (cl-env-bind-var e name (cl-eval init e))))))))
+          (cl-eval-body body (bind-seq bindings env)))
+        ;; LET: evaluate all inits in current env, then bind
+        (let ((pairs (map
+                       (fn (b)
+                         (let ((name (if (list? b) (nth b 0) b))
+                               (init (if (and (list? b) (> (len b) 1)) (nth b 1) nil)))
+                           {:name name :value (cl-eval init env)}))
+                       bindings)))
+          (let ((new-env (reduce
+                           (fn (e pair)
+                             (cl-env-bind-var e (get pair "name") (get pair "value")))
+                           env pairs)))
+            (cl-eval-body body new-env)))))))
+
+;; SETQ / SETF (simplified: mutate nearest scope or global)
+(define cl-eval-setq
+  (fn (args env)
+    (if (< (len args) 2)
+      nil
+      (let ((name (nth args 0))
+            (val  (cl-eval (nth args 1) env)))
+        (if (has-key? (get env "vars") name)
+          (dict-set! (get env "vars") name val)
+          (dict-set! (get cl-global-env "vars") name val))
+        (if (> (len args) 2)
+          (cl-eval-setq (rest (rest args)) env)
+          val)))))
+
+;; FUNCTION: get function value or create lambda
+(define cl-eval-function
+  (fn (args env)
+    (let ((spec (nth args 0)))
+      (cond
+        ((and (list? spec) (> (len spec) 0) (= (nth spec 0) "LAMBDA"))
+          (cl-make-lambda (rest spec) env))
+        ((string? spec)
+          (cond
+            ((cl-env-has-fn? env spec) (cl-env-get-fn env spec))
+            ((cl-env-has-fn? cl-global-env spec)
+              (cl-env-get-fn cl-global-env spec))
+            (:else {:cl-type "error" :message (str "Undefined function: " spec)})))
+        (:else {:cl-type "error" :message "FUNCTION: invalid spec"})))))
+
+;; FLET: local functions (non-recursive, close over outer env)
+(define cl-eval-flet
+  (fn (args env)
+    (let ((fn-defs (nth args 0))
+          (body    (rest args)))
+      (let ((new-env (reduce
+                       (fn (e def)
+                         (let ((name    (nth def 0))
+                               (ll      (nth def 1))
+                               (fn-body (rest (rest def))))
+                           (cl-env-bind-fn e name
+                             {:cl-type "function"
+                              :params  (cl-parse-lambda-list ll)
+                              :body    fn-body
+                              :env     env})))
+                       env fn-defs)))
+        (cl-eval-body body new-env)))))
+
+;; LABELS: mutually-recursive local functions
+(define cl-eval-labels
+  (fn (args env)
+    (let ((fn-defs (nth args 0))
+          (body    (rest args)))
+      ;; Build env with placeholder nil entries for each name
+      (let ((new-env (reduce
+                       (fn (e def) (cl-env-bind-fn e (nth def 0) nil))
+                       env fn-defs)))
+        ;; Fill in real function objects that capture new-env
+        (for-each
+          (fn (def)
+            (let ((name    (nth def 0))
+                  (ll      (nth def 1))
+                  (fn-body (rest (rest def))))
+              (dict-set! (get new-env "fns") name
+                {:cl-type "function"
+                 :params  (cl-parse-lambda-list ll)
+                 :body    fn-body
+                 :env     new-env})))
+          fn-defs)
+        (cl-eval-body body new-env)))))
+
+;; EVAL-WHEN: evaluate body only if :execute is in situations
+(define cl-eval-eval-when
+  (fn (args env)
+    (let ((situations (nth args 0))
+          (body       (rest args)))
+      (define has-exec
+        (some (fn (s)
+                (or
+                  (and (dict? s)
+                       (= (get s "cl-type") "keyword")
+                       (= (get s "name") "EXECUTE"))
+                  (= s "EXECUTE")))
+              situations))
+      (if has-exec (cl-eval-body body env) nil))))
+
+;; DEFUN: define function in global fns namespace
+(define cl-eval-defun
+  (fn (args env)
+    (let ((name    (nth args 0))
+          (ll      (nth args 1))
+          (fn-body (rest (rest args))))
+      (let ((fn-obj {:cl-type "function"
+                     :params  (cl-parse-lambda-list ll)
+                     :body    fn-body
+                     :env     env}))
+        (dict-set! (get cl-global-env "fns") name fn-obj)
+        name))))
+
+;; DEFVAR / DEFPARAMETER / DEFCONSTANT
+(define cl-eval-defvar
+  (fn (args env always-assign)
+    (let ((name     (nth args 0))
+          (has-init (> (len args) 1)))
+      (let ((val (if has-init (cl-eval (nth args 1) env) nil)))
+        (when (or always-assign
+                  (not (cl-env-has-var? cl-global-env name)))
+          (dict-set! (get cl-global-env "vars") name val))
+        name))))
+
+;; Function call: evaluate name → look up fns, builtins; evaluate args
+(define cl-call-fn
+  (fn (name args env)
+    (let ((evaled (map (fn (a) (cl-eval a env)) args)))
+      (cond
+        ;; FUNCALL: (funcall fn arg...)
+        ((= name "FUNCALL")
+          (cl-apply (nth evaled 0) (rest evaled)))
+        ;; APPLY: (apply fn arg... list)
+        ((= name "APPLY")
+          (let ((fn-obj   (nth evaled 0))
+                (all-args (rest evaled)))
+            (let ((leading  (slice all-args 0 (- (len all-args) 1)))
+                  (last-arg (nth all-args (- (len all-args) 1))))
+              (cl-apply fn-obj (concat leading (if (= last-arg nil) (list) last-arg))))))
+        ;; MAPCAR: (mapcar fn list)
+        ((= name "MAPCAR")
+          (let ((fn-obj (nth evaled 0))
+                (lst    (nth evaled 1)))
+            (if (= lst nil) (list)
+              (map (fn (x) (cl-apply fn-obj (list x))) lst))))
+        ;; Look up in local fns namespace
+        ((cl-env-has-fn? env name)
+          (cl-apply (cl-env-get-fn env name) evaled))
+        ;; Look up in global fns namespace
+        ((cl-env-has-fn? cl-global-env name)
+          (cl-apply (cl-env-get-fn cl-global-env name) evaled))
+        ;; Look up in builtins
+        ((has-key? cl-builtins name)
+          ((get cl-builtins name) evaled))
+        (:else
+          {:cl-type "error" :message (str "Undefined function: " name)})))))
+
+;; ── main evaluator ────────────────────────────────────────────────
+
+(define cl-eval
+  (fn (form env)
+    (cond
+      ;; Nil and booleans are self-evaluating
+      ((= form nil) nil)
+      ((= form true) true)
+      ;; Numbers are self-evaluating
+      ((number? form) form)
+      ;; Dicts: typed CL values
+      ((dict? form)
+        (let ((ct (get form "cl-type")))
+          (cond
+            ((= ct "string") (get form "value"))  ;; CL string → SX string
+            (:else form))))                         ;; keywords, floats, chars, etc.
+      ;; Symbol reference (variable lookup)
+      ((string? form)
+        (cond
+          ((cl-env-has-var? env form) (cl-env-get-var env form))
+          ((cl-env-has-var? cl-global-env form)
+            (cl-env-get-var cl-global-env form))
+          (:else {:cl-type "error" :message (str "Undefined variable: " form)})))
+      ;; List: special forms or function call
+      ((list? form) (cl-eval-list form env))
+      ;; Anything else self-evaluates
+      (:else form))))
+
+(define cl-eval-list
+  (fn (form env)
+    (if (= (len form) 0)
+      nil
+      (let ((head (nth form 0))
+            (args (rest form)))
+        (cond
+          ((= head "QUOTE")        (nth args 0))
+          ((= head "IF")           (cl-eval-if args env))
+          ((= head "PROGN")        (cl-eval-body args env))
+          ((= head "LET")          (cl-eval-let args env false))
+          ((= head "LET*")         (cl-eval-let args env true))
+          ((= head "AND")          (cl-eval-and args env))
+          ((= head "OR")           (cl-eval-or args env))
+          ((= head "COND")         (cl-eval-cond args env))
+          ((= head "WHEN")
+            (if (cl-eval (nth args 0) env)
+              (cl-eval-body (rest args) env) nil))
+          ((= head "UNLESS")
+            (if (not (cl-eval (nth args 0) env))
+              (cl-eval-body (rest args) env) nil))
+          ((= head "SETQ")         (cl-eval-setq args env))
+          ((= head "SETF")         (cl-eval-setq args env))
+          ((= head "FUNCTION")     (cl-eval-function args env))
+          ((= head "LAMBDA")       (cl-make-lambda args env))
+          ((= head "FLET")         (cl-eval-flet args env))
+          ((= head "LABELS")       (cl-eval-labels args env))
+          ((= head "THE")          (cl-eval (nth args 1) env))
+          ((= head "LOCALLY")      (cl-eval-body args env))
+          ((= head "EVAL-WHEN")    (cl-eval-eval-when args env))
+          ((= head "DEFUN")        (cl-eval-defun args env))
+          ((= head "DEFVAR")       (cl-eval-defvar args env false))
+          ((= head "DEFPARAMETER") (cl-eval-defvar args env true))
+          ((= head "DEFCONSTANT")  (cl-eval-defvar args env true))
+          ((= head "DECLAIM")      nil)
+          ((= head "PROCLAIM")     nil)
+          ;; Named function call
+          ((string? head)
+            (cl-call-fn head args env))
+          ;; Anonymous call: ((lambda ...) args)
+          (:else
+            (let ((fn-obj (cl-eval head env)))
+              (if (and (dict? fn-obj) (= (get fn-obj "cl-type") "function"))
+                (cl-apply fn-obj (map (fn (a) (cl-eval a env)) args))
+                {:cl-type "error" :message "Not callable"}))))))))
+
+;; ── public API ────────────────────────────────────────────────────
+
+(define cl-eval-str
+  (fn (src env)
+    (cl-eval (cl-read src) env)))
+
+(define cl-eval-all-str
+  (fn (src env)
+    (let ((forms (cl-read-all src)))
+      (if (= (len forms) 0)
+        nil
+        (let ((result nil) (i 0))
+          (define loop (fn ()
+            (when (< i (len forms))
+              (do
+                (set! result (cl-eval (nth forms i) env))
+                (set! i (+ i 1))
+                (loop)))))
+          (loop)
+          result)))))

lib/common-lisp/parser.sx

@@ -0,0 +1,377 @@
+;; Common Lisp reader — converts token stream to CL AST forms.
+;;
+;; Depends on: lib/common-lisp/reader.sx  (cl-tokenize)
+;;
+;; AST representation:
+;;   integer/float         → SX number (or {:cl-type "float"/:ratio ...})
+;;   string                → SX string
+;;   symbol FOO            → SX string "FOO"  (upcase)
+;;   symbol NIL            → nil
+;;   symbol T              → true
+;;   :keyword              → {:cl-type "keyword" :name "FOO"}
+;;   #\char                → {:cl-type "char"    :value "a"}
+;;   #:uninterned          → {:cl-type "uninterned" :name "FOO"}
+;;   ratio 1/3             → {:cl-type "ratio"   :value "1/3"}
+;;   float 3.14            → {:cl-type "float"   :value "3.14"}
+;;   proper list (a b c)   → SX list (a b c)
+;;   dotted pair (a . b)   → {:cl-type "cons" :car a :cdr b}
+;;   vector #(a b)         → {:cl-type "vector" :elements (list a b)}
+;;   'x                    → ("QUOTE" x)
+;;   `x                    → ("QUASIQUOTE" x)
+;;   ,x                    → ("UNQUOTE" x)
+;;   ,@x                   → ("UNQUOTE-SPLICING" x)
+;;   #'x                   → ("FUNCTION" x)
+;;
+;; Public API:
+;;   (cl-read src)         — parse first form from string, return form
+;;   (cl-read-all src)     — parse all top-level forms, return list
+
+;; ── number conversion ─────────────────────────────────────────────
+
+(define
+  cl-hex-val
+  (fn
+    (c)
+    (let
+      ((o (cl-ord c)))
+      (cond
+        ((and (>= o 48) (<= o 57)) (- o 48))
+        ((and (>= o 65) (<= o 70)) (+ 10 (- o 65)))
+        ((and (>= o 97) (<= o 102)) (+ 10 (- o 97)))
+        (:else 0)))))
+
+(define
+  cl-parse-radix-str
+  (fn
+    (s radix start)
+    (let
+      ((n (string-length s)) (i start) (acc 0))
+      (define
+        loop
+        (fn
+          ()
+          (when
+            (< i n)
+            (do
+              (set! acc (+ (* acc radix) (cl-hex-val (substring s i (+ i 1)))))
+              (set! i (+ i 1))
+              (loop)))))
+      (loop)
+      acc)))
+
+(define
+  cl-convert-integer
+  (fn
+    (s)
+    (let
+      ((n (string-length s)) (neg false))
+      (cond
+        ((and (> n 2) (= (substring s 0 1) "#"))
+          (let
+            ((letter (downcase (substring s 1 2))))
+            (cond
+              ((= letter "x") (cl-parse-radix-str s 16 2))
+              ((= letter "b") (cl-parse-radix-str s 2 2))
+              ((= letter "o") (cl-parse-radix-str s 8 2))
+              (:else (parse-int s 0)))))
+        (:else (parse-int s 0))))))
+
+;; ── reader ────────────────────────────────────────────────────────
+
+;; Read one form from token list.
+;; Returns {:form F :rest remaining-toks} or {:form nil :rest toks :eof true}
+(define
+  cl-read-form
+  (fn
+    (toks)
+    (if
+      (not toks)
+      {:form nil :rest toks :eof true}
+      (let
+        ((tok (nth toks 0)) (nxt (rest toks)))
+        (let
+          ((type (get tok "type")) (val (get tok "value")))
+          (cond
+            ((= type "eof") {:form nil :rest toks :eof true})
+            ((= type "integer") {:form (cl-convert-integer val) :rest nxt})
+            ((= type "float") {:form {:cl-type "float" :value val} :rest nxt})
+            ((= type "ratio") {:form {:cl-type "ratio" :value val} :rest nxt})
+            ((= type "string") {:form val :rest nxt})
+            ((= type "char") {:form {:cl-type "char" :value val} :rest nxt})
+            ((= type "keyword") {:form {:cl-type "keyword" :name val} :rest nxt})
+            ((= type "uninterned") {:form {:cl-type "uninterned" :name val} :rest nxt})
+            ((= type "symbol")
+              (cond
+                ((= val "NIL") {:form nil :rest nxt})
+                ((= val "T") {:form true :rest nxt})
+                (:else {:form val :rest nxt})))
+            ;; list forms
+            ((= type "lparen") (cl-read-list nxt))
+            ((= type "hash-paren") (cl-read-vector nxt))
+            ;; reader macros that wrap the next form
+            ((= type "quote") (cl-read-wrap "QUOTE" nxt))
+            ((= type "backquote") (cl-read-wrap "QUASIQUOTE" nxt))
+            ((= type "comma") (cl-read-wrap "UNQUOTE" nxt))
+            ((= type "comma-at") (cl-read-wrap "UNQUOTE-SPLICING" nxt))
+            ((= type "hash-quote") (cl-read-wrap "FUNCTION" nxt))
+            ;; skip unrecognised tokens
+            (:else (cl-read-form nxt))))))))
+
+;; Wrap next form in a list: (name form)
+(define
+  cl-read-wrap
+  (fn
+    (name toks)
+    (let
+      ((inner (cl-read-form toks)))
+      {:form (list name (get inner "form")) :rest (get inner "rest")})))
+
+;; Read list forms until ')'; handles dotted pair (a . b)
+;; Called after consuming '('
+(define
+  cl-read-list
+  (fn
+    (toks)
+    (let
+      ((result (cl-read-list-items toks (list))))
+      {:form (get result "items") :rest (get result "rest")})))
+
+(define
+  cl-read-list-items
+  (fn
+    (toks acc)
+    (if
+      (not toks)
+      {:items acc :rest toks}
+      (let
+        ((tok (nth toks 0)))
+        (let
+          ((type (get tok "type")))
+          (cond
+            ((= type "eof") {:items acc :rest toks})
+            ((= type "rparen") {:items acc :rest (rest toks)})
+            ;; dotted pair: read one more form then expect ')'
+            ((= type "dot")
+              (let
+                ((cdr-result (cl-read-form (rest toks))))
+                (let
+                  ((cdr-form (get cdr-result "form"))
+                    (after-cdr (get cdr-result "rest")))
+                  ;; skip the closing ')'
+                  (let
+                    ((close (if after-cdr (nth after-cdr 0) nil)))
+                    (let
+                      ((remaining
+                          (if
+                            (and close (= (get close "type") "rparen"))
+                            (rest after-cdr)
+                            after-cdr)))
+                      ;; build dotted structure
+                      (let
+                        ((dotted (cl-build-dotted acc cdr-form)))
+                        {:items dotted :rest remaining}))))))
+            (:else
+              (let
+                ((item (cl-read-form toks)))
+                (cl-read-list-items
+                  (get item "rest")
+                  (concat acc (list (get item "form"))))))))))))
+
+;; Build dotted form: (a b . c) → ((DOTTED a b) . c) style
+;; In CL (a b c . d) means a proper dotted structure.
+;; We represent it as {:cl-type "cons" :car a :cdr (list->dotted b c d)}
+(define
+  cl-build-dotted
+  (fn
+    (head-items tail)
+    (if
+      (= (len head-items) 0)
+      tail
+      (if
+        (= (len head-items) 1)
+        {:cl-type "cons" :car (nth head-items 0) :cdr tail}
+        (let
+          ((last-item (nth head-items (- (len head-items) 1)))
+            (but-last (slice head-items 0 (- (len head-items) 1))))
+          {:cl-type "cons"
+            :car (cl-build-dotted but-last (list last-item))
+            :cdr tail})))))
+
+;; Read vector #(…) elements until ')'
+(define
+  cl-read-vector
+  (fn
+    (toks)
+    (let
+      ((result (cl-read-vector-items toks (list))))
+      {:form {:cl-type "vector" :elements (get result "items")} :rest (get result "rest")})))
+
+(define
+  cl-read-vector-items
+  (fn
+    (toks acc)
+    (if
+      (not toks)
+      {:items acc :rest toks}
+      (let
+        ((tok (nth toks 0)))
+        (let
+          ((type (get tok "type")))
+          (cond
+            ((= type "eof") {:items acc :rest toks})
+            ((= type "rparen") {:items acc :rest (rest toks)})
+            (:else
+              (let
+                ((item (cl-read-form toks)))
+                (cl-read-vector-items
+                  (get item "rest")
+                  (concat acc (list (get item "form"))))))))))))
+
+;; ── lambda-list parser ───────────────────────────────────────────
+;;
+;; (cl-parse-lambda-list forms) — parse a list of CL forms (already read)
+;; into a structured dict:
+;;   {:required (list sym ...)
+;;    :optional (list {:name N :default D :supplied S} ...)
+;;    :rest     nil | "SYM"
+;;    :key      (list {:name N :keyword K :default D :supplied S} ...)
+;;    :allow-other-keys false | true
+;;    :aux      (list {:name N :init I} ...)}
+;;
+;; Symbols arrive as SX strings (upcase). &-markers are strings like "&OPTIONAL".
+;; Key params: keyword is the upcase name string; caller uses it as :keyword.
+;; Supplied-p: nil when absent.
+
+(define
+  cl-parse-opt-spec
+  (fn
+    (spec)
+    (if
+      (list? spec)
+      {:name (nth spec 0)
+        :default (if (> (len spec) 1) (nth spec 1) nil)
+        :supplied (if (> (len spec) 2) (nth spec 2) nil)}
+      {:name spec :default nil :supplied nil})))
+
+(define
+  cl-parse-key-spec
+  (fn
+    (spec)
+    (if
+      (list? spec)
+      (let
+        ((first (nth spec 0)))
+        (if
+          (list? first)
+          ;; ((:keyword var) default supplied-p)
+          {:name (nth first 1)
+            :keyword (get first "name")
+            :default (if (> (len spec) 1) (nth spec 1) nil)
+            :supplied (if (> (len spec) 2) (nth spec 2) nil)}
+          ;; (var default supplied-p)
+          {:name first
+            :keyword first
+            :default (if (> (len spec) 1) (nth spec 1) nil)
+            :supplied (if (> (len spec) 2) (nth spec 2) nil)}))
+      {:name spec :keyword spec :default nil :supplied nil})))
+
+(define
+  cl-parse-aux-spec
+  (fn
+    (spec)
+    (if
+      (list? spec)
+      {:name (nth spec 0) :init (if (> (len spec) 1) (nth spec 1) nil)}
+      {:name spec :init nil})))
+
+(define
+  cl-parse-lambda-list
+  (fn
+    (forms)
+    (let
+      ((state "required")
+        (required (list))
+        (optional (list))
+        (rest-name nil)
+        (key (list))
+        (allow-other-keys false)
+        (aux (list)))
+
+      (define
+        scan
+        (fn
+          (items)
+          (when
+            (> (len items) 0)
+            (let
+              ((item (nth items 0)) (tail (rest items)))
+              (cond
+                ((= item "&OPTIONAL")
+                  (do (set! state "optional") (scan tail)))
+                ((= item "&REST")
+                  (do (set! state "rest") (scan tail)))
+                ((= item "&BODY")
+                  (do (set! state "rest") (scan tail)))
+                ((= item "&KEY")
+                  (do (set! state "key") (scan tail)))
+                ((= item "&AUX")
+                  (do (set! state "aux") (scan tail)))
+                ((= item "&ALLOW-OTHER-KEYS")
+                  (do (set! allow-other-keys true) (scan tail)))
+                ((= state "required")
+                  (do (append! required item) (scan tail)))
+                ((= state "optional")
+                  (do (append! optional (cl-parse-opt-spec item)) (scan tail)))
+                ((= state "rest")
+                  (do (set! rest-name item) (set! state "done") (scan tail)))
+                ((= state "key")
+                  (do (append! key (cl-parse-key-spec item)) (scan tail)))
+                ((= state "aux")
+                  (do (append! aux (cl-parse-aux-spec item)) (scan tail)))
+                (:else (scan tail)))))))
+
+      (scan forms)
+      {:required required
+        :optional optional
+        :rest rest-name
+        :key key
+        :allow-other-keys allow-other-keys
+        :aux aux})))
+
+;; Convenience: parse lambda list from a CL source string
+(define
+  cl-parse-lambda-list-str
+  (fn
+    (src)
+    (cl-parse-lambda-list (cl-read src))))
+
+;; ── public API ────────────────────────────────────────────────────
+
+(define
+  cl-read
+  (fn
+    (src)
+    (let
+      ((toks (cl-tokenize src)))
+      (get (cl-read-form toks) "form"))))
+
+(define
+  cl-read-all
+  (fn
+    (src)
+    (let
+      ((toks (cl-tokenize src)))
+      (define
+        loop
+        (fn
+          (toks acc)
+          (if
+            (or (not toks) (= (get (nth toks 0) "type") "eof"))
+            acc
+            (let
+              ((result (cl-read-form toks)))
+              (if
+                (get result "eof")
+                acc
+                (loop (get result "rest") (concat acc (list (get result "form")))))))))
+      (loop toks (list)))))

lib/common-lisp/reader.sx

@@ -0,0 +1,381 @@
+;; Common Lisp tokenizer
+;;
+;; Tokens: {:type T :value V :pos P}
+;;
+;; Types:
+;;   "symbol"      — FOO, PKG:SYM, PKG::SYM, T, NIL (upcase)
+;;   "keyword"     — :foo (value is upcase name without colon)
+;;   "integer"     — 42, -5, #xFF, #b1010, #o17 (string)
+;;   "float"       — 3.14, 1.0e10 (string)
+;;   "ratio"       — 1/3 (string "N/D")
+;;   "string"      — unescaped content
+;;   "char"        — single-character string
+;;   "lparen"  "rparen"  "quote"  "backquote"  "comma"  "comma-at"
+;;   "hash-quote"  — #'
+;;   "hash-paren"  — #(
+;;   "uninterned"  — #:foo (upcase name)
+;;   "dot"         — standalone . (dotted pair separator)
+;;   "eof"
+
+(define cl-make-tok (fn (type value pos) {:type type :value value :pos pos}))
+
+;; ── char ordinal table ────────────────────────────────────────────
+
+(define
+  cl-ord-table
+  (let
+    ((t (dict)) (i 0))
+    (define
+      cl-fill
+      (fn
+        ()
+        (when
+          (< i 128)
+          (do
+            (dict-set! t (char-from-code i) i)
+            (set! i (+ i 1))
+            (cl-fill)))))
+    (cl-fill)
+    t))
+
+(define cl-ord (fn (c) (or (get cl-ord-table c) 0)))
+
+;; ── character predicates ──────────────────────────────────────────
+
+(define cl-digit? (fn (c) (and (>= (cl-ord c) 48) (<= (cl-ord c) 57))))
+
+(define
+  cl-hex?
+  (fn
+    (c)
+    (or
+      (cl-digit? c)
+      (and (>= (cl-ord c) 65) (<= (cl-ord c) 70))
+      (and (>= (cl-ord c) 97) (<= (cl-ord c) 102)))))
+
+(define cl-octal? (fn (c) (and (>= (cl-ord c) 48) (<= (cl-ord c) 55))))
+
+(define cl-binary? (fn (c) (or (= c "0") (= c "1"))))
+
+(define cl-ws? (fn (c) (or (= c " ") (= c "\t") (= c "\n") (= c "\r"))))
+
+(define
+  cl-alpha?
+  (fn
+    (c)
+    (or
+      (and (>= (cl-ord c) 65) (<= (cl-ord c) 90))
+      (and (>= (cl-ord c) 97) (<= (cl-ord c) 122)))))
+
+;; Characters that end a token (whitespace + terminating macro chars)
+(define
+  cl-terminating?
+  (fn
+    (c)
+    (or
+      (cl-ws? c)
+      (= c "(")
+      (= c ")")
+      (= c "\"")
+      (= c ";")
+      (= c "`")
+      (= c ","))))
+
+;; Symbol constituent: not terminating, not reader-special
+(define
+  cl-sym-char?
+  (fn
+    (c)
+    (not
+      (or
+        (cl-terminating? c)
+        (= c "#")
+        (= c "|")
+        (= c "\\")
+        (= c "'")))))
+
+;; ── named character table ─────────────────────────────────────────
+
+(define
+  cl-named-chars
+  {:space " "
+    :newline "\n"
+    :tab "\t"
+    :return "\r"
+    :backspace (char-from-code 8)
+    :rubout (char-from-code 127)
+    :delete (char-from-code 127)
+    :escape (char-from-code 27)
+    :altmode (char-from-code 27)
+    :null (char-from-code 0)
+    :nul (char-from-code 0)
+    :page (char-from-code 12)
+    :formfeed (char-from-code 12)})
+
+;; ── main tokenizer ────────────────────────────────────────────────
+
+(define
+  cl-tokenize
+  (fn
+    (src)
+    (let
+      ((pos 0) (n (string-length src)) (toks (list)))
+
+      (define at (fn () (if (< pos n) (substring src pos (+ pos 1)) nil)))
+      (define peek1 (fn () (if (< (+ pos 1) n) (substring src (+ pos 1) (+ pos 2)) nil)))
+      (define adv (fn () (set! pos (+ pos 1))))
+
+      ;; Advance while predicate holds; return substring from start to end
+      (define
+        read-while
+        (fn
+          (pred)
+          (let
+            ((start pos))
+            (define
+              rw-loop
+              (fn
+                ()
+                (when
+                  (and (at) (pred (at)))
+                  (do (adv) (rw-loop)))))
+            (rw-loop)
+            (substring src start pos))))
+
+      (define
+        skip-line
+        (fn
+          ()
+          (when
+            (and (at) (not (= (at) "\n")))
+            (do (adv) (skip-line)))))
+
+      (define
+        skip-block
+        (fn
+          (depth)
+          (when
+            (at)
+            (cond
+              ((and (= (at) "#") (= (peek1) "|"))
+                (do (adv) (adv) (skip-block (+ depth 1))))
+              ((and (= (at) "|") (= (peek1) "#"))
+                (do
+                  (adv)
+                  (adv)
+                  (when (> depth 1) (skip-block (- depth 1)))))
+              (:else (do (adv) (skip-block depth)))))))
+
+      ;; Read string literal — called with pos just past opening "
+      (define
+        read-str
+        (fn
+          (acc)
+          (if
+            (not (at))
+            acc
+            (cond
+              ((= (at) "\"") (do (adv) acc))
+              ((= (at) "\\")
+                (do
+                  (adv)
+                  (let
+                    ((e (at)))
+                    (adv)
+                    (read-str
+                      (str
+                        acc
+                        (cond
+                          ((= e "n") "\n")
+                          ((= e "t") "\t")
+                          ((= e "r") "\r")
+                          ((= e "\"") "\"")
+                          ((= e "\\") "\\")
+                          (:else e)))))))
+              (:else
+                (let
+                  ((c (at)))
+                  (adv)
+                  (read-str (str acc c))))))))
+
+      ;; Read #\ char literal — called with pos just past the backslash
+      (define
+        read-char-lit
+        (fn
+          ()
+          (let
+            ((first (at)))
+            (adv)
+            (let
+              ((rest (if (and (at) (cl-alpha? (at))) (read-while cl-alpha?) "")))
+              (if
+                (= rest "")
+                first
+                (let
+                  ((name (downcase (str first rest))))
+                  (or (get cl-named-chars name) first)))))))
+
+      ;; Number scanner — called with pos just past first digit(s).
+      ;; acc holds what was already consumed (first digit or sign+digit).
+      (define
+        scan-num
+        (fn
+          (p acc)
+          (let
+            ((more (read-while cl-digit?)))
+            (set! acc (str acc more))
+            (cond
+              ;; ratio N/D
+              ((and (at) (= (at) "/") (peek1) (cl-digit? (peek1)))
+                (do
+                  (adv)
+                  (let
+                    ((denom (read-while cl-digit?)))
+                    {:type "ratio" :value (str acc "/" denom) :pos p})))
+              ;; float: decimal point N.M[eE]
+              ((and (at) (= (at) ".") (peek1) (cl-digit? (peek1)))
+                (do
+                  (adv)
+                  (let
+                    ((frac (read-while cl-digit?)))
+                    (set! acc (str acc "." frac))
+                    (when
+                      (and (at) (or (= (at) "e") (= (at) "E")))
+                      (do
+                        (set! acc (str acc (at)))
+                        (adv)
+                        (when
+                          (and (at) (or (= (at) "+") (= (at) "-")))
+                          (do (set! acc (str acc (at))) (adv)))
+                        (set! acc (str acc (read-while cl-digit?)))))
+                    {:type "float" :value acc :pos p})))
+              ;; float: exponent only NeE
+              ((and (at) (or (= (at) "e") (= (at) "E")))
+                (do
+                  (set! acc (str acc (at)))
+                  (adv)
+                  (when
+                    (and (at) (or (= (at) "+") (= (at) "-")))
+                    (do (set! acc (str acc (at))) (adv)))
+                  (set! acc (str acc (read-while cl-digit?)))
+                  {:type "float" :value acc :pos p}))
+              (:else {:type "integer" :value acc :pos p})))))
+
+      (define
+        read-radix
+        (fn
+          (letter p)
+          (let
+            ((pred
+                (cond
+                  ((or (= letter "x") (= letter "X")) cl-hex?)
+                  ((or (= letter "b") (= letter "B")) cl-binary?)
+                  ((or (= letter "o") (= letter "O")) cl-octal?)
+                  (:else cl-digit?))))
+            {:type "integer"
+              :value (str "#" letter (read-while pred))
+              :pos p})))
+
+      (define emit (fn (tok) (append! toks tok)))
+
+      (define
+        scan
+        (fn
+          ()
+          (when
+            (< pos n)
+            (let
+              ((c (at)) (p pos))
+              (cond
+                ((cl-ws? c) (do (adv) (scan)))
+                ((= c ";") (do (adv) (skip-line) (scan)))
+                ((= c "(") (do (adv) (emit (cl-make-tok "lparen" "(" p)) (scan)))
+                ((= c ")") (do (adv) (emit (cl-make-tok "rparen" ")" p)) (scan)))
+                ((= c "'") (do (adv) (emit (cl-make-tok "quote" "'" p)) (scan)))
+                ((= c "`") (do (adv) (emit (cl-make-tok "backquote" "`" p)) (scan)))
+                ((= c ",")
+                  (do
+                    (adv)
+                    (if
+                      (= (at) "@")
+                      (do (adv) (emit (cl-make-tok "comma-at" ",@" p)))
+                      (emit (cl-make-tok "comma" "," p)))
+                    (scan)))
+                ((= c "\"")
+                  (do
+                    (adv)
+                    (emit (cl-make-tok "string" (read-str "") p))
+                    (scan)))
+                ;; :keyword
+                ((= c ":")
+                  (do
+                    (adv)
+                    (emit (cl-make-tok "keyword" (upcase (read-while cl-sym-char?)) p))
+                    (scan)))
+                ;; dispatch macro #
+                ((= c "#")
+                  (do
+                    (adv)
+                    (let
+                      ((d (at)))
+                      (cond
+                        ((= d "'") (do (adv) (emit (cl-make-tok "hash-quote" "#'" p)) (scan)))
+                        ((= d "(") (do (adv) (emit (cl-make-tok "hash-paren" "#(" p)) (scan)))
+                        ((= d ":")
+                          (do
+                            (adv)
+                            (emit
+                              (cl-make-tok "uninterned" (upcase (read-while cl-sym-char?)) p))
+                            (scan)))
+                        ((= d "|") (do (adv) (skip-block 1) (scan)))
+                        ((= d "\\")
+                          (do (adv) (emit (cl-make-tok "char" (read-char-lit) p)) (scan)))
+                        ((or (= d "x") (= d "X"))
+                          (do (adv) (emit (read-radix d p)) (scan)))
+                        ((or (= d "b") (= d "B"))
+                          (do (adv) (emit (read-radix d p)) (scan)))
+                        ((or (= d "o") (= d "O"))
+                          (do (adv) (emit (read-radix d p)) (scan)))
+                        (:else (scan))))))
+                ;; standalone dot, float .5, or symbol starting with dots
+                ((= c ".")
+                  (do
+                    (adv)
+                    (cond
+                      ((or (not (at)) (cl-terminating? (at)))
+                        (do (emit (cl-make-tok "dot" "." p)) (scan)))
+                      ((cl-digit? (at))
+                        (do
+                          (emit
+                            (cl-make-tok "float" (str "0." (read-while cl-digit?)) p))
+                          (scan)))
+                      (:else
+                        (do
+                          (emit
+                            (cl-make-tok "symbol" (upcase (str "." (read-while cl-sym-char?))) p))
+                          (scan))))))
+                ;; sign followed by digit → number
+                ((and (or (= c "+") (= c "-")) (peek1) (cl-digit? (peek1)))
+                  (do
+                    (adv)
+                    (let
+                      ((first-d (at)))
+                      (adv)
+                      (emit (scan-num p (str c first-d))))
+                    (scan)))
+                ;; decimal digit → number
+                ((cl-digit? c)
+                  (do
+                    (adv)
+                    (emit (scan-num p c))
+                    (scan)))
+                ;; symbol constituent (includes bare +, -, etc.)
+                ((cl-sym-char? c)
+                  (do
+                    (emit (cl-make-tok "symbol" (upcase (read-while cl-sym-char?)) p))
+                    (scan)))
+                (:else (do (adv) (scan))))))))
+
+      (scan)
+      (append! toks (cl-make-tok "eof" nil n))
+      toks)))

lib/common-lisp/test.sh

@@ -0,0 +1,100 @@
+#!/usr/bin/env bash
+# Common Lisp on SX test runner — pipes directly to sx_server.exe
+#
+# Usage:
+#   bash lib/common-lisp/test.sh           # all tests
+#   bash lib/common-lisp/test.sh -v        # verbose
+#   bash lib/common-lisp/test.sh tests/read.sx  # one file
+
+set -euo pipefail
+cd "$(git rev-parse --show-toplevel)"
+
+SX_SERVER="hosts/ocaml/_build/default/bin/sx_server.exe"
+if [ ! -x "$SX_SERVER" ]; then
+  MAIN_ROOT=$(git worktree list | awk 'NR==1{print $1}')
+  if [ -x "$MAIN_ROOT/$SX_SERVER" ]; then
+    SX_SERVER="$MAIN_ROOT/$SX_SERVER"
+  else
+    echo "ERROR: sx_server.exe not found"
+    exit 1
+  fi
+fi
+
+VERBOSE=""
+FILES=()
+for arg in "$@"; do
+  case "$arg" in
+    -v|--verbose) VERBOSE=1 ;;
+    *) FILES+=("$arg") ;;
+  esac
+done
+
+if [ ${#FILES[@]} -eq 0 ]; then
+  mapfile -t FILES < <(find lib/common-lisp/tests -maxdepth 2 -name '*.sx' | sort)
+fi
+
+TOTAL_PASS=0
+TOTAL_FAIL=0
+FAILED_FILES=()
+
+for FILE in "${FILES[@]}"; do
+  [ -f "$FILE" ] || { echo "skip $FILE (not found)"; continue; }
+  TMPFILE=$(mktemp)
+  cat > "$TMPFILE" <<EPOCHS
+(epoch 1)
+(load "lib/common-lisp/reader.sx")
+(load "lib/common-lisp/parser.sx")
+(epoch 2)
+(load "$FILE")
+(epoch 3)
+(eval "(list cl-test-pass cl-test-fail)")
+EPOCHS
+
+  OUTPUT=$(timeout 60 "$SX_SERVER" < "$TMPFILE" 2>&1 || true)
+  rm -f "$TMPFILE"
+
+  LINE=$(echo "$OUTPUT" | awk '/^\(ok-len 3 / {getline; print; exit}' || true)
+  if [ -z "$LINE" ]; then
+    LINE=$(echo "$OUTPUT" | grep -E '^\(ok 3 \([0-9]+ [0-9]+\)\)' | tail -1 \
+            | sed -E 's/^\(ok 3 //; s/\)$//' || true)
+  fi
+  if [ -z "$LINE" ]; then
+    echo "✗ $FILE: could not extract summary"
+    echo "$OUTPUT" | tail -20
+    TOTAL_FAIL=$((TOTAL_FAIL + 1))
+    FAILED_FILES+=("$FILE")
+    continue
+  fi
+  P=$(echo "$LINE" | sed -E 's/^\(([0-9]+) ([0-9]+)\).*/\1/')
+  F=$(echo "$LINE" | sed -E 's/^\(([0-9]+) ([0-9]+)\).*/\2/')
+  TOTAL_PASS=$((TOTAL_PASS + P))
+  TOTAL_FAIL=$((TOTAL_FAIL + F))
+  if [ "$F" -gt 0 ]; then
+    FAILED_FILES+=("$FILE")
+    printf '✗ %-40s %d/%d\n' "$FILE" "$P" "$((P+F))"
+    TMPFILE2=$(mktemp)
+    cat > "$TMPFILE2" <<EPOCHS
+(epoch 1)
+(load "lib/common-lisp/reader.sx")
+(load "lib/common-lisp/parser.sx")
+(epoch 2)
+(load "$FILE")
+(epoch 3)
+(eval "(map (fn (f) (get f \"name\")) cl-test-fails)")
+EPOCHS
+    FAILS=$(timeout 60 "$SX_SERVER" < "$TMPFILE2" 2>&1 | grep -E '^\(ok 3 ' || true)
+    rm -f "$TMPFILE2"
+    echo "    $FAILS"
+  elif [ "$VERBOSE" = "1" ]; then
+    printf '✓ %-40s %d passed\n' "$FILE" "$P"
+  fi
+done
+
+TOTAL=$((TOTAL_PASS + TOTAL_FAIL))
+if [ $TOTAL_FAIL -eq 0 ]; then
+  echo "✓ $TOTAL_PASS/$TOTAL common-lisp-on-sx tests passed"
+else
+  echo "✗ $TOTAL_PASS/$TOTAL passed, $TOTAL_FAIL failed in: ${FAILED_FILES[*]}"
+fi
+
+[ $TOTAL_FAIL -eq 0 ]

lib/common-lisp/tests/eval.sx

@@ -0,0 +1,285 @@
+;; CL evaluator tests
+
+(define cl-test-pass 0)
+(define cl-test-fail 0)
+(define cl-test-fails (list))
+
+(define
+  cl-deep=
+  (fn
+    (a b)
+    (cond
+      ((= a b) true)
+      ((and (dict? a) (dict? b))
+        (let
+          ((ak (keys a)) (bk (keys b)))
+          (if
+            (not (= (len ak) (len bk)))
+            false
+            (every?
+              (fn (k) (and (has-key? b k) (cl-deep= (get a k) (get b k))))
+              ak))))
+      ((and (list? a) (list? b))
+        (if
+          (not (= (len a) (len b)))
+          false
+          (let
+            ((i 0) (ok true))
+            (define
+              chk
+              (fn
+                ()
+                (when
+                  (and ok (< i (len a)))
+                  (do
+                    (when
+                      (not (cl-deep= (nth a i) (nth b i)))
+                      (set! ok false))
+                    (set! i (+ i 1))
+                    (chk)))))
+            (chk)
+            ok)))
+      (:else false))))
+
+(define
+  cl-test
+  (fn
+    (name actual expected)
+    (if
+      (cl-deep= actual expected)
+      (set! cl-test-pass (+ cl-test-pass 1))
+      (do
+        (set! cl-test-fail (+ cl-test-fail 1))
+        (append! cl-test-fails {:name name :expected expected :actual actual})))))
+
+;; Convenience: evaluate CL string with fresh env each time
+(define ev (fn (src) (cl-eval-str src (cl-make-env))))
+(define evall (fn (src) (cl-eval-all-str src (cl-make-env))))
+
+;; ── self-evaluating literals ──────────────────────────────────────
+
+(cl-test "lit: nil" (ev "nil") nil)
+(cl-test "lit: t" (ev "t") true)
+(cl-test "lit: integer" (ev "42") 42)
+(cl-test "lit: negative" (ev "-7") -7)
+(cl-test "lit: zero" (ev "0") 0)
+(cl-test "lit: string" (ev "\"hello\"") "hello")
+(cl-test "lit: empty string" (ev "\"\"") "")
+(cl-test "lit: keyword type" (get (ev ":foo") "cl-type") "keyword")
+(cl-test "lit: keyword name" (get (ev ":foo") "name") "FOO")
+(cl-test "lit: float type" (get (ev "3.14") "cl-type") "float")
+
+;; ── QUOTE ─────────────────────────────────────────────────────────
+
+(cl-test "quote: symbol" (ev "'x") "X")
+(cl-test "quote: list" (ev "'(a b c)") (list "A" "B" "C"))
+(cl-test "quote: nil" (ev "'nil") nil)
+(cl-test "quote: integer" (ev "'42") 42)
+(cl-test "quote: nested" (ev "'(a (b c))") (list "A" (list "B" "C")))
+
+;; ── IF ────────────────────────────────────────────────────────────
+
+(cl-test "if: true branch" (ev "(if t 1 2)") 1)
+(cl-test "if: false branch" (ev "(if nil 1 2)") 2)
+(cl-test "if: no else nil" (ev "(if nil 99)") nil)
+(cl-test "if: number truthy" (ev "(if 0 'yes 'no)") "YES")
+(cl-test "if: empty string truthy" (ev "(if \"\" 'yes 'no)") "YES")
+(cl-test "if: nested" (ev "(if t (if nil 1 2) 3)") 2)
+
+;; ── PROGN ────────────────────────────────────────────────────────
+
+(cl-test "progn: single" (ev "(progn 42)") 42)
+(cl-test "progn: multiple" (ev "(progn 1 2 3)") 3)
+(cl-test "progn: nil last" (ev "(progn 1 nil)") nil)
+
+;; ── AND / OR ─────────────────────────────────────────────────────
+
+(cl-test "and: empty" (ev "(and)") true)
+(cl-test "and: all true" (ev "(and 1 2 3)") 3)
+(cl-test "and: short-circuit" (ev "(and nil 99)") nil)
+(cl-test "and: returns last" (ev "(and 1 2)") 2)
+(cl-test "or: empty" (ev "(or)") nil)
+(cl-test "or: first truthy" (ev "(or 1 2)") 1)
+(cl-test "or: all nil" (ev "(or nil nil)") nil)
+(cl-test "or: short-circuit" (ev "(or nil 42)") 42)
+
+;; ── COND ─────────────────────────────────────────────────────────
+
+(cl-test "cond: first match" (ev "(cond (t 1) (t 2))") 1)
+(cl-test "cond: second match" (ev "(cond (nil 1) (t 2))") 2)
+(cl-test "cond: no match" (ev "(cond (nil 1) (nil 2))") nil)
+(cl-test "cond: returns test value" (ev "(cond (42))") 42)
+
+;; ── WHEN / UNLESS ─────────────────────────────────────────────────
+
+(cl-test "when: true" (ev "(when t 1 2 3)") 3)
+(cl-test "when: nil" (ev "(when nil 99)") nil)
+(cl-test "unless: nil runs" (ev "(unless nil 42)") 42)
+(cl-test "unless: true skips" (ev "(unless t 99)") nil)
+
+;; ── LET ──────────────────────────────────────────────────────────
+
+(cl-test "let: empty bindings" (ev "(let () 42)") 42)
+(cl-test "let: single binding" (ev "(let ((x 5)) x)") 5)
+(cl-test "let: two bindings" (ev "(let ((x 3) (y 4)) (+ x y))") 7)
+(cl-test "let: parallel" (ev "(let ((x 1)) (let ((x 2) (y x)) y))") 1)
+(cl-test "let: nested" (ev "(let ((x 1)) (let ((y 2)) (+ x y)))") 3)
+(cl-test "let: progn body" (ev "(let ((x 5)) (+ x 1) (* x 2))") 10)
+(cl-test "let: bare name nil" (ev "(let (x) x)") nil)
+
+;; ── LET* ─────────────────────────────────────────────────────────
+
+(cl-test "let*: sequential" (ev "(let* ((x 1) (y (+ x 1))) y)") 2)
+(cl-test "let*: chain" (ev "(let* ((a 2) (b (* a 3)) (c (+ b 1))) c)") 7)
+(cl-test "let*: shadow" (ev "(let ((x 1)) (let* ((x 2) (y x)) y))") 2)
+
+;; ── SETQ / SETF ──────────────────────────────────────────────────
+
+(cl-test "setq: basic" (ev "(let ((x 0)) (setq x 5) x)") 5)
+(cl-test "setq: returns value" (ev "(let ((x 0)) (setq x 99))") 99)
+(cl-test "setf: basic" (ev "(let ((x 0)) (setf x 7) x)") 7)
+
+;; ── LAMBDA ────────────────────────────────────────────────────────
+
+(cl-test "lambda: call" (ev "((lambda (x) x) 42)") 42)
+(cl-test "lambda: multi-arg" (ev "((lambda (x y) (+ x y)) 3 4)") 7)
+(cl-test "lambda: closure" (ev "(let ((n 10)) ((lambda (x) (+ x n)) 5))") 15)
+(cl-test "lambda: rest arg"
+  (ev "((lambda (x &rest xs) (cons x xs)) 1 2 3)")
+  {:cl-type "cons" :car 1 :cdr (list 2 3)})
+(cl-test "lambda: optional no default"
+  (ev "((lambda (&optional x) x))")
+  nil)
+(cl-test "lambda: optional with arg"
+  (ev "((lambda (&optional (x 99)) x) 42)")
+  42)
+(cl-test "lambda: optional default used"
+  (ev "((lambda (&optional (x 7)) x))")
+  7)
+
+;; ── FUNCTION ─────────────────────────────────────────────────────
+
+(cl-test "function: lambda" (get (ev "(function (lambda (x) x))") "cl-type") "function")
+
+;; ── DEFUN ────────────────────────────────────────────────────────
+
+(cl-test "defun: returns name" (evall "(defun sq (x) (* x x))") "SQ")
+(cl-test "defun: call" (evall "(defun sq (x) (* x x)) (sq 5)") 25)
+(cl-test "defun: multi-arg" (evall "(defun add (x y) (+ x y)) (add 3 4)") 7)
+(cl-test "defun: recursive factorial"
+  (evall "(defun fact (n) (if (<= n 1) 1 (* n (fact (- n 1))))) (fact 5)")
+  120)
+(cl-test "defun: multiple calls"
+  (evall "(defun double (x) (* x 2)) (+ (double 3) (double 5))")
+  16)
+
+;; ── FLET ─────────────────────────────────────────────────────────
+
+(cl-test "flet: basic"
+  (ev "(flet ((double (x) (* x 2))) (double 5))")
+  10)
+(cl-test "flet: sees outer vars"
+  (ev "(let ((n 3)) (flet ((add-n (x) (+ x n))) (add-n 7)))")
+  10)
+(cl-test "flet: non-recursive"
+  (ev "(flet ((f (x) (+ x 1))) (flet ((f (x) (f (f x)))) (f 5)))")
+  7)
+
+;; ── LABELS ────────────────────────────────────────────────────────
+
+(cl-test "labels: basic"
+  (ev "(labels ((greet (x) x)) (greet 42))")
+  42)
+(cl-test "labels: recursive"
+  (ev "(labels ((count (n) (if (<= n 0) 0 (+ 1 (count (- n 1)))))) (count 5))")
+  5)
+(cl-test "labels: mutual recursion"
+  (ev "(labels
+         ((even? (n) (if (= n 0) t  (odd? (- n 1))))
+          (odd?  (n) (if (= n 0) nil   (even? (- n 1)))))
+         (list (even? 4) (odd? 3)))")
+  (list true true))
+
+;; ── THE / LOCALLY / EVAL-WHEN ────────────────────────────────────
+
+(cl-test "the: passthrough" (ev "(the integer 42)") 42)
+(cl-test "the: string" (ev "(the string \"hi\")") "hi")
+(cl-test "locally: body" (ev "(locally 1 2 3)") 3)
+(cl-test "eval-when: execute" (ev "(eval-when (:execute) 99)") 99)
+(cl-test "eval-when: no execute" (ev "(eval-when (:compile-toplevel) 99)") nil)
+
+;; ── DEFVAR / DEFPARAMETER ────────────────────────────────────────
+
+(cl-test "defvar: returns name" (evall "(defvar *x* 10)") "*X*")
+(cl-test "defparameter: sets value" (evall "(defparameter *y* 42) *y*") 42)
+(cl-test "defvar: no reinit" (evall "(defvar *z* 1) (defvar *z* 99) *z*") 1)
+
+;; ── built-in arithmetic ───────────────────────────────────────────
+
+(cl-test "arith: +" (ev "(+ 1 2 3)") 6)
+(cl-test "arith: + zero" (ev "(+)") 0)
+(cl-test "arith: -" (ev "(- 10 3 2)") 5)
+(cl-test "arith: - negate" (ev "(- 5)") -5)
+(cl-test "arith: *" (ev "(* 2 3 4)") 24)
+(cl-test "arith: * one" (ev "(*)") 1)
+(cl-test "arith: /" (ev "(/ 12 3)") 4)
+(cl-test "arith: max" (ev "(max 3 1 4 1 5)") 5)
+(cl-test "arith: min" (ev "(min 3 1 4 1 5)") 1)
+(cl-test "arith: abs neg" (ev "(abs -7)") 7)
+(cl-test "arith: abs pos" (ev "(abs 7)") 7)
+
+;; ── built-in comparisons ──────────────────────────────────────────
+
+(cl-test "cmp: = true" (ev "(= 3 3)") true)
+(cl-test "cmp: = false" (ev "(= 3 4)") nil)
+(cl-test "cmp: /=" (ev "(/= 3 4)") true)
+(cl-test "cmp: <" (ev "(< 1 2)") true)
+(cl-test "cmp: > false" (ev "(> 1 2)") nil)
+(cl-test "cmp: <=" (ev "(<= 2 2)") true)
+
+;; ── built-in predicates ───────────────────────────────────────────
+
+(cl-test "pred: null nil" (ev "(null nil)") true)
+(cl-test "pred: null non-nil" (ev "(null 5)") nil)
+(cl-test "pred: not nil" (ev "(not nil)") true)
+(cl-test "pred: not truthy" (ev "(not 5)") nil)
+(cl-test "pred: numberp" (ev "(numberp 5)") true)
+(cl-test "pred: numberp str" (ev "(numberp \"x\")") nil)
+(cl-test "pred: stringp" (ev "(stringp \"hello\")") true)
+(cl-test "pred: listp list" (ev "(listp '(1))") true)
+(cl-test "pred: listp nil" (ev "(listp nil)") true)
+(cl-test "pred: zerop" (ev "(zerop 0)") true)
+(cl-test "pred: plusp" (ev "(plusp 3)") true)
+(cl-test "pred: evenp" (ev "(evenp 4)") true)
+(cl-test "pred: oddp" (ev "(oddp 3)") true)
+
+;; ── built-in list ops ─────────────────────────────────────────────
+
+(cl-test "list: car" (ev "(car '(1 2 3))") 1)
+(cl-test "list: cdr" (ev "(cdr '(1 2 3))") (list 2 3))
+(cl-test "list: cons" (get (ev "(cons 1 2)") "car") 1)
+(cl-test "list: list fn" (ev "(list 1 2 3)") (list 1 2 3))
+(cl-test "list: length" (ev "(length '(a b c))") 3)
+(cl-test "list: length nil" (ev "(length nil)") 0)
+(cl-test "list: append" (ev "(append '(1 2) '(3 4))") (list 1 2 3 4))
+(cl-test "list: first" (ev "(first '(10 20 30))") 10)
+(cl-test "list: second" (ev "(second '(10 20 30))") 20)
+(cl-test "list: third" (ev "(third '(10 20 30))") 30)
+(cl-test "list: rest" (ev "(rest '(1 2 3))") (list 2 3))
+(cl-test "list: nth" (ev "(nth 1 '(a b c))") "B")
+(cl-test "list: reverse" (ev "(reverse '(1 2 3))") (list 3 2 1))
+
+;; ── FUNCALL / APPLY / MAPCAR ─────────────────────────────────────
+
+(cl-test "funcall: lambda"
+  (ev "(funcall (lambda (x) (* x x)) 5)")
+  25)
+(cl-test "apply: basic"
+  (ev "(apply #'+ '(1 2 3))")
+  6)
+(cl-test "apply: leading args"
+  (ev "(apply #'+ 1 2 '(3 4))")
+  10)
+(cl-test "mapcar: basic"
+  (ev "(mapcar (lambda (x) (* x 2)) '(1 2 3))")
+  (list 2 4 6))

lib/common-lisp/tests/lambda.sx

@@ -0,0 +1,204 @@
+;; Lambda list parser tests
+
+(define cl-test-pass 0)
+(define cl-test-fail 0)
+(define cl-test-fails (list))
+
+;; Deep structural equality for dicts and lists
+(define
+  cl-deep=
+  (fn
+    (a b)
+    (cond
+      ((= a b) true)
+      ((and (dict? a) (dict? b))
+        (let
+          ((ak (keys a)) (bk (keys b)))
+          (if
+            (not (= (len ak) (len bk)))
+            false
+            (every?
+              (fn (k) (and (has-key? b k) (cl-deep= (get a k) (get b k))))
+              ak))))
+      ((and (list? a) (list? b))
+        (if
+          (not (= (len a) (len b)))
+          false
+          (let
+            ((i 0) (ok true))
+            (define
+              chk
+              (fn
+                ()
+                (when
+                  (and ok (< i (len a)))
+                  (do
+                    (when
+                      (not (cl-deep= (nth a i) (nth b i)))
+                      (set! ok false))
+                    (set! i (+ i 1))
+                    (chk)))))
+            (chk)
+            ok)))
+      (:else false))))
+
+(define
+  cl-test
+  (fn
+    (name actual expected)
+    (if
+      (cl-deep= actual expected)
+      (set! cl-test-pass (+ cl-test-pass 1))
+      (do
+        (set! cl-test-fail (+ cl-test-fail 1))
+        (append! cl-test-fails {:name name :expected expected :actual actual})))))
+
+;; Helper: parse lambda list from string "(x y ...)"
+(define ll (fn (src) (cl-parse-lambda-list-str src)))
+(define ll-req  (fn (src) (get (ll src) "required")))
+(define ll-opt  (fn (src) (get (ll src) "optional")))
+(define ll-rest (fn (src) (get (ll src) "rest")))
+(define ll-key  (fn (src) (get (ll src) "key")))
+(define ll-aok  (fn (src) (get (ll src) "allow-other-keys")))
+(define ll-aux  (fn (src) (get (ll src) "aux")))
+
+;; ── required parameters ───────────────────────────────────────────
+
+(cl-test "required: empty" (ll-req "()") (list))
+(cl-test "required: one" (ll-req "(x)") (list "X"))
+(cl-test "required: two" (ll-req "(x y)") (list "X" "Y"))
+(cl-test "required: three" (ll-req "(a b c)") (list "A" "B" "C"))
+(cl-test "required: upcased" (ll-req "(foo bar)") (list "FOO" "BAR"))
+
+;; ── &optional ─────────────────────────────────────────────────────
+
+(cl-test "optional: none" (ll-opt "(x)") (list))
+
+(cl-test
+  "optional: bare symbol"
+  (ll-opt "(x &optional z)")
+  (list {:name "Z" :default nil :supplied nil}))
+
+(cl-test
+  "optional: with default"
+  (ll-opt "(x &optional (z 0))")
+  (list {:name "Z" :default 0 :supplied nil}))
+
+(cl-test
+  "optional: with supplied-p"
+  (ll-opt "(x &optional (z 0 z-p))")
+  (list {:name "Z" :default 0 :supplied "Z-P"}))
+
+(cl-test
+  "optional: two params"
+  (ll-opt "(&optional a (b 1))")
+  (list {:name "A" :default nil :supplied nil} {:name "B" :default 1 :supplied nil}))
+
+(cl-test
+  "optional: string default"
+  (ll-opt "(&optional (name \"world\"))")
+  (list {:name "NAME" :default {:cl-type "string" :value "world"} :supplied nil}))
+
+;; ── &rest ─────────────────────────────────────────────────────────
+
+(cl-test "rest: none" (ll-rest "(x)") nil)
+(cl-test "rest: present" (ll-rest "(x &rest args)") "ARGS")
+(cl-test "rest: with required" (ll-rest "(a b &rest tail)") "TAIL")
+
+;; &body is an alias for &rest
+(cl-test "body: alias for rest" (ll-rest "(&body forms)") "FORMS")
+
+;; rest doesn't consume required params
+(cl-test "rest: required still there" (ll-req "(a b &rest rest)") (list "A" "B"))
+
+;; ── &key ──────────────────────────────────────────────────────────
+
+(cl-test "key: none" (ll-key "(x)") (list))
+
+(cl-test
+  "key: bare symbol"
+  (ll-key "(&key x)")
+  (list {:name "X" :keyword "X" :default nil :supplied nil}))
+
+(cl-test
+  "key: with default"
+  (ll-key "(&key (x 42))")
+  (list {:name "X" :keyword "X" :default 42 :supplied nil}))
+
+(cl-test
+  "key: with supplied-p"
+  (ll-key "(&key (x 42 x-p))")
+  (list {:name "X" :keyword "X" :default 42 :supplied "X-P"}))
+
+(cl-test
+  "key: two params"
+  (ll-key "(&key a b)")
+  (list
+    {:name "A" :keyword "A" :default nil :supplied nil}
+    {:name "B" :keyword "B" :default nil :supplied nil}))
+
+;; ── &allow-other-keys ─────────────────────────────────────────────
+
+(cl-test "aok: absent" (ll-aok "(x)") false)
+(cl-test "aok: present" (ll-aok "(&key x &allow-other-keys)") true)
+
+;; ── &aux ──────────────────────────────────────────────────────────
+
+(cl-test "aux: none" (ll-aux "(x)") (list))
+
+(cl-test
+  "aux: bare symbol"
+  (ll-aux "(&aux temp)")
+  (list {:name "TEMP" :init nil}))
+
+(cl-test
+  "aux: with init"
+  (ll-aux "(&aux (count 0))")
+  (list {:name "COUNT" :init 0}))
+
+(cl-test
+  "aux: two vars"
+  (ll-aux "(&aux a (b 1))")
+  (list {:name "A" :init nil} {:name "B" :init 1}))
+
+;; ── combined ──────────────────────────────────────────────────────
+
+(cl-test
+  "combined: full lambda list"
+  (let
+    ((parsed (ll "(x y &optional (z 0 z-p) &rest args &key a (b nil b-p) &aux temp)")))
+    (list
+      (get parsed "required")
+      (get (nth (get parsed "optional") 0) "name")
+      (get (nth (get parsed "optional") 0) "default")
+      (get (nth (get parsed "optional") 0) "supplied")
+      (get parsed "rest")
+      (get (nth (get parsed "key") 0) "name")
+      (get (nth (get parsed "key") 1) "supplied")
+      (get (nth (get parsed "aux") 0) "name")))
+  (list
+    (list "X" "Y")
+    "Z"
+    0
+    "Z-P"
+    "ARGS"
+    "A"
+    "B-P"
+    "TEMP"))
+
+(cl-test
+  "combined: required only stops before &"
+  (ll-req "(a b &optional c)")
+  (list "A" "B"))
+
+(cl-test
+  "combined: required only with &key"
+  (ll-req "(x &key y)")
+  (list "X"))
+
+(cl-test
+  "combined: &rest and &key together"
+  (let
+    ((parsed (ll "(&rest args &key verbose)")))
+    (list (get parsed "rest") (get (nth (get parsed "key") 0) "name")))
+  (list "ARGS" "VERBOSE"))

lib/common-lisp/tests/parse.sx

@@ -0,0 +1,160 @@
+;; Common Lisp reader/parser tests
+
+(define cl-test-pass 0)
+(define cl-test-fail 0)
+(define cl-test-fails (list))
+
+(define
+  cl-deep=
+  (fn
+    (a b)
+    (cond
+      ((= a b) true)
+      ((and (dict? a) (dict? b))
+        (let
+          ((ak (keys a)) (bk (keys b)))
+          (if
+            (not (= (len ak) (len bk)))
+            false
+            (every?
+              (fn (k) (and (has-key? b k) (cl-deep= (get a k) (get b k))))
+              ak))))
+      ((and (list? a) (list? b))
+        (if
+          (not (= (len a) (len b)))
+          false
+          (let
+            ((i 0) (ok true))
+            (define
+              chk
+              (fn
+                ()
+                (when
+                  (and ok (< i (len a)))
+                  (do
+                    (when
+                      (not (cl-deep= (nth a i) (nth b i)))
+                      (set! ok false))
+                    (set! i (+ i 1))
+                    (chk)))))
+            (chk)
+            ok)))
+      (:else false))))
+
+(define
+  cl-test
+  (fn
+    (name actual expected)
+    (if
+      (cl-deep= actual expected)
+      (set! cl-test-pass (+ cl-test-pass 1))
+      (do
+        (set! cl-test-fail (+ cl-test-fail 1))
+        (append! cl-test-fails {:name name :expected expected :actual actual})))))
+
+;; ── atoms ─────────────────────────────────────────────────────────
+
+(cl-test "integer: 42" (cl-read "42") 42)
+(cl-test "integer: 0" (cl-read "0") 0)
+(cl-test "integer: negative" (cl-read "-5") -5)
+(cl-test "integer: positive sign" (cl-read "+3") 3)
+(cl-test "integer: hex #xFF" (cl-read "#xFF") 255)
+(cl-test "integer: hex #xAB" (cl-read "#xAB") 171)
+(cl-test "integer: binary #b1010" (cl-read "#b1010") 10)
+(cl-test "integer: octal #o17" (cl-read "#o17") 15)
+
+(cl-test "float: type" (get (cl-read "3.14") "cl-type") "float")
+(cl-test "float: value" (get (cl-read "3.14") "value") "3.14")
+(cl-test "float: neg" (get (cl-read "-2.5") "value") "-2.5")
+(cl-test "float: exp" (get (cl-read "1.0e10") "value") "1.0e10")
+
+(cl-test "ratio: type" (get (cl-read "1/3") "cl-type") "ratio")
+(cl-test "ratio: value" (get (cl-read "1/3") "value") "1/3")
+(cl-test "ratio: 22/7" (get (cl-read "22/7") "value") "22/7")
+
+(cl-test "string: basic" (cl-read "\"hello\"") {:cl-type "string" :value "hello"})
+(cl-test "string: empty" (cl-read "\"\"") {:cl-type "string" :value ""})
+(cl-test "string: with escape" (cl-read "\"a\\nb\"") {:cl-type "string" :value "a\nb"})
+
+(cl-test "symbol: foo" (cl-read "foo") "FOO")
+(cl-test "symbol: BAR" (cl-read "BAR") "BAR")
+(cl-test "symbol: pkg:sym" (cl-read "cl:car") "CL:CAR")
+(cl-test "symbol: pkg::sym" (cl-read "pkg::foo") "PKG::FOO")
+
+(cl-test "nil: symbol" (cl-read "nil") nil)
+(cl-test "nil: uppercase" (cl-read "NIL") nil)
+(cl-test "t: symbol" (cl-read "t") true)
+(cl-test "t: uppercase" (cl-read "T") true)
+
+(cl-test "keyword: type" (get (cl-read ":foo") "cl-type") "keyword")
+(cl-test "keyword: name" (get (cl-read ":foo") "name") "FOO")
+(cl-test "keyword: :test" (get (cl-read ":test") "name") "TEST")
+
+(cl-test "char: type" (get (cl-read "#\\a") "cl-type") "char")
+(cl-test "char: value" (get (cl-read "#\\a") "value") "a")
+(cl-test "char: Space" (get (cl-read "#\\Space") "value") " ")
+(cl-test "char: Newline" (get (cl-read "#\\Newline") "value") "\n")
+
+(cl-test "uninterned: type" (get (cl-read "#:foo") "cl-type") "uninterned")
+(cl-test "uninterned: name" (get (cl-read "#:foo") "name") "FOO")
+
+;; ── lists ─────────────────────────────────────────────────────────
+
+(cl-test "list: empty" (cl-read "()") (list))
+(cl-test "list: one element" (cl-read "(foo)") (list "FOO"))
+(cl-test "list: two elements" (cl-read "(foo bar)") (list "FOO" "BAR"))
+(cl-test "list: nested" (cl-read "((a b) c)") (list (list "A" "B") "C"))
+(cl-test "list: with integer" (cl-read "(+ 1 2)") (list "+" 1 2))
+(cl-test "list: with string" (cl-read "(print \"hi\")") (list "PRINT" {:cl-type "string" :value "hi"}))
+(cl-test "list: nil element" (cl-read "(a nil b)") (list "A" nil "B"))
+(cl-test "list: t element" (cl-read "(a t b)") (list "A" true "B"))
+
+;; ── dotted pairs ──────────────────────────────────────────────<E29480><E29480>──
+
+(cl-test "dotted: type" (get (cl-read "(a . b)") "cl-type") "cons")
+(cl-test "dotted: car" (get (cl-read "(a . b)") "car") "A")
+(cl-test "dotted: cdr" (get (cl-read "(a . b)") "cdr") "B")
+(cl-test "dotted: number cdr" (get (cl-read "(x . 42)") "cdr") 42)
+
+;; ── reader macros ────────────────────────────────────────────────<E29480><E29480>
+
+(cl-test "quote: form" (cl-read "'x") (list "QUOTE" "X"))
+(cl-test "quote: list" (cl-read "'(a b)") (list "QUOTE" (list "A" "B")))
+(cl-test "backquote: form" (cl-read "`x") (list "QUASIQUOTE" "X"))
+(cl-test "unquote: form" (cl-read ",x") (list "UNQUOTE" "X"))
+(cl-test "comma-at: form" (cl-read ",@x") (list "UNQUOTE-SPLICING" "X"))
+(cl-test "function: form" (cl-read "#'foo") (list "FUNCTION" "FOO"))
+
+;; ── vector ────────────────────────────────────────────────────────
+
+(cl-test "vector: type" (get (cl-read "#(1 2 3)") "cl-type") "vector")
+(cl-test "vector: elements" (get (cl-read "#(1 2 3)") "elements") (list 1 2 3))
+(cl-test "vector: empty" (get (cl-read "#()") "elements") (list))
+(cl-test "vector: mixed" (get (cl-read "#(a 1 \"s\")") "elements") (list "A" 1 {:cl-type "string" :value "s"}))
+
+;; ── cl-read-all ───────────────────────────────────────────────────
+
+(cl-test
+  "read-all: empty"
+  (cl-read-all "")
+  (list))
+
+(cl-test
+  "read-all: two forms"
+  (cl-read-all "42 foo")
+  (list 42 "FOO"))
+
+(cl-test
+  "read-all: three forms"
+  (cl-read-all "(+ 1 2) (+ 3 4) hello")
+  (list (list "+" 1 2) (list "+" 3 4) "HELLO"))
+
+(cl-test
+  "read-all: with comments"
+  (cl-read-all "; this is a comment\n42 ; inline\nfoo")
+  (list 42 "FOO"))
+
+(cl-test
+  "read-all: defun form"
+  (nth (cl-read-all "(defun square (x) (* x x))") 0)
+  (list "DEFUN" "SQUARE" (list "X") (list "*" "X" "X")))

lib/common-lisp/tests/read.sx

@@ -0,0 +1,180 @@
+;; Common Lisp tokenizer tests
+
+(define cl-test-pass 0)
+(define cl-test-fail 0)
+(define cl-test-fails (list))
+
+(define
+  cl-test
+  (fn
+    (name actual expected)
+    (if
+      (= actual expected)
+      (set! cl-test-pass (+ cl-test-pass 1))
+      (do
+        (set! cl-test-fail (+ cl-test-fail 1))
+        (append! cl-test-fails {:name name :expected expected :actual actual})))))
+
+;; Helpers: extract types and values from token stream (drops eof)
+(define
+  cl-tok-types
+  (fn
+    (src)
+    (map
+      (fn (t) (get t "type"))
+      (filter (fn (t) (not (= (get t "type") "eof"))) (cl-tokenize src)))))
+
+(define
+  cl-tok-values
+  (fn
+    (src)
+    (map
+      (fn (t) (get t "value"))
+      (filter (fn (t) (not (= (get t "type") "eof"))) (cl-tokenize src)))))
+
+(define
+  cl-tok-first
+  (fn (src) (nth (cl-tokenize src) 0)))
+
+;; ── symbols ───────────────────────────────────────────────────────
+
+(cl-test "symbol: bare lowercase" (cl-tok-values "foo") (list "FOO"))
+(cl-test "symbol: uppercase" (cl-tok-values "BAR") (list "BAR"))
+(cl-test "symbol: mixed case folded" (cl-tok-values "FooBar") (list "FOOBAR"))
+(cl-test "symbol: with hyphen" (cl-tok-values "foo-bar") (list "FOO-BAR"))
+(cl-test "symbol: with star" (cl-tok-values "*special*") (list "*SPECIAL*"))
+(cl-test "symbol: with question" (cl-tok-values "null?") (list "NULL?"))
+(cl-test "symbol: with exclamation" (cl-tok-values "set!") (list "SET!"))
+(cl-test "symbol: plus sign alone" (cl-tok-values "+") (list "+"))
+(cl-test "symbol: minus sign alone" (cl-tok-values "-") (list "-"))
+(cl-test "symbol: type is symbol" (cl-tok-types "foo") (list "symbol"))
+
+;; ── package-qualified symbols ─────────────────────────────────────
+
+(cl-test "symbol: pkg:sym external" (cl-tok-values "cl:car") (list "CL:CAR"))
+(cl-test "symbol: pkg::sym internal" (cl-tok-values "pkg::foo") (list "PKG::FOO"))
+(cl-test "symbol: cl:car type" (cl-tok-types "cl:car") (list "symbol"))
+
+;; ── keywords ──────────────────────────────────────────────────────
+
+(cl-test "keyword: basic" (cl-tok-values ":foo") (list "FOO"))
+(cl-test "keyword: type" (cl-tok-types ":foo") (list "keyword"))
+(cl-test "keyword: upcase" (cl-tok-values ":hello-world") (list "HELLO-WORLD"))
+(cl-test "keyword: multiple" (cl-tok-types ":a :b :c") (list "keyword" "keyword" "keyword"))
+
+;; ── integers ──────────────────────────────────────────────────────
+
+(cl-test "integer: zero" (cl-tok-values "0") (list "0"))
+(cl-test "integer: positive" (cl-tok-values "42") (list "42"))
+(cl-test "integer: negative" (cl-tok-values "-5") (list "-5"))
+(cl-test "integer: positive-sign" (cl-tok-values "+3") (list "+3"))
+(cl-test "integer: type" (cl-tok-types "42") (list "integer"))
+(cl-test "integer: multi-digit" (cl-tok-values "12345678") (list "12345678"))
+
+;; ── hex, binary, octal ───────────────────────────────────────────
+
+(cl-test "hex: lowercase x" (cl-tok-values "#xFF") (list "#xFF"))
+(cl-test "hex: uppercase X" (cl-tok-values "#XFF") (list "#XFF"))
+(cl-test "hex: type" (cl-tok-types "#xFF") (list "integer"))
+(cl-test "hex: zero" (cl-tok-values "#x0") (list "#x0"))
+(cl-test "binary: #b" (cl-tok-values "#b1010") (list "#b1010"))
+(cl-test "binary: type" (cl-tok-types "#b1010") (list "integer"))
+(cl-test "octal: #o" (cl-tok-values "#o17") (list "#o17"))
+(cl-test "octal: type" (cl-tok-types "#o17") (list "integer"))
+
+;; ── floats ────────────────────────────────────────────────────────
+
+(cl-test "float: basic" (cl-tok-values "3.14") (list "3.14"))
+(cl-test "float: type" (cl-tok-types "3.14") (list "float"))
+(cl-test "float: negative" (cl-tok-values "-2.5") (list "-2.5"))
+(cl-test "float: exponent" (cl-tok-values "1.0e10") (list "1.0e10"))
+(cl-test "float: neg exponent" (cl-tok-values "1.5e-3") (list "1.5e-3"))
+(cl-test "float: leading dot" (cl-tok-values ".5") (list "0.5"))
+(cl-test "float: exp only" (cl-tok-values "1e5") (list "1e5"))
+
+;; ── ratios ────────────────────────────────────────────────────────
+
+(cl-test "ratio: 1/3" (cl-tok-values "1/3") (list "1/3"))
+(cl-test "ratio: type" (cl-tok-types "1/3") (list "ratio"))
+(cl-test "ratio: 22/7" (cl-tok-values "22/7") (list "22/7"))
+(cl-test "ratio: negative" (cl-tok-values "-1/2") (list "-1/2"))
+
+;; ── strings ───────────────────────────────────────────────────────
+
+(cl-test "string: empty" (cl-tok-values "\"\"") (list ""))
+(cl-test "string: basic" (cl-tok-values "\"hello\"") (list "hello"))
+(cl-test "string: type" (cl-tok-types "\"hello\"") (list "string"))
+(cl-test "string: with space" (cl-tok-values "\"hello world\"") (list "hello world"))
+(cl-test "string: escaped quote" (cl-tok-values "\"say \\\"hi\\\"\"") (list "say \"hi\""))
+(cl-test "string: escaped backslash" (cl-tok-values "\"a\\\\b\"") (list "a\\b"))
+(cl-test "string: newline escape" (cl-tok-values "\"a\\nb\"") (list "a\nb"))
+(cl-test "string: tab escape" (cl-tok-values "\"a\\tb\"") (list "a\tb"))
+
+;; ── characters ────────────────────────────────────────────────────
+
+(cl-test "char: lowercase a" (cl-tok-values "#\\a") (list "a"))
+(cl-test "char: uppercase A" (cl-tok-values "#\\A") (list "A"))
+(cl-test "char: digit" (cl-tok-values "#\\1") (list "1"))
+(cl-test "char: type" (cl-tok-types "#\\a") (list "char"))
+(cl-test "char: Space" (cl-tok-values "#\\Space") (list " "))
+(cl-test "char: Newline" (cl-tok-values "#\\Newline") (list "\n"))
+(cl-test "char: Tab" (cl-tok-values "#\\Tab") (list "\t"))
+(cl-test "char: Return" (cl-tok-values "#\\Return") (list "\r"))
+
+;; ── reader macros ─────────────────────────────────────────────────
+
+(cl-test "quote: type" (cl-tok-types "'x") (list "quote" "symbol"))
+(cl-test "backquote: type" (cl-tok-types "`x") (list "backquote" "symbol"))
+(cl-test "comma: type" (cl-tok-types ",x") (list "comma" "symbol"))
+(cl-test "comma-at: type" (cl-tok-types ",@x") (list "comma-at" "symbol"))
+(cl-test "hash-quote: type" (cl-tok-types "#'foo") (list "hash-quote" "symbol"))
+(cl-test "hash-paren: type" (cl-tok-types "#(1 2)") (list "hash-paren" "integer" "integer" "rparen"))
+
+;; ── uninterned ────────────────────────────────────────────────────
+
+(cl-test "uninterned: type" (cl-tok-types "#:foo") (list "uninterned"))
+(cl-test "uninterned: value upcase" (cl-tok-values "#:foo") (list "FOO"))
+(cl-test "uninterned: compound" (cl-tok-values "#:my-sym") (list "MY-SYM"))
+
+;; ── parens and structure ──────────────────────────────────────────
+
+(cl-test "paren: empty list" (cl-tok-types "()") (list "lparen" "rparen"))
+(cl-test "paren: nested" (cl-tok-types "((a))") (list "lparen" "lparen" "symbol" "rparen" "rparen"))
+(cl-test "dot: standalone" (cl-tok-types "(a . b)") (list "lparen" "symbol" "dot" "symbol" "rparen"))
+
+;; ── comments ──────────────────────────────────────────────────────
+
+(cl-test "comment: line" (cl-tok-types "; comment\nfoo") (list "symbol"))
+(cl-test "comment: inline" (cl-tok-values "foo ; bar\nbaz") (list "FOO" "BAZ"))
+(cl-test "block-comment: basic" (cl-tok-types "#| hello |# foo") (list "symbol"))
+(cl-test "block-comment: nested" (cl-tok-types "#| a #| b |# c |# x") (list "symbol"))
+
+;; ── combined ──────────────────────────────────────────────────────
+
+(cl-test
+  "combined: defun skeleton"
+  (cl-tok-types "(defun foo (x) x)")
+  (list "lparen" "symbol" "symbol" "lparen" "symbol" "rparen" "symbol" "rparen"))
+
+(cl-test
+  "combined: let form"
+  (cl-tok-types "(let ((x 1)) x)")
+  (list
+    "lparen"
+    "symbol"
+    "lparen"
+    "lparen"
+    "symbol"
+    "integer"
+    "rparen"
+    "rparen"
+    "symbol"
+    "rparen"))
+
+(cl-test
+  "combined: whitespace skip"
+  (cl-tok-values "  foo   bar   baz  ")
+  (list "FOO" "BAR" "BAZ"))
+
+(cl-test "eof: present" (get (nth (cl-tokenize "") 0) "type") "eof")
+(cl-test "eof: at end of tokens" (get (nth (cl-tokenize "x") 1) "type") "eof")

lib/prolog/compiler.sx

@@ -1,176 +0,0 @@
-;; lib/prolog/compiler.sx — clause compiler: parse-AST clauses → SX closures
-;;
-;; Each compiled clause is a lambda (fn (goal trail db cut-box k) bool)
-;; that creates fresh vars, builds the instantiated head/body, and calls
-;; pl-unify! + pl-solve! directly — no AST walk at solve time.
-;;
-;; Usage:
-;;   (pl-db-load! db (pl-parse src))
-;;   (pl-compile-db! db)
-;;   ; pl-solve-user! in runtime.sx automatically prefers compiled clauses
-;;   (pl-solve-once! db goal trail)
-
-;; Collect unique variable names from a parse-AST clause into a dict.
-(define
-  pl-cmp-vars-into!
-  (fn
-    (ast seen)
-    (cond
-      ((not (list? ast)) nil)
-      ((empty? ast) nil)
-      ((= (first ast) "var")
-        (let
-          ((name (nth ast 1)))
-          (when
-            (and (not (= name "_")) (not (dict-has? seen name)))
-            (dict-set! seen name true))))
-      ((= (first ast) "compound")
-        (for-each (fn (a) (pl-cmp-vars-into! a seen)) (nth ast 2)))
-      ((= (first ast) "clause")
-        (begin
-          (pl-cmp-vars-into! (nth ast 1) seen)
-          (pl-cmp-vars-into! (nth ast 2) seen))))))
-
-;; Return list of unique var names in a clause (head + body, excluding _).
-(define
-  pl-cmp-collect-vars
-  (fn
-    (clause)
-    (let ((seen {})) (pl-cmp-vars-into! clause seen) (keys seen))))
-
-;; Create a fresh runtime var for each name in the list; return name->var dict.
-(define
-  pl-cmp-make-var-map
-  (fn
-    (var-names)
-    (let
-      ((m {}))
-      (for-each
-        (fn (name) (dict-set! m name (pl-mk-rt-var name)))
-        var-names)
-      m)))
-
-;; Instantiate a parse-AST term using a pre-built var-map.
-;; ("var" "_") always gets a fresh anonymous var.
-(define
-  pl-cmp-build-term
-  (fn
-    (ast var-map)
-    (cond
-      ((pl-var? ast) ast)
-      ((not (list? ast)) ast)
-      ((empty? ast) ast)
-      ((= (first ast) "var")
-        (let
-          ((name (nth ast 1)))
-          (if (= name "_") (pl-mk-rt-var "_") (dict-get var-map name))))
-      ((or (= (first ast) "atom") (= (first ast) "num") (= (first ast) "str"))
-        ast)
-      ((= (first ast) "compound")
-        (list
-          "compound"
-          (nth ast 1)
-          (map (fn (a) (pl-cmp-build-term a var-map)) (nth ast 2))))
-      ((= (first ast) "clause")
-        (list
-          "clause"
-          (pl-cmp-build-term (nth ast 1) var-map)
-          (pl-cmp-build-term (nth ast 2) var-map)))
-      (true ast))))
-
-;; Compile one parse-AST clause to a lambda.
-;; Pre-computes var names at compile time; creates fresh vars per call.
-(define
-  pl-compile-clause
-  (fn
-    (clause)
-    (let
-      ((var-names (pl-cmp-collect-vars clause))
-        (head-ast (nth clause 1))
-        (body-ast (nth clause 2)))
-      (fn
-        (goal trail db cut-box k)
-        (let
-          ((var-map (pl-cmp-make-var-map var-names)))
-          (let
-            ((fresh-head (pl-cmp-build-term head-ast var-map))
-              (fresh-body (pl-cmp-build-term body-ast var-map)))
-            (let
-              ((mark (pl-trail-mark trail)))
-              (if
-                (pl-unify! goal fresh-head trail)
-                (let
-                  ((r (pl-solve! db fresh-body trail cut-box k)))
-                  (if r true (begin (pl-trail-undo-to! trail mark) false)))
-                (begin (pl-trail-undo-to! trail mark) false)))))))))
-
-;; Try a list of compiled clause lambdas — same cut semantics as pl-try-clauses!.
-(define
-  pl-try-compiled-clauses!
-  (fn
-    (db
-      goal
-      trail
-      compiled-clauses
-      outer-cut-box
-      outer-was-cut
-      inner-cut-box
-      k)
-    (cond
-      ((empty? compiled-clauses) false)
-      (true
-        (let
-          ((r ((first compiled-clauses) goal trail db inner-cut-box k)))
-          (cond
-            (r true)
-            ((dict-get inner-cut-box :cut) false)
-            ((and (not outer-was-cut) (dict-get outer-cut-box :cut)) false)
-            (true
-              (pl-try-compiled-clauses!
-                db
-                goal
-                trail
-                (rest compiled-clauses)
-                outer-cut-box
-                outer-was-cut
-                inner-cut-box
-                k))))))))
-
-;; Compile all clauses in DB and store in :compiled table.
-;; After this call, pl-solve-user! will dispatch via compiled lambdas.
-;; Note: clauses assert!-ed after this call are not compiled.
-(define
-  pl-compile-db!
-  (fn
-    (db)
-    (let
-      ((src-table (dict-get db :clauses)) (compiled-table {}))
-      (for-each
-        (fn
-          (key)
-          (dict-set!
-            compiled-table
-            key
-            (map pl-compile-clause (dict-get src-table key))))
-        (keys src-table))
-      (dict-set! db :compiled compiled-table)
-      db)))
-
-;; Cross-validate: load src into both a plain and a compiled DB,
-;; run goal-str through each, return true iff solution counts match.
-;; Use this to keep the interpreter as the reference implementation.
-(define
-  pl-compiled-matches-interp?
-  (fn
-    (src goal-str)
-    (let
-      ((db-interp (pl-mk-db)) (db-comp (pl-mk-db)))
-      (pl-db-load! db-interp (pl-parse src))
-      (pl-db-load! db-comp (pl-parse src))
-      (pl-compile-db! db-comp)
-      (let
-        ((gi (pl-instantiate (pl-parse-goal goal-str) {}))
-          (gc (pl-instantiate (pl-parse-goal goal-str) {})))
-        (=
-          (pl-solve-count! db-interp gi (pl-mk-trail))
-          (pl-solve-count! db-comp gc (pl-mk-trail)))))))

lib/prolog/conformance.sh

@@ -1,126 +0,0 @@
-#!/usr/bin/env bash
-# Run every Prolog test suite via sx_server and refresh scoreboard.{json,md}.
-# Exit 0 if all green, 1 if any failures.
-set -euo pipefail
-
-HERE="$(cd "$(dirname "$0")" && pwd)"
-ROOT="$(cd "$HERE/../.." && pwd)"
-SX="${SX_SERVER:-/root/rose-ash/hosts/ocaml/_build/default/bin/sx_server.exe}"
-
-if [[ ! -x "$SX" ]]; then
-  echo "sx_server not found at $SX (set SX_SERVER env to override)" >&2
-  exit 2
-fi
-
-cd "$ROOT"
-
-# name : test-file : runner-fn
-SUITES=(
-  "parse:lib/prolog/tests/parse.sx:pl-parse-tests-run!"
-  "unify:lib/prolog/tests/unify.sx:pl-unify-tests-run!"
-  "clausedb:lib/prolog/tests/clausedb.sx:pl-clausedb-tests-run!"
-  "solve:lib/prolog/tests/solve.sx:pl-solve-tests-run!"
-  "operators:lib/prolog/tests/operators.sx:pl-operators-tests-run!"
-  "dynamic:lib/prolog/tests/dynamic.sx:pl-dynamic-tests-run!"
-  "findall:lib/prolog/tests/findall.sx:pl-findall-tests-run!"
-  "term_inspect:lib/prolog/tests/term_inspect.sx:pl-term-inspect-tests-run!"
-  "append:lib/prolog/tests/programs/append.sx:pl-append-tests-run!"
-  "reverse:lib/prolog/tests/programs/reverse.sx:pl-reverse-tests-run!"
-  "member:lib/prolog/tests/programs/member.sx:pl-member-tests-run!"
-  "nqueens:lib/prolog/tests/programs/nqueens.sx:pl-nqueens-tests-run!"
-  "family:lib/prolog/tests/programs/family.sx:pl-family-tests-run!"
-  "atoms:lib/prolog/tests/atoms.sx:pl-atom-tests-run!"
-  "query_api:lib/prolog/tests/query_api.sx:pl-query-api-tests-run!"
-  "iso_predicates:lib/prolog/tests/iso_predicates.sx:pl-iso-predicates-tests-run!"
-  "meta_predicates:lib/prolog/tests/meta_predicates.sx:pl-meta-predicates-tests-run!"
-  "list_predicates:lib/prolog/tests/list_predicates.sx:pl-list-predicates-tests-run!"
-  "meta_call:lib/prolog/tests/meta_call.sx:pl-meta-call-tests-run!"
-  "set_predicates:lib/prolog/tests/set_predicates.sx:pl-set-predicates-tests-run!"
-  "char_predicates:lib/prolog/tests/char_predicates.sx:pl-char-predicates-tests-run!"
-  "io_predicates:lib/prolog/tests/io_predicates.sx:pl-io-predicates-tests-run!"
-  "assert_rules:lib/prolog/tests/assert_rules.sx:pl-assert-rules-tests-run!"
-  "string_agg:lib/prolog/tests/string_agg.sx:pl-string-agg-tests-run!"
-  "advanced:lib/prolog/tests/advanced.sx:pl-advanced-tests-run!"
-  "compiler:lib/prolog/tests/compiler.sx:pl-compiler-tests-run!"
-  "cross_validate:lib/prolog/tests/cross_validate.sx:pl-cross-validate-tests-run!"
-)
-
-SCRIPT='(epoch 1)
-(load "lib/prolog/tokenizer.sx")
-(load "lib/prolog/parser.sx")
-(load "lib/prolog/runtime.sx")
-(load "lib/prolog/query.sx")
-(load "lib/prolog/compiler.sx")'
-for entry in "${SUITES[@]}"; do
-  IFS=: read -r _ file _ <<< "$entry"
-  SCRIPT+=$'\n(load "'"$file"$'")'
-done
-for entry in "${SUITES[@]}"; do
-  IFS=: read -r _ _ fn <<< "$entry"
-  SCRIPT+=$'\n(eval "('"$fn"$')")'
-done
-
-OUTPUT="$(printf '%s\n' "$SCRIPT" | "$SX" 2>&1)"
-
-mapfile -t LINES < <(printf '%s\n' "$OUTPUT" | grep -E '^\{:failed')
-
-if [[ ${#LINES[@]} -ne ${#SUITES[@]} ]]; then
-  echo "Expected ${#SUITES[@]} suite results, got ${#LINES[@]}" >&2
-  echo "---- raw output ----" >&2
-  printf '%s\n' "$OUTPUT" >&2
-  exit 3
-fi
-
-TOTAL_PASS=0
-TOTAL_FAIL=0
-TOTAL=0
-JSON_SUITES=""
-MD_ROWS=""
-
-for i in "${!SUITES[@]}"; do
-  IFS=: read -r name _ _ <<< "${SUITES[$i]}"
-  line="${LINES[$i]}"
-  passed=$(grep -oE ':passed [0-9]+' <<< "$line" | grep -oE '[0-9]+')
-  total=$(grep -oE ':total [0-9]+' <<< "$line" | grep -oE '[0-9]+')
-  failed=$(grep -oE ':failed [0-9]+' <<< "$line" | grep -oE '[0-9]+')
-  TOTAL_PASS=$((TOTAL_PASS + passed))
-  TOTAL_FAIL=$((TOTAL_FAIL + failed))
-  TOTAL=$((TOTAL + total))
-  status="ok"
-  [[ "$failed" -gt 0 ]] && status="FAIL"
-  [[ -n "$JSON_SUITES" ]] && JSON_SUITES+=","
-  JSON_SUITES+="\"$name\":{\"passed\":$passed,\"total\":$total,\"failed\":$failed}"
-  MD_ROWS+="| $name | $passed | $total | $status |"$'\n'
-done
-
-WHEN="$(date -Iseconds 2>/dev/null || date)"
-
-cat > "$HERE/scoreboard.json" <<JSON
-{
-  "total_passed": $TOTAL_PASS,
-  "total_failed": $TOTAL_FAIL,
-  "total": $TOTAL,
-  "suites": {$JSON_SUITES},
-  "generated": "$WHEN"
-}
-JSON
-
-cat > "$HERE/scoreboard.md" <<MD
-# Prolog scoreboard
-
-**$TOTAL_PASS / $TOTAL passing** ($TOTAL_FAIL failure(s)).
-Generated $WHEN.
-
-| Suite | Passed | Total | Status |
-|-------|--------|-------|--------|
-$MD_ROWS
-Run \`bash lib/prolog/conformance.sh\` to refresh. Override the binary
-with \`SX_SERVER=path/to/sx_server.exe bash …\`.
-MD
-
-if [[ "$TOTAL_FAIL" -gt 0 ]]; then
-  echo "$TOTAL_FAIL failure(s) across $TOTAL tests" >&2
-  exit 1
-fi
-
-echo "All $TOTAL tests pass."

lib/prolog/parser.sx

@@ -1,20 +1,28 @@
 ;; lib/prolog/parser.sx — tokens → Prolog AST
 ;;
-;; Phase 4 grammar (with operator table):
+;; Phase 1 grammar (NO operator table yet):
 ;;   Program      := Clause* EOF
-;;   Clause       := Term[999] "." | Term[999] ":-" Term[1200] "."
+;;   Clause       := Term "." | Term ":-" Term "."
-;;   Term[Pmax] uses precedence climbing on the operator table:
+;;   Term         := Atom | Var | Number | String | Compound | List
-;;     primary = Atom | Var | Number | String | Compound | List | "(" Term[1200] ")"
+;;   Compound     := atom "(" ArgList ")"
-;;     while next token is infix op `op` with prec(op) ≤ Pmax:
+;;   ArgList      := Term ("," Term)*
-;;       consume op; parse rhs at right-prec(op); fold into compound(op-name,[lhs,rhs])
+;;   List         := "[" "]" | "[" Term ("," Term)* ("|" Term)? "]"
 ;;
-;; Op type → right-prec for op at precedence P:
+;; Term AST shapes (all tagged lists for uniform dispatch):
-;;   xfx → P-1   strict-both
+;;   ("atom"  name)            — atom
-;;   xfy → P     right-associative
+;;   ("var"   name)            — variable template (parser-time only)
-;;   yfx → P-1   left-associative
+;;   ("num"   value)           — integer or float
+;;   ("str"   value)           — string literal
+;;   ("compound" functor args) — compound term, args is list of term-ASTs
+;;   ("cut")                   — the cut atom !
 ;;
-;; AST shapes are unchanged — operators just become compound terms.
+;; A clause is (list "clause" head body). A fact is head with body = ("atom" "true").
+;;
+;; The empty list is (atom "[]"). Cons is compound "." with two args:
+;; [1, 2, 3]   → .(1, .(2, .(3, [])))
+;; [H|T]       → .(H, T)
 
+;; ── Parser state helpers ────────────────────────────────────────────
 (define
   pp-peek
   (fn
@@ -58,6 +66,7 @@
             (if (= (get t :value) nil) "" (get t :value))
             "'"))))))
 
+;; ── AST constructors ────────────────────────────────────────────────
 (define pl-mk-atom (fn (name) (list "atom" name)))
 (define pl-mk-var (fn (name) (list "var" name)))
 (define pl-mk-num (fn (n) (list "num" n)))
@@ -65,14 +74,18 @@
 (define pl-mk-compound (fn (f args) (list "compound" f args)))
 (define pl-mk-cut (fn () (list "cut")))
 
+;; Term tag extractors
 (define pl-term-tag (fn (t) (if (list? t) (first t) nil)))
 (define pl-term-val (fn (t) (nth t 1)))
 (define pl-compound-functor (fn (t) (nth t 1)))
 (define pl-compound-args (fn (t) (nth t 2)))
 
+;; Empty-list atom and cons helpers
 (define pl-nil-term (fn () (pl-mk-atom "[]")))
+
 (define pl-mk-cons (fn (h t) (pl-mk-compound "." (list h t))))
 
+;; Build cons list from a list of terms + optional tail
 (define
   pl-mk-list-term
   (fn
@@ -82,61 +95,9 @@
       tail
       (pl-mk-cons (first items) (pl-mk-list-term (rest items) tail)))))
 
-;; ── Operator table (Phase 4) ──────────────────────────────────────
-;; Each entry: (name precedence type). Type ∈ "xfx" "xfy" "yfx".
-(define
-  pl-op-table
-  (list
-    (list "," 1000 "xfy")
-    (list ";" 1100 "xfy")
-    (list "->" 1050 "xfy")
-    (list "=" 700 "xfx")
-    (list "\\=" 700 "xfx")
-    (list "is" 700 "xfx")
-    (list "<" 700 "xfx")
-    (list ">" 700 "xfx")
-    (list "=<" 700 "xfx")
-    (list ">=" 700 "xfx")
-    (list "+" 500 "yfx")
-    (list "-" 500 "yfx")
-    (list "*" 400 "yfx")
-    (list "/" 400 "yfx")
-    (list ":-" 1200 "xfx")
-    (list "mod" 400 "yfx")))
-
-(define
-  pl-op-find
-  (fn
-    (name table)
-    (cond
-      ((empty? table) nil)
-      ((= (first (first table)) name) (rest (first table)))
-      (true (pl-op-find name (rest table))))))
-
-(define pl-op-lookup (fn (name) (pl-op-find name pl-op-table)))
-
-;; Token → (name prec type) for known infix ops, else nil.
-(define
-  pl-token-op
-  (fn
-    (t)
-    (let
-      ((ty (get t :type)) (vv (get t :value)))
-      (cond
-        ((and (= ty "punct") (= vv ","))
-          (let
-            ((info (pl-op-lookup ",")))
-            (if (nil? info) nil (cons "," info))))
-        ((or (= ty "atom") (= ty "op"))
-          (let
-            ((info (pl-op-lookup vv)))
-            (if (nil? info) nil (cons vv info))))
-        (true nil)))))
-
 ;; ── Term parser ─────────────────────────────────────────────────────
-;; Primary term: atom, var, num, str, compound (atom + paren), list, cut, parens.
 (define
-  pp-parse-primary
+  pp-parse-term
   (fn
     (st)
     (let
@@ -150,12 +111,6 @@
           ((and (= ty "op") (= vv "!"))
             (do (pp-advance! st) (pl-mk-cut)))
           ((and (= ty "punct") (= vv "[")) (pp-parse-list st))
-          ((and (= ty "punct") (= vv "("))
-            (do
-              (pp-advance! st)
-              (let
-                ((inner (pp-parse-term-prec st 1200)))
-                (do (pp-expect! st "punct" ")") inner))))
           ((= ty "atom")
             (do
               (pp-advance! st)
@@ -178,51 +133,13 @@
                 (if (= vv nil) "" vv)
                 "'"))))))))
 
-;; Operator-aware term parser: precedence climbing.
+;; Parse one or more comma-separated terms (arguments).
-(define
-  pp-parse-term-prec
-  (fn
-    (st max-prec)
-    (let ((left (pp-parse-primary st))) (pp-parse-op-rhs st left max-prec))))
-
-(define
-  pp-parse-op-rhs
-  (fn
-    (st left max-prec)
-    (let
-      ((op-info (pl-token-op (pp-peek st))))
-      (cond
-        ((nil? op-info) left)
-        (true
-          (let
-            ((name (first op-info))
-              (prec (nth op-info 1))
-              (ty (nth op-info 2)))
-            (cond
-              ((> prec max-prec) left)
-              (true
-                (let
-                  ((right-prec (if (= ty "xfy") prec (- prec 1))))
-                  (do
-                    (pp-advance! st)
-                    (let
-                      ((right (pp-parse-term-prec st right-prec)))
-                      (pp-parse-op-rhs
-                        st
-                        (pl-mk-compound name (list left right))
-                        max-prec))))))))))))
-
-;; Backwards-compat alias.
-(define pp-parse-term (fn (st) (pp-parse-term-prec st 999)))
-
-;; Args inside parens: parse at prec 999 so comma-as-operator (1000)
-;; is not consumed; the explicit comma loop handles separation.
 (define
   pp-parse-arg-list
   (fn
     (st)
     (let
-      ((first-arg (pp-parse-term-prec st 999)) (args (list)))
+      ((first-arg (pp-parse-term st)) (args (list)))
       (do
         (append! args first-arg)
         (define
@@ -233,12 +150,12 @@
               (pp-at? st "punct" ",")
               (do
                 (pp-advance! st)
-                (append! args (pp-parse-term-prec st 999))
+                (append! args (pp-parse-term st))
                 (loop)))))
         (loop)
         args))))
 
-;; List literal.
+;; Parse a [ ... ] list literal. Consumes the "[".
 (define
   pp-parse-list
   (fn
@@ -251,7 +168,7 @@
         (let
           ((items (list)))
           (do
-            (append! items (pp-parse-term-prec st 999))
+            (append! items (pp-parse-term st))
             (define
               comma-loop
               (fn
@@ -260,17 +177,52 @@
                   (pp-at? st "punct" ",")
                   (do
                     (pp-advance! st)
-                    (append! items (pp-parse-term-prec st 999))
+                    (append! items (pp-parse-term st))
                     (comma-loop)))))
             (comma-loop)
             (let
-              ((tail (if (pp-at? st "punct" "|") (do (pp-advance! st) (pp-parse-term-prec st 999)) (pl-nil-term))))
+              ((tail (if (pp-at? st "punct" "|") (do (pp-advance! st) (pp-parse-term st)) (pl-nil-term))))
               (do (pp-expect! st "punct" "]") (pl-mk-list-term items tail)))))))))
 
 ;; ── Body parsing ────────────────────────────────────────────────────
-;; A body is a single term parsed at prec 1200 — operator parser folds
+;; A clause body is a comma-separated list of goals. We flatten into a
-;; `,`, `;`, `->` automatically into right-associative compounds.
+;; right-associative `,` compound: (A, B, C) → ','(A, ','(B, C))
-(define pp-parse-body (fn (st) (pp-parse-term-prec st 1200)))
+;; If only one goal, it's that goal directly.
+(define
+  pp-parse-body
+  (fn
+    (st)
+    (let
+      ((first-goal (pp-parse-term st)) (rest-goals (list)))
+      (do
+        (define
+          gloop
+          (fn
+            ()
+            (when
+              (pp-at? st "punct" ",")
+              (do
+                (pp-advance! st)
+                (append! rest-goals (pp-parse-term st))
+                (gloop)))))
+        (gloop)
+        (if
+          (= (len rest-goals) 0)
+          first-goal
+          (pp-build-conj first-goal rest-goals))))))
+
+(define
+  pp-build-conj
+  (fn
+    (first-goal rest-goals)
+    (if
+      (= (len rest-goals) 0)
+      first-goal
+      (pl-mk-compound
+        ","
+        (list
+          first-goal
+          (pp-build-conj (first rest-goals) (rest rest-goals)))))))
 
 ;; ── Clause parsing ──────────────────────────────────────────────────
 (define
@@ -278,11 +230,12 @@
   (fn
     (st)
     (let
-      ((head (pp-parse-term-prec st 999)))
+      ((head (pp-parse-term st)))
       (let
         ((body (if (pp-at? st "op" ":-") (do (pp-advance! st) (pp-parse-body st)) (pl-mk-atom "true"))))
         (do (pp-expect! st "punct" ".") (list "clause" head body))))))
 
+;; Parse an entire program — returns list of clauses.
 (define
   pl-parse-program
   (fn
@@ -300,9 +253,13 @@
         (ploop)
         clauses))))
 
+;; Parse a single query term (no trailing "."). Returns the term.
 (define
   pl-parse-query
   (fn (tokens) (let ((st {:idx 0 :tokens tokens})) (pp-parse-body st))))
 
+;; Convenience: source → clauses
 (define pl-parse (fn (src) (pl-parse-program (pl-tokenize src))))
+
+;; Convenience: source → query term
 (define pl-parse-goal (fn (src) (pl-parse-query (pl-tokenize src))))

lib/prolog/query.sx

@@ -1,114 +0,0 @@
-;; lib/prolog/query.sx — high-level Prolog query API for SX/Hyperscript callers.
-;;
-;; Requires tokenizer.sx, parser.sx, runtime.sx to be loaded first.
-;;
-;; Public API:
-;;   (pl-load source-str)                → db
-;;   (pl-query-all db query-str)         → list of solution dicts {var-name → term-string}
-;;   (pl-query-one db query-str)         → first solution dict or nil
-;;   (pl-query source-str query-str)     → list of solution dicts (convenience)
-
-;; Collect variable name strings from a parse-time AST (pre-instantiation).
-;; Returns list of unique strings, excluding anonymous "_".
-(define
-  pl-query-extract-vars
-  (fn
-    (ast)
-    (let
-      ((seen {}))
-      (let
-        ((collect!
-          (fn
-            (t)
-            (cond
-              ((not (list? t)) nil)
-              ((empty? t) nil)
-              ((= (first t) "var")
-                (if
-                  (not (= (nth t 1) "_"))
-                  (dict-set! seen (nth t 1) true)
-                  nil))
-              ((= (first t) "compound")
-                (for-each collect! (nth t 2)))
-              (true nil)))))
-        (collect! ast)
-        (keys seen)))))
-
-;; Build a solution dict from a var-env after a successful solve.
-;; Maps each variable name string to its formatted term value.
-(define
-  pl-query-solution-dict
-  (fn
-    (var-names var-env)
-    (let
-      ((d {}))
-      (for-each
-        (fn (name) (dict-set! d name (pl-format-term (dict-get var-env name))))
-        var-names)
-      d)))
-
-;; Parse source-str and load clauses into a fresh DB.
-;; Returns the DB for reuse across multiple queries.
-(define
-  pl-load
-  (fn
-    (source-str)
-    (let
-      ((db (pl-mk-db)))
-      (if
-        (and (string? source-str) (not (= source-str "")))
-        (pl-db-load! db (pl-parse source-str))
-        nil)
-      db)))
-
-;; Run query-str against db, returning a list of solution dicts.
-;; Each dict maps variable name strings to their formatted term values.
-;; Returns an empty list if no solutions.
-(define
-  pl-query-all
-  (fn
-    (db query-str)
-    (let
-      ((parsed (pl-parse (str "q_ :- " query-str "."))))
-      (let
-        ((body-ast (nth (first parsed) 2)))
-        (let
-          ((var-names (pl-query-extract-vars body-ast))
-           (var-env {}))
-          (let
-            ((goal (pl-instantiate body-ast var-env))
-             (trail (pl-mk-trail))
-             (solutions (list)))
-            (let
-              ((mark (pl-trail-mark trail)))
-              (pl-solve!
-                db
-                goal
-                trail
-                {:cut false}
-                (fn
-                  ()
-                  (begin
-                    (append!
-                      solutions
-                      (pl-query-solution-dict var-names var-env))
-                    false)))
-              (pl-trail-undo-to! trail mark)
-              solutions)))))))
-
-;; Return the first solution dict, or nil if no solutions.
-(define
-  pl-query-one
-  (fn
-    (db query-str)
-    (let
-      ((all (pl-query-all db query-str)))
-      (if (empty? all) nil (first all)))))
-
-;; Convenience: parse source-str, then run query-str against it.
-;; Returns a list of solution dicts. Creates a fresh DB each call.
-(define
-  pl-query
-  (fn
-    (source-str query-str)
-    (pl-query-all (pl-load source-str) query-str)))

lib/prolog/scoreboard.json

@@ -1,7 +0,0 @@
-{
-  "total_passed": 517,
-  "total_failed": 0,
-  "total": 517,
-  "suites": {"parse":{"passed":25,"total":25,"failed":0},"unify":{"passed":47,"total":47,"failed":0},"clausedb":{"passed":14,"total":14,"failed":0},"solve":{"passed":62,"total":62,"failed":0},"operators":{"passed":19,"total":19,"failed":0},"dynamic":{"passed":11,"total":11,"failed":0},"findall":{"passed":11,"total":11,"failed":0},"term_inspect":{"passed":14,"total":14,"failed":0},"append":{"passed":6,"total":6,"failed":0},"reverse":{"passed":6,"total":6,"failed":0},"member":{"passed":7,"total":7,"failed":0},"nqueens":{"passed":6,"total":6,"failed":0},"family":{"passed":10,"total":10,"failed":0},"atoms":{"passed":34,"total":34,"failed":0},"query_api":{"passed":16,"total":16,"failed":0},"iso_predicates":{"passed":29,"total":29,"failed":0},"meta_predicates":{"passed":25,"total":25,"failed":0},"list_predicates":{"passed":33,"total":33,"failed":0},"meta_call":{"passed":15,"total":15,"failed":0},"set_predicates":{"passed":15,"total":15,"failed":0},"char_predicates":{"passed":27,"total":27,"failed":0},"io_predicates":{"passed":24,"total":24,"failed":0},"assert_rules":{"passed":15,"total":15,"failed":0},"string_agg":{"passed":25,"total":25,"failed":0},"advanced":{"passed":21,"total":21,"failed":0}},
-  "generated": "2026-04-25T14:12:52+00:00"
-}

lib/prolog/scoreboard.md

@@ -1,35 +0,0 @@
-# Prolog scoreboard
-
-**517 / 517 passing** (0 failure(s)).
-Generated 2026-04-25T14:12:52+00:00.
-
-| Suite | Passed | Total | Status |
-|-------|--------|-------|--------|
-| parse | 25 | 25 | ok |
-| unify | 47 | 47 | ok |
-| clausedb | 14 | 14 | ok |
-| solve | 62 | 62 | ok |
-| operators | 19 | 19 | ok |
-| dynamic | 11 | 11 | ok |
-| findall | 11 | 11 | ok |
-| term_inspect | 14 | 14 | ok |
-| append | 6 | 6 | ok |
-| reverse | 6 | 6 | ok |
-| member | 7 | 7 | ok |
-| nqueens | 6 | 6 | ok |
-| family | 10 | 10 | ok |
-| atoms | 34 | 34 | ok |
-| query_api | 16 | 16 | ok |
-| iso_predicates | 29 | 29 | ok |
-| meta_predicates | 25 | 25 | ok |
-| list_predicates | 33 | 33 | ok |
-| meta_call | 15 | 15 | ok |
-| set_predicates | 15 | 15 | ok |
-| char_predicates | 27 | 27 | ok |
-| io_predicates | 24 | 24 | ok |
-| assert_rules | 15 | 15 | ok |
-| string_agg | 25 | 25 | ok |
-| advanced | 21 | 21 | ok |
-
-Run `bash lib/prolog/conformance.sh` to refresh. Override the binary
-with `SX_SERVER=path/to/sx_server.exe bash …`.

lib/prolog/tests/advanced.sx

@@ -1,254 +0,0 @@
-;; lib/prolog/tests/advanced.sx — predsort/3, term_variables/2, arith extensions
-
-(define pl-adv-test-count 0)
-(define pl-adv-test-pass 0)
-(define pl-adv-test-fail 0)
-(define pl-adv-test-failures (list))
-
-(define
-  pl-adv-test!
-  (fn
-    (name got expected)
-    (begin
-      (set! pl-adv-test-count (+ pl-adv-test-count 1))
-      (if
-        (= got expected)
-        (set! pl-adv-test-pass (+ pl-adv-test-pass 1))
-        (begin
-          (set! pl-adv-test-fail (+ pl-adv-test-fail 1))
-          (append!
-            pl-adv-test-failures
-            (str name "\n    expected: " expected "\n    got:      " got)))))))
-
-(define
-  pl-adv-goal
-  (fn
-    (src env)
-    (pl-instantiate (nth (first (pl-parse (str "g :- " src "."))) 2) env)))
-
-(define pl-adv-db (pl-mk-db))
-;; Load a numeric comparator for predsort tests
-(pl-db-load!
-  pl-adv-db
-  (pl-parse
-    "cmp_num(Order, X, Y) :- (X < Y -> Order = '<' ; (X > Y -> Order = '>' ; Order = '='))."))
-
-;; ── Arithmetic extensions ──────────────────────────────────────────
-
-(define pl-adv-arith-env-1 {:X (pl-mk-rt-var "X")})
-(pl-solve-once!
-  pl-adv-db
-  (pl-adv-goal "X is floor(3.7)" pl-adv-arith-env-1)
-  (pl-mk-trail))
-(pl-adv-test!
-  "floor(3.7) = 3"
-  (pl-num-val (pl-walk-deep (dict-get pl-adv-arith-env-1 "X")))
-  3)
-
-(define pl-adv-arith-env-2 {:X (pl-mk-rt-var "X")})
-(pl-solve-once!
-  pl-adv-db
-  (pl-adv-goal "X is ceiling(3.2)" pl-adv-arith-env-2)
-  (pl-mk-trail))
-(pl-adv-test!
-  "ceiling(3.2) = 4"
-  (pl-num-val (pl-walk-deep (dict-get pl-adv-arith-env-2 "X")))
-  4)
-
-(define pl-adv-arith-env-3 {:X (pl-mk-rt-var "X")})
-(pl-solve-once!
-  pl-adv-db
-  (pl-adv-goal "X is truncate(3.9)" pl-adv-arith-env-3)
-  (pl-mk-trail))
-(pl-adv-test!
-  "truncate(3.9) = 3"
-  (pl-num-val (pl-walk-deep (dict-get pl-adv-arith-env-3 "X")))
-  3)
-
-(define pl-adv-arith-env-4 {:X (pl-mk-rt-var "X")})
-(pl-solve-once!
-  pl-adv-db
-  (pl-adv-goal "X is truncate(0 - 3.9)" pl-adv-arith-env-4)
-  (pl-mk-trail))
-(pl-adv-test!
-  "truncate(0-3.9) = -3"
-  (pl-num-val (pl-walk-deep (dict-get pl-adv-arith-env-4 "X")))
-  -3)
-
-(define pl-adv-arith-env-5 {:X (pl-mk-rt-var "X")})
-(pl-solve-once!
-  pl-adv-db
-  (pl-adv-goal "X is round(3.5)" pl-adv-arith-env-5)
-  (pl-mk-trail))
-(pl-adv-test!
-  "round(3.5) = 4"
-  (pl-num-val (pl-walk-deep (dict-get pl-adv-arith-env-5 "X")))
-  4)
-
-(define pl-adv-arith-env-6 {:X (pl-mk-rt-var "X")})
-(pl-solve-once!
-  pl-adv-db
-  (pl-adv-goal "X is sqrt(4.0)" pl-adv-arith-env-6)
-  (pl-mk-trail))
-(pl-adv-test!
-  "sqrt(4.0) = 2"
-  (pl-num-val (pl-walk-deep (dict-get pl-adv-arith-env-6 "X")))
-  2)
-
-(define pl-adv-arith-env-7 {:X (pl-mk-rt-var "X")})
-(pl-solve-once!
-  pl-adv-db
-  (pl-adv-goal "X is sign(0 - 5)" pl-adv-arith-env-7)
-  (pl-mk-trail))
-(pl-adv-test!
-  "sign(0-5) = -1"
-  (pl-num-val (pl-walk-deep (dict-get pl-adv-arith-env-7 "X")))
-  -1)
-
-(define pl-adv-arith-env-8 {:X (pl-mk-rt-var "X")})
-(pl-solve-once!
-  pl-adv-db
-  (pl-adv-goal "X is sign(0)" pl-adv-arith-env-8)
-  (pl-mk-trail))
-(pl-adv-test!
-  "sign(0) = 0"
-  (pl-num-val (pl-walk-deep (dict-get pl-adv-arith-env-8 "X")))
-  0)
-
-(define pl-adv-arith-env-9 {:X (pl-mk-rt-var "X")})
-(pl-solve-once!
-  pl-adv-db
-  (pl-adv-goal "X is sign(3)" pl-adv-arith-env-9)
-  (pl-mk-trail))
-(pl-adv-test!
-  "sign(3) = 1"
-  (pl-num-val (pl-walk-deep (dict-get pl-adv-arith-env-9 "X")))
-  1)
-
-(define pl-adv-arith-env-10 {:X (pl-mk-rt-var "X")})
-(pl-solve-once!
-  pl-adv-db
-  (pl-adv-goal "X is pow(2, 3)" pl-adv-arith-env-10)
-  (pl-mk-trail))
-(pl-adv-test!
-  "pow(2,3) = 8"
-  (pl-num-val (pl-walk-deep (dict-get pl-adv-arith-env-10 "X")))
-  8)
-
-(define pl-adv-arith-env-11 {:X (pl-mk-rt-var "X")})
-(pl-solve-once!
-  pl-adv-db
-  (pl-adv-goal "X is floor(0 - 3.7)" pl-adv-arith-env-11)
-  (pl-mk-trail))
-(pl-adv-test!
-  "floor(0-3.7) = -4"
-  (pl-num-val (pl-walk-deep (dict-get pl-adv-arith-env-11 "X")))
-  -4)
-
-(define pl-adv-arith-env-12 {:X (pl-mk-rt-var "X")})
-(pl-solve-once!
-  pl-adv-db
-  (pl-adv-goal "X is ceiling(0 - 3.2)" pl-adv-arith-env-12)
-  (pl-mk-trail))
-(pl-adv-test!
-  "ceiling(0-3.2) = -3"
-  (pl-num-val (pl-walk-deep (dict-get pl-adv-arith-env-12 "X")))
-  -3)
-
-;; ── term_variables/2 ──────────────────────────────────────────────
-
-(define pl-adv-tv-env-1 {:Vs (pl-mk-rt-var "Vs")})
-(pl-solve-once!
-  pl-adv-db
-  (pl-adv-goal "term_variables(hello, Vs)" pl-adv-tv-env-1)
-  (pl-mk-trail))
-(pl-adv-test!
-  "term_variables(hello,Vs) -> []"
-  (pl-format-term (pl-walk-deep (dict-get pl-adv-tv-env-1 "Vs")))
-  "[]")
-
-(define pl-adv-tv-env-2 {:Vs (pl-mk-rt-var "Vs")})
-(pl-solve-once!
-  pl-adv-db
-  (pl-adv-goal "term_variables(f(a, g(b)), Vs)" pl-adv-tv-env-2)
-  (pl-mk-trail))
-(pl-adv-test!
-  "term_variables(f(a,g(b)),Vs) -> []"
-  (pl-format-term (pl-walk-deep (dict-get pl-adv-tv-env-2 "Vs")))
-  "[]")
-
-(define pl-adv-tv-env-3 {:Y (pl-mk-rt-var "Y") :Vs (pl-mk-rt-var "Vs") :X (pl-mk-rt-var "X")})
-(pl-solve-once!
-  pl-adv-db
-  (pl-adv-goal "term_variables(f(X, Y), Vs)" pl-adv-tv-env-3)
-  (pl-mk-trail))
-(pl-adv-test!
-  "term_variables(f(X,Y),Vs) has 2 vars"
-  (pl-list-length (pl-walk-deep (dict-get pl-adv-tv-env-3 "Vs")))
-  2)
-
-(define pl-adv-tv-env-4 {:Vs (pl-mk-rt-var "Vs") :X (pl-mk-rt-var "X")})
-(pl-solve-once!
-  pl-adv-db
-  (pl-adv-goal "term_variables(X, Vs)" pl-adv-tv-env-4)
-  (pl-mk-trail))
-(pl-adv-test!
-  "term_variables(X,Vs) has 1 var"
-  (pl-list-length (pl-walk-deep (dict-get pl-adv-tv-env-4 "Vs")))
-  1)
-
-(define pl-adv-tv-env-5 {:Y (pl-mk-rt-var "Y") :Vs (pl-mk-rt-var "Vs") :X (pl-mk-rt-var "X")})
-(pl-solve-once!
-  pl-adv-db
-  (pl-adv-goal "term_variables(foo(X, Y, X), Vs)" pl-adv-tv-env-5)
-  (pl-mk-trail))
-(pl-adv-test!
-  "term_variables(foo(X,Y,X),Vs) deduplicates X -> 2 vars"
-  (pl-list-length (pl-walk-deep (dict-get pl-adv-tv-env-5 "Vs")))
-  2)
-
-;; ── predsort/3 ────────────────────────────────────────────────────
-
-(define pl-adv-ps-env-1 {:R (pl-mk-rt-var "R")})
-(pl-solve-once!
-  pl-adv-db
-  (pl-adv-goal "predsort(cmp_num, [], R)" pl-adv-ps-env-1)
-  (pl-mk-trail))
-(pl-adv-test!
-  "predsort([]) -> []"
-  (pl-format-term (pl-walk-deep (dict-get pl-adv-ps-env-1 "R")))
-  "[]")
-
-(define pl-adv-ps-env-2 {:R (pl-mk-rt-var "R")})
-(pl-solve-once!
-  pl-adv-db
-  (pl-adv-goal "predsort(cmp_num, [1], R)" pl-adv-ps-env-2)
-  (pl-mk-trail))
-(pl-adv-test!
-  "predsort([1]) -> [1]"
-  (pl-format-term (pl-walk-deep (dict-get pl-adv-ps-env-2 "R")))
-  ".(1, [])")
-
-(define pl-adv-ps-env-3 {:R (pl-mk-rt-var "R")})
-(pl-solve-once!
-  pl-adv-db
-  (pl-adv-goal "predsort(cmp_num, [3,1,2], R)" pl-adv-ps-env-3)
-  (pl-mk-trail))
-(pl-adv-test!
-  "predsort([3,1,2]) -> [1,2,3]"
-  (pl-format-term (pl-walk-deep (dict-get pl-adv-ps-env-3 "R")))
-  ".(1, .(2, .(3, [])))")
-
-(define pl-adv-ps-env-4 {:R (pl-mk-rt-var "R")})
-(pl-solve-once!
-  pl-adv-db
-  (pl-adv-goal "predsort(cmp_num, [3,1,2,1,3], R)" pl-adv-ps-env-4)
-  (pl-mk-trail))
-(pl-adv-test!
-  "predsort([3,1,2,1,3]) dedup -> [1,2,3]"
-  (pl-format-term (pl-walk-deep (dict-get pl-adv-ps-env-4 "R")))
-  ".(1, .(2, .(3, [])))")
-
-;; ── Runner ─────────────────────────────────────────────────────────
-
-(define pl-advanced-tests-run! (fn () {:failed pl-adv-test-fail :passed pl-adv-test-pass :total pl-adv-test-count :failures pl-adv-test-failures}))

lib/prolog/tests/assert_rules.sx

@@ -1,215 +0,0 @@
-;; lib/prolog/tests/assert_rules.sx — assert/assertz/asserta with rule terms (head :- body)
-;; Tests that :- is in the op table (prec 1200 xfx) and pl-build-clause handles rule form.
-
-(define pl-ar-test-count 0)
-(define pl-ar-test-pass 0)
-(define pl-ar-test-fail 0)
-(define pl-ar-test-failures (list))
-
-(define
-  pl-ar-test!
-  (fn
-    (name got expected)
-    (begin
-      (set! pl-ar-test-count (+ pl-ar-test-count 1))
-      (if
-        (= got expected)
-        (set! pl-ar-test-pass (+ pl-ar-test-pass 1))
-        (begin
-          (set! pl-ar-test-fail (+ pl-ar-test-fail 1))
-          (append!
-            pl-ar-test-failures
-            (str name "\n    expected: " expected "\n    got:      " got)))))))
-
-(define
-  pl-ar-goal
-  (fn
-    (src env)
-    (pl-instantiate (nth (first (pl-parse (str "g :- " src "."))) 2) env)))
-
-;; ── DB1: assertz a simple rule then query ──────────────────────────
-(define pl-ar-db1 (pl-mk-db))
-
-(pl-solve-once!
-  pl-ar-db1
-  (pl-ar-goal "assertz((double(X, Y) :- Y is X * 2))" {})
-  (pl-mk-trail))
-
-(pl-ar-test!
-  "assertz rule: double(3, Y) succeeds"
-  (pl-solve-once!
-    pl-ar-db1
-    (pl-ar-goal "double(3, Y)" {})
-    (pl-mk-trail))
-  true)
-
-(define pl-ar-env1 {})
-(pl-solve-once!
-  pl-ar-db1
-  (pl-ar-goal "double(3, Y)" pl-ar-env1)
-  (pl-mk-trail))
-
-(pl-ar-test!
-  "assertz rule: double(3, Y) binds Y to 6"
-  (pl-num-val (pl-walk-deep (dict-get pl-ar-env1 "Y")))
-  6)
-
-(define pl-ar-env1b {})
-(pl-solve-once!
-  pl-ar-db1
-  (pl-ar-goal "double(10, Y)" pl-ar-env1b)
-  (pl-mk-trail))
-
-(pl-ar-test!
-  "assertz rule: double(10, Y) yields 20"
-  (pl-num-val (pl-walk-deep (dict-get pl-ar-env1b "Y")))
-  20)
-
-;; ── DB2: assert a rule with multiple facts, count solutions ─────────
-(define pl-ar-db2 (pl-mk-db))
-
-(pl-solve-once!
-  pl-ar-db2
-  (pl-ar-goal "assert(fact(a))" {})
-  (pl-mk-trail))
-(pl-solve-once!
-  pl-ar-db2
-  (pl-ar-goal "assert(fact(b))" {})
-  (pl-mk-trail))
-(pl-solve-once!
-  pl-ar-db2
-  (pl-ar-goal "assertz((copy(X) :- fact(X)))" {})
-  (pl-mk-trail))
-
-(pl-ar-test!
-  "rule copy/1 using fact/1: 2 solutions"
-  (pl-solve-count! pl-ar-db2 (pl-ar-goal "copy(X)" {}) (pl-mk-trail))
-  2)
-
-(define pl-ar-env2a {})
-(pl-solve-once! pl-ar-db2 (pl-ar-goal "copy(X)" pl-ar-env2a) (pl-mk-trail))
-
-(pl-ar-test!
-  "rule copy/1: first solution is a"
-  (pl-atom-name (pl-walk-deep (dict-get pl-ar-env2a "X")))
-  "a")
-
-;; ── DB3: asserta rule is tried before existing clauses ─────────────
-(define pl-ar-db3 (pl-mk-db))
-
-(pl-solve-once!
-  pl-ar-db3
-  (pl-ar-goal "assert(ord(a))" {})
-  (pl-mk-trail))
-(pl-solve-once!
-  pl-ar-db3
-  (pl-ar-goal "asserta((ord(b) :- true))" {})
-  (pl-mk-trail))
-
-(define pl-ar-env3 {})
-(pl-solve-once! pl-ar-db3 (pl-ar-goal "ord(X)" pl-ar-env3) (pl-mk-trail))
-
-(pl-ar-test!
-  "asserta rule ord(b) is tried before ord(a)"
-  (pl-atom-name (pl-walk-deep (dict-get pl-ar-env3 "X")))
-  "b")
-
-(pl-ar-test!
-  "asserta: total solutions for ord/1 is 2"
-  (pl-solve-count! pl-ar-db3 (pl-ar-goal "ord(X)" {}) (pl-mk-trail))
-  2)
-
-;; ── DB4: rule with conjunction in body ─────────────────────────────
-(define pl-ar-db4 (pl-mk-db))
-
-(pl-solve-once!
-  pl-ar-db4
-  (pl-ar-goal "assert(num(1))" {})
-  (pl-mk-trail))
-(pl-solve-once!
-  pl-ar-db4
-  (pl-ar-goal "assert(num(2))" {})
-  (pl-mk-trail))
-(pl-solve-once!
-  pl-ar-db4
-  (pl-ar-goal "assertz((big(X) :- num(X), X > 1))" {})
-  (pl-mk-trail))
-
-(pl-ar-test!
-  "conjunction in rule body: big(1) fails"
-  (pl-solve-once! pl-ar-db4 (pl-ar-goal "big(1)" {}) (pl-mk-trail))
-  false)
-
-(pl-ar-test!
-  "conjunction in rule body: big(2) succeeds"
-  (pl-solve-once! pl-ar-db4 (pl-ar-goal "big(2)" {}) (pl-mk-trail))
-  true)
-
-;; ── DB5: recursive rule ─────────────────────────────────────────────
-(define pl-ar-db5 (pl-mk-db))
-
-(pl-solve-once!
-  pl-ar-db5
-  (pl-ar-goal "assert((nat(0) :- true))" {})
-  (pl-mk-trail))
-(pl-solve-once!
-  pl-ar-db5
-  (pl-ar-goal "assertz((nat(s(X)) :- nat(X)))" {})
-  (pl-mk-trail))
-
-(pl-ar-test!
-  "recursive rule: nat(0) succeeds"
-  (pl-solve-once! pl-ar-db5 (pl-ar-goal "nat(0)" {}) (pl-mk-trail))
-  true)
-
-(pl-ar-test!
-  "recursive rule: nat(s(0)) succeeds"
-  (pl-solve-once!
-    pl-ar-db5
-    (pl-ar-goal "nat(s(0))" {})
-    (pl-mk-trail))
-  true)
-
-(pl-ar-test!
-  "recursive rule: nat(s(s(0))) succeeds"
-  (pl-solve-once!
-    pl-ar-db5
-    (pl-ar-goal "nat(s(s(0)))" {})
-    (pl-mk-trail))
-  true)
-
-(pl-ar-test!
-  "recursive rule: nat(bad) fails"
-  (pl-solve-once! pl-ar-db5 (pl-ar-goal "nat(bad)" {}) (pl-mk-trail))
-  false)
-
-;; ── DB6: rule with true body (explicit) ────────────────────────────
-(define pl-ar-db6 (pl-mk-db))
-
-(pl-solve-once!
-  pl-ar-db6
-  (pl-ar-goal "assertz((always(X) :- true))" {})
-  (pl-mk-trail))
-(pl-solve-once!
-  pl-ar-db6
-  (pl-ar-goal "assert(always(extra))" {})
-  (pl-mk-trail))
-
-(pl-ar-test!
-  "rule body=true: always(foo) succeeds"
-  (pl-solve-once!
-    pl-ar-db6
-    (pl-ar-goal "always(foo)" {})
-    (pl-mk-trail))
-  true)
-
-(pl-ar-test!
-  "rule body=true: always/1 has 2 clauses (1 rule + 1 fact)"
-  (pl-solve-count!
-    pl-ar-db6
-    (pl-ar-goal "always(X)" {})
-    (pl-mk-trail))
-  2)
-
-;; ── Runner ──────────────────────────────────────────────────────────
-(define pl-assert-rules-tests-run! (fn () {:failed pl-ar-test-fail :passed pl-ar-test-pass :total pl-ar-test-count :failures pl-ar-test-failures}))

lib/prolog/tests/atoms.sx

@@ -1,305 +0,0 @@
-;; lib/prolog/tests/atoms.sx — type predicates + string/atom built-ins
-
-(define pl-at-test-count 0)
-(define pl-at-test-pass 0)
-(define pl-at-test-fail 0)
-(define pl-at-test-failures (list))
-
-(define
-  pl-at-test!
-  (fn
-    (name got expected)
-    (begin
-      (set! pl-at-test-count (+ pl-at-test-count 1))
-      (if
-        (= got expected)
-        (set! pl-at-test-pass (+ pl-at-test-pass 1))
-        (begin
-          (set! pl-at-test-fail (+ pl-at-test-fail 1))
-          (append!
-            pl-at-test-failures
-            (str name "\n    expected: " expected "\n    got:      " got)))))))
-
-(define
-  pl-at-goal
-  (fn
-    (src env)
-    (pl-instantiate (nth (first (pl-parse (str "g :- " src "."))) 2) env)))
-
-(define pl-at-db (pl-mk-db))
-
-;; ── var/1 + nonvar/1 ──
-
-(pl-at-test!
-  "var(X) for unbound var"
-  (pl-solve-once! pl-at-db (pl-at-goal "var(X)" {}) (pl-mk-trail))
-  true)
-(pl-at-test!
-  "var(foo) fails"
-  (pl-solve-once! pl-at-db (pl-at-goal "var(foo)" {}) (pl-mk-trail))
-  false)
-(pl-at-test!
-  "nonvar(foo) succeeds"
-  (pl-solve-once!
-    pl-at-db
-    (pl-at-goal "nonvar(foo)" {})
-    (pl-mk-trail))
-  true)
-(pl-at-test!
-  "nonvar(X) for unbound var fails"
-  (pl-solve-once! pl-at-db (pl-at-goal "nonvar(X)" {}) (pl-mk-trail))
-  false)
-
-;; ── atom/1 ──
-
-(pl-at-test!
-  "atom(foo) succeeds"
-  (pl-solve-once! pl-at-db (pl-at-goal "atom(foo)" {}) (pl-mk-trail))
-  true)
-(pl-at-test!
-  "atom([]) succeeds"
-  (pl-solve-once! pl-at-db (pl-at-goal "atom([])" {}) (pl-mk-trail))
-  true)
-(pl-at-test!
-  "atom(42) fails"
-  (pl-solve-once! pl-at-db (pl-at-goal "atom(42)" {}) (pl-mk-trail))
-  false)
-(pl-at-test!
-  "atom(f(x)) fails"
-  (pl-solve-once!
-    pl-at-db
-    (pl-at-goal "atom(f(x))" {})
-    (pl-mk-trail))
-  false)
-
-;; ── number/1 + integer/1 ──
-
-(pl-at-test!
-  "number(42) succeeds"
-  (pl-solve-once!
-    pl-at-db
-    (pl-at-goal "number(42)" {})
-    (pl-mk-trail))
-  true)
-(pl-at-test!
-  "number(foo) fails"
-  (pl-solve-once!
-    pl-at-db
-    (pl-at-goal "number(foo)" {})
-    (pl-mk-trail))
-  false)
-(pl-at-test!
-  "integer(7) succeeds"
-  (pl-solve-once!
-    pl-at-db
-    (pl-at-goal "integer(7)" {})
-    (pl-mk-trail))
-  true)
-
-;; ── compound/1 + callable/1 + atomic/1 ──
-
-(pl-at-test!
-  "compound(f(x)) succeeds"
-  (pl-solve-once!
-    pl-at-db
-    (pl-at-goal "compound(f(x))" {})
-    (pl-mk-trail))
-  true)
-(pl-at-test!
-  "compound(foo) fails"
-  (pl-solve-once!
-    pl-at-db
-    (pl-at-goal "compound(foo)" {})
-    (pl-mk-trail))
-  false)
-(pl-at-test!
-  "callable(foo) succeeds"
-  (pl-solve-once!
-    pl-at-db
-    (pl-at-goal "callable(foo)" {})
-    (pl-mk-trail))
-  true)
-(pl-at-test!
-  "callable(f(x)) succeeds"
-  (pl-solve-once!
-    pl-at-db
-    (pl-at-goal "callable(f(x))" {})
-    (pl-mk-trail))
-  true)
-(pl-at-test!
-  "callable(42) fails"
-  (pl-solve-once!
-    pl-at-db
-    (pl-at-goal "callable(42)" {})
-    (pl-mk-trail))
-  false)
-(pl-at-test!
-  "atomic(foo) succeeds"
-  (pl-solve-once!
-    pl-at-db
-    (pl-at-goal "atomic(foo)" {})
-    (pl-mk-trail))
-  true)
-(pl-at-test!
-  "atomic(42) succeeds"
-  (pl-solve-once!
-    pl-at-db
-    (pl-at-goal "atomic(42)" {})
-    (pl-mk-trail))
-  true)
-(pl-at-test!
-  "atomic(f(x)) fails"
-  (pl-solve-once!
-    pl-at-db
-    (pl-at-goal "atomic(f(x))" {})
-    (pl-mk-trail))
-  false)
-
-;; ── is_list/1 ──
-
-(pl-at-test!
-  "is_list([]) succeeds"
-  (pl-solve-once!
-    pl-at-db
-    (pl-at-goal "is_list([])" {})
-    (pl-mk-trail))
-  true)
-(pl-at-test!
-  "is_list([1,2,3]) succeeds"
-  (pl-solve-once!
-    pl-at-db
-    (pl-at-goal "is_list([1,2,3])" {})
-    (pl-mk-trail))
-  true)
-(pl-at-test!
-  "is_list(foo) fails"
-  (pl-solve-once!
-    pl-at-db
-    (pl-at-goal "is_list(foo)" {})
-    (pl-mk-trail))
-  false)
-
-;; ── atom_length/2 ──
-
-(define pl-at-env-al {})
-(pl-solve-once!
-  pl-at-db
-  (pl-at-goal "atom_length(hello, N)" pl-at-env-al)
-  (pl-mk-trail))
-(pl-at-test!
-  "atom_length(hello, N) -> N=5"
-  (pl-num-val (pl-walk-deep (dict-get pl-at-env-al "N")))
-  5)
-(pl-at-test!
-  "atom_length empty atom"
-  (pl-solve-once!
-    pl-at-db
-    (pl-at-goal "atom_length('', 0)" {})
-    (pl-mk-trail))
-  true)
-
-;; ── atom_concat/3 ──
-
-(define pl-at-env-ac {})
-(pl-solve-once!
-  pl-at-db
-  (pl-at-goal "atom_concat(foo, bar, X)" pl-at-env-ac)
-  (pl-mk-trail))
-(pl-at-test!
-  "atom_concat(foo, bar, X) -> X=foobar"
-  (pl-atom-name (pl-walk-deep (dict-get pl-at-env-ac "X")))
-  "foobar")
-
-(pl-at-test!
-  "atom_concat(foo, bar, foobar) check"
-  (pl-solve-once!
-    pl-at-db
-    (pl-at-goal "atom_concat(foo, bar, foobar)" {})
-    (pl-mk-trail))
-  true)
-(pl-at-test!
-  "atom_concat(foo, bar, foobaz) fails"
-  (pl-solve-once!
-    pl-at-db
-    (pl-at-goal "atom_concat(foo, bar, foobaz)" {})
-    (pl-mk-trail))
-  false)
-
-(define pl-at-env-ac2 {})
-(pl-solve-once!
-  pl-at-db
-  (pl-at-goal "atom_concat(foo, Y, foobar)" pl-at-env-ac2)
-  (pl-mk-trail))
-(pl-at-test!
-  "atom_concat(foo, Y, foobar) -> Y=bar"
-  (pl-atom-name (pl-walk-deep (dict-get pl-at-env-ac2 "Y")))
-  "bar")
-
-;; ── atom_chars/2 ──
-
-(define pl-at-env-ach {})
-(pl-solve-once!
-  pl-at-db
-  (pl-at-goal "atom_chars(cat, Cs)" pl-at-env-ach)
-  (pl-mk-trail))
-(pl-at-test!
-  "atom_chars(cat, Cs) -> Cs=[c,a,t]"
-  (pl-solve-once!
-    pl-at-db
-    (pl-at-goal "atom_chars(cat, [c,a,t])" {})
-    (pl-mk-trail))
-  true)
-
-(define pl-at-env-ach2 {})
-(pl-solve-once!
-  pl-at-db
-  (pl-at-goal "atom_chars(A, [h,i])" pl-at-env-ach2)
-  (pl-mk-trail))
-(pl-at-test!
-  "atom_chars(A, [h,i]) -> A=hi"
-  (pl-atom-name (pl-walk-deep (dict-get pl-at-env-ach2 "A")))
-  "hi")
-
-;; ── char_code/2 ──
-
-(define pl-at-env-cc {})
-(pl-solve-once!
-  pl-at-db
-  (pl-at-goal "char_code(a, N)" pl-at-env-cc)
-  (pl-mk-trail))
-(pl-at-test!
-  "char_code(a, N) -> N=97"
-  (pl-num-val (pl-walk-deep (dict-get pl-at-env-cc "N")))
-  97)
-
-(define pl-at-env-cc2 {})
-(pl-solve-once!
-  pl-at-db
-  (pl-at-goal "char_code(C, 65)" pl-at-env-cc2)
-  (pl-mk-trail))
-(pl-at-test!
-  "char_code(C, 65) -> C='A'"
-  (pl-atom-name (pl-walk-deep (dict-get pl-at-env-cc2 "C")))
-  "A")
-
-;; ── number_codes/2 ──
-
-(pl-at-test!
-  "number_codes(42, [52,50])"
-  (pl-solve-once!
-    pl-at-db
-    (pl-at-goal "number_codes(42, [52,50])" {})
-    (pl-mk-trail))
-  true)
-
-;; ── number_chars/2 ──
-
-(pl-at-test!
-  "number_chars(42, ['4','2'])"
-  (pl-solve-once!
-    pl-at-db
-    (pl-at-goal "number_chars(42, ['4','2'])" {})
-    (pl-mk-trail))
-  true)
-
-(define pl-atom-tests-run! (fn () {:failed pl-at-test-fail :passed pl-at-test-pass :total pl-at-test-count :failures pl-at-test-failures}))

lib/prolog/tests/char_predicates.sx

@@ -1,290 +0,0 @@
-;; lib/prolog/tests/char_predicates.sx — char_type/2, upcase_atom/2, downcase_atom/2,
-;;   string_upper/2, string_lower/2
-
-(define pl-cp-test-count 0)
-(define pl-cp-test-pass 0)
-(define pl-cp-test-fail 0)
-(define pl-cp-test-failures (list))
-
-(define
-  pl-cp-test!
-  (fn
-    (name got expected)
-    (begin
-      (set! pl-cp-test-count (+ pl-cp-test-count 1))
-      (if
-        (= got expected)
-        (set! pl-cp-test-pass (+ pl-cp-test-pass 1))
-        (begin
-          (set! pl-cp-test-fail (+ pl-cp-test-fail 1))
-          (append!
-            pl-cp-test-failures
-            (str name "\n    expected: " expected "\n    got:      " got)))))))
-
-(define
-  pl-cp-goal
-  (fn
-    (src env)
-    (pl-instantiate (nth (first (pl-parse (str "g :- " src "."))) 2) env)))
-
-(define pl-cp-db (pl-mk-db))
-
-;; ─── char_type/2 — alpha ──────────────────────────────────────────
-
-(pl-cp-test!
-  "char_type(a, alpha) succeeds"
-  (pl-solve-once!
-    pl-cp-db
-    (pl-cp-goal "char_type(a, alpha)" {})
-    (pl-mk-trail))
-  true)
-
-(pl-cp-test!
-  "char_type('1', alpha) fails"
-  (pl-solve-once!
-    pl-cp-db
-    (pl-cp-goal "char_type('1', alpha)" {})
-    (pl-mk-trail))
-  false)
-
-(pl-cp-test!
-  "char_type('A', alpha) succeeds"
-  (pl-solve-once!
-    pl-cp-db
-    (pl-cp-goal "char_type('A', alpha)" {})
-    (pl-mk-trail))
-  true)
-
-;; ─── char_type/2 — alnum ─────────────────────────────────────────
-
-(pl-cp-test!
-  "char_type('5', alnum) succeeds"
-  (pl-solve-once!
-    pl-cp-db
-    (pl-cp-goal "char_type('5', alnum)" {})
-    (pl-mk-trail))
-  true)
-
-(pl-cp-test!
-  "char_type(a, alnum) succeeds"
-  (pl-solve-once!
-    pl-cp-db
-    (pl-cp-goal "char_type(a, alnum)" {})
-    (pl-mk-trail))
-  true)
-
-(pl-cp-test!
-  "char_type(' ', alnum) fails"
-  (pl-solve-once!
-    pl-cp-db
-    (pl-cp-goal "char_type(' ', alnum)" {})
-    (pl-mk-trail))
-  false)
-
-;; ─── char_type/2 — digit ─────────────────────────────────────────
-
-(pl-cp-test!
-  "char_type('5', digit) succeeds"
-  (pl-solve-once!
-    pl-cp-db
-    (pl-cp-goal "char_type('5', digit)" {})
-    (pl-mk-trail))
-  true)
-
-(pl-cp-test!
-  "char_type(a, digit) fails"
-  (pl-solve-once!
-    pl-cp-db
-    (pl-cp-goal "char_type(a, digit)" {})
-    (pl-mk-trail))
-  false)
-
-;; ─── char_type/2 — digit(Weight) ─────────────────────────────────
-
-(define pl-cp-env-dw {})
-(pl-solve-once!
-  pl-cp-db
-  (pl-cp-goal "char_type('5', digit(N))" pl-cp-env-dw)
-  (pl-mk-trail))
-(pl-cp-test!
-  "char_type('5', digit(N)) -> N=5"
-  (pl-num-val (pl-walk-deep (dict-get pl-cp-env-dw "N")))
-  5)
-
-(define pl-cp-env-dw0 {})
-(pl-solve-once!
-  pl-cp-db
-  (pl-cp-goal "char_type('0', digit(N))" pl-cp-env-dw0)
-  (pl-mk-trail))
-(pl-cp-test!
-  "char_type('0', digit(N)) -> N=0"
-  (pl-num-val (pl-walk-deep (dict-get pl-cp-env-dw0 "N")))
-  0)
-
-;; ─── char_type/2 — space/white ───────────────────────────────────
-
-(pl-cp-test!
-  "char_type(' ', space) succeeds"
-  (pl-solve-once!
-    pl-cp-db
-    (pl-cp-goal "char_type(' ', space)" {})
-    (pl-mk-trail))
-  true)
-
-(pl-cp-test!
-  "char_type(a, space) fails"
-  (pl-solve-once!
-    pl-cp-db
-    (pl-cp-goal "char_type(a, space)" {})
-    (pl-mk-trail))
-  false)
-
-;; ─── char_type/2 — upper(Lower) ──────────────────────────────────
-
-(define pl-cp-env-ul {})
-(pl-solve-once!
-  pl-cp-db
-  (pl-cp-goal "char_type('A', upper(L))" pl-cp-env-ul)
-  (pl-mk-trail))
-(pl-cp-test!
-  "char_type('A', upper(L)) -> L=a"
-  (pl-atom-name (pl-walk-deep (dict-get pl-cp-env-ul "L")))
-  "a")
-
-(pl-cp-test!
-  "char_type(a, upper(L)) fails — not uppercase"
-  (pl-solve-once!
-    pl-cp-db
-    (pl-cp-goal "char_type(a, upper(_))" {})
-    (pl-mk-trail))
-  false)
-
-;; ─── char_type/2 — lower(Upper) ──────────────────────────────────
-
-(define pl-cp-env-lu {})
-(pl-solve-once!
-  pl-cp-db
-  (pl-cp-goal "char_type(a, lower(U))" pl-cp-env-lu)
-  (pl-mk-trail))
-(pl-cp-test!
-  "char_type(a, lower(U)) -> U='A'"
-  (pl-atom-name (pl-walk-deep (dict-get pl-cp-env-lu "U")))
-  "A")
-
-;; ─── char_type/2 — ascii(Code) ───────────────────────────────────
-
-(define pl-cp-env-as {})
-(pl-solve-once!
-  pl-cp-db
-  (pl-cp-goal "char_type(a, ascii(C))" pl-cp-env-as)
-  (pl-mk-trail))
-(pl-cp-test!
-  "char_type(a, ascii(C)) -> C=97"
-  (pl-num-val (pl-walk-deep (dict-get pl-cp-env-as "C")))
-  97)
-
-;; ─── char_type/2 — punct ─────────────────────────────────────────
-
-(pl-cp-test!
-  "char_type('.', punct) succeeds"
-  (pl-solve-once!
-    pl-cp-db
-    (pl-cp-goal "char_type('.', punct)" {})
-    (pl-mk-trail))
-  true)
-
-(pl-cp-test!
-  "char_type(a, punct) fails"
-  (pl-solve-once!
-    pl-cp-db
-    (pl-cp-goal "char_type(a, punct)" {})
-    (pl-mk-trail))
-  false)
-
-;; ─── upcase_atom/2 ───────────────────────────────────────────────
-
-(define pl-cp-env-ua {})
-(pl-solve-once!
-  pl-cp-db
-  (pl-cp-goal "upcase_atom(hello, X)" pl-cp-env-ua)
-  (pl-mk-trail))
-(pl-cp-test!
-  "upcase_atom(hello, X) -> X='HELLO'"
-  (pl-atom-name (pl-walk-deep (dict-get pl-cp-env-ua "X")))
-  "HELLO")
-
-(pl-cp-test!
-  "upcase_atom(hello, 'HELLO') succeeds"
-  (pl-solve-once!
-    pl-cp-db
-    (pl-cp-goal "upcase_atom(hello, 'HELLO')" {})
-    (pl-mk-trail))
-  true)
-
-(pl-cp-test!
-  "upcase_atom('Hello World', 'HELLO WORLD') succeeds"
-  (pl-solve-once!
-    pl-cp-db
-    (pl-cp-goal "upcase_atom('Hello World', 'HELLO WORLD')" {})
-    (pl-mk-trail))
-  true)
-
-(pl-cp-test!
-  "upcase_atom('', '') succeeds"
-  (pl-solve-once!
-    pl-cp-db
-    (pl-cp-goal "upcase_atom('', '')" {})
-    (pl-mk-trail))
-  true)
-
-;; ─── downcase_atom/2 ─────────────────────────────────────────────
-
-(define pl-cp-env-da {})
-(pl-solve-once!
-  pl-cp-db
-  (pl-cp-goal "downcase_atom('HELLO', X)" pl-cp-env-da)
-  (pl-mk-trail))
-(pl-cp-test!
-  "downcase_atom('HELLO', X) -> X=hello"
-  (pl-atom-name (pl-walk-deep (dict-get pl-cp-env-da "X")))
-  "hello")
-
-(pl-cp-test!
-  "downcase_atom('HELLO', hello) succeeds"
-  (pl-solve-once!
-    pl-cp-db
-    (pl-cp-goal "downcase_atom('HELLO', hello)" {})
-    (pl-mk-trail))
-  true)
-
-(pl-cp-test!
-  "downcase_atom(hello, hello) succeeds — already lowercase"
-  (pl-solve-once!
-    pl-cp-db
-    (pl-cp-goal "downcase_atom(hello, hello)" {})
-    (pl-mk-trail))
-  true)
-
-;; ─── string_upper/2 + string_lower/2 (aliases) ───────────────────
-
-(define pl-cp-env-su {})
-(pl-solve-once!
-  pl-cp-db
-  (pl-cp-goal "string_upper(hello, X)" pl-cp-env-su)
-  (pl-mk-trail))
-(pl-cp-test!
-  "string_upper(hello, X) -> X='HELLO'"
-  (pl-atom-name (pl-walk-deep (dict-get pl-cp-env-su "X")))
-  "HELLO")
-
-(define pl-cp-env-sl {})
-(pl-solve-once!
-  pl-cp-db
-  (pl-cp-goal "string_lower('WORLD', X)" pl-cp-env-sl)
-  (pl-mk-trail))
-(pl-cp-test!
-  "string_lower('WORLD', X) -> X=world"
-  (pl-atom-name (pl-walk-deep (dict-get pl-cp-env-sl "X")))
-  "world")
-
-(define pl-char-predicates-tests-run! (fn () {:failed pl-cp-test-fail :passed pl-cp-test-pass :total pl-cp-test-count :failures pl-cp-test-failures}))

lib/prolog/tests/clausedb.sx

@@ -1,99 +0,0 @@
-;; lib/prolog/tests/clausedb.sx — Clause DB unit tests
-
-(define pl-db-test-count 0)
-(define pl-db-test-pass 0)
-(define pl-db-test-fail 0)
-(define pl-db-test-failures (list))
-
-(define
-  pl-db-test!
-  (fn
-    (name got expected)
-    (begin
-      (set! pl-db-test-count (+ pl-db-test-count 1))
-      (if
-        (= got expected)
-        (set! pl-db-test-pass (+ pl-db-test-pass 1))
-        (begin
-          (set! pl-db-test-fail (+ pl-db-test-fail 1))
-          (append!
-            pl-db-test-failures
-            (str name "\n    expected: " expected "\n    got:      " got)))))))
-
-(pl-db-test!
-  "head-key atom arity 0"
-  (pl-head-key (nth (first (pl-parse "foo.")) 1))
-  "foo/0")
-
-(pl-db-test!
-  "head-key compound arity 2"
-  (pl-head-key (nth (first (pl-parse "bar(a, b).")) 1))
-  "bar/2")
-
-(pl-db-test!
-  "clause-key of :- clause"
-  (pl-clause-key (first (pl-parse "likes(mary, X) :- friendly(X).")))
-  "likes/2")
-
-(pl-db-test!
-  "empty db lookup returns empty list"
-  (len (pl-db-lookup (pl-mk-db) "parent/2"))
-  0)
-
-(define pl-db-t1 (pl-mk-db))
-(pl-db-load! pl-db-t1 (pl-parse "foo(a). foo(b). foo(c)."))
-
-(pl-db-test!
-  "three facts same functor"
-  (len (pl-db-lookup pl-db-t1 "foo/1"))
-  3)
-(pl-db-test!
-  "mismatching key returns empty"
-  (len (pl-db-lookup pl-db-t1 "foo/2"))
-  0)
-
-(pl-db-test!
-  "first clause has arg a"
-  (pl-atom-name
-    (first (pl-args (nth (first (pl-db-lookup pl-db-t1 "foo/1")) 1))))
-  "a")
-
-(pl-db-test!
-  "third clause has arg c"
-  (pl-atom-name
-    (first (pl-args (nth (nth (pl-db-lookup pl-db-t1 "foo/1") 2) 1))))
-  "c")
-
-(define pl-db-t2 (pl-mk-db))
-(pl-db-load! pl-db-t2 (pl-parse "foo. bar. foo. parent(a, b). parent(c, d)."))
-
-(pl-db-test!
-  "atom heads keyed as foo/0"
-  (len (pl-db-lookup pl-db-t2 "foo/0"))
-  2)
-(pl-db-test!
-  "atom heads keyed as bar/0"
-  (len (pl-db-lookup pl-db-t2 "bar/0"))
-  1)
-(pl-db-test!
-  "compound heads keyed as parent/2"
-  (len (pl-db-lookup pl-db-t2 "parent/2"))
-  2)
-
-(pl-db-test!
-  "lookup-goal extracts functor/arity"
-  (len
-    (pl-db-lookup-goal pl-db-t2 (nth (first (pl-parse "parent(X, Y).")) 1)))
-  2)
-
-(pl-db-test!
-  "lookup-goal on atom goal"
-  (len (pl-db-lookup-goal pl-db-t2 (nth (first (pl-parse "foo.")) 1)))
-  2)
-
-(pl-db-test!
-  "stored clause is clause form"
-  (first (first (pl-db-lookup pl-db-t2 "parent/2")))
-  "clause")
-
-(define pl-clausedb-tests-run! (fn () {:failed pl-db-test-fail :passed pl-db-test-pass :total pl-db-test-count :failures pl-db-test-failures}))

lib/prolog/tests/compiler.sx

@@ -1,185 +0,0 @@
-;; lib/prolog/tests/compiler.sx — compiled clause dispatch tests
-
-(define pl-cmp-test-count 0)
-(define pl-cmp-test-pass 0)
-(define pl-cmp-test-fail 0)
-(define pl-cmp-test-failures (list))
-
-(define
-  pl-cmp-test!
-  (fn
-    (name got expected)
-    (set! pl-cmp-test-count (+ pl-cmp-test-count 1))
-    (if
-      (= got expected)
-      (set! pl-cmp-test-pass (+ pl-cmp-test-pass 1))
-      (begin
-        (set! pl-cmp-test-fail (+ pl-cmp-test-fail 1))
-        (append! pl-cmp-test-failures name)))))
-
-;; Load src, compile, return DB.
-(define
-  pl-cmp-mk
-  (fn
-    (src)
-    (let
-      ((db (pl-mk-db)))
-      (pl-db-load! db (pl-parse src))
-      (pl-compile-db! db)
-      db)))
-
-;; Run goal string against compiled DB; return bool (instantiates vars).
-(define
-  pl-cmp-once
-  (fn
-    (db src)
-    (pl-solve-once!
-      db
-      (pl-instantiate (pl-parse-goal src) {})
-      (pl-mk-trail))))
-
-;; Count solutions for goal string against compiled DB.
-(define
-  pl-cmp-count
-  (fn
-    (db src)
-    (pl-solve-count!
-      db
-      (pl-instantiate (pl-parse-goal src) {})
-      (pl-mk-trail))))
-
-;; ── 1. Simple facts ──────────────────────────────────────────────
-
-(define pl-cmp-db1 (pl-cmp-mk "color(red). color(green). color(blue)."))
-
-(pl-cmp-test! "compiled fact hit" (pl-cmp-once pl-cmp-db1 "color(red)") true)
-(pl-cmp-test!
-  "compiled fact miss"
-  (pl-cmp-once pl-cmp-db1 "color(yellow)")
-  false)
-(pl-cmp-test! "compiled fact count" (pl-cmp-count pl-cmp-db1 "color(X)") 3)
-
-;; ── 2. Recursive rule: append ────────────────────────────────────
-
-(define
-  pl-cmp-db2
-  (pl-cmp-mk "append([], L, L). append([H|T], L, [H|R]) :- append(T, L, R)."))
-
-(pl-cmp-test!
-  "compiled append build"
-  (pl-cmp-once pl-cmp-db2 "append([1,2],[3],[1,2,3])")
-  true)
-(pl-cmp-test!
-  "compiled append fail"
-  (pl-cmp-once pl-cmp-db2 "append([1,2],[3],[1,2])")
-  false)
-(pl-cmp-test!
-  "compiled append split count"
-  (pl-cmp-count pl-cmp-db2 "append(X, Y, [a,b])")
-  3)
-
-;; ── 3. Cut ───────────────────────────────────────────────────────
-
-(define
-  pl-cmp-db3
-  (pl-cmp-mk "first(X, [X|_]) :- !. first(X, [_|T]) :- first(X, T)."))
-
-(pl-cmp-test!
-  "compiled cut: only one solution"
-  (pl-cmp-count pl-cmp-db3 "first(X, [a,b,c])")
-  1)
-
-(let
-  ((db pl-cmp-db3) (trail (pl-mk-trail)) (env {}))
-  (let
-    ((x (pl-mk-rt-var "X")))
-    (dict-set! env "X" x)
-    (pl-solve-once!
-      db
-      (pl-instantiate (pl-parse-goal "first(X, [a,b,c])") env)
-      trail)
-    (pl-cmp-test!
-      "compiled cut: correct binding"
-      (pl-atom-name (pl-walk x))
-      "a")))
-
-;; ── 4. member ────────────────────────────────────────────────────
-
-(define
-  pl-cmp-db4
-  (pl-cmp-mk "member(X, [X|_]). member(X, [_|T]) :- member(X, T)."))
-
-(pl-cmp-test!
-  "compiled member hit"
-  (pl-cmp-once pl-cmp-db4 "member(b, [a,b,c])")
-  true)
-(pl-cmp-test!
-  "compiled member miss"
-  (pl-cmp-once pl-cmp-db4 "member(d, [a,b,c])")
-  false)
-(pl-cmp-test!
-  "compiled member count"
-  (pl-cmp-count pl-cmp-db4 "member(X, [a,b,c])")
-  3)
-
-;; ── 5. Arithmetic in body ────────────────────────────────────────
-
-(define pl-cmp-db5 (pl-cmp-mk "double(X, Y) :- Y is X * 2."))
-
-(let
-  ((db pl-cmp-db5) (trail (pl-mk-trail)) (env {}))
-  (let
-    ((y (pl-mk-rt-var "Y")))
-    (dict-set! env "Y" y)
-    (pl-solve-once!
-      db
-      (pl-instantiate (pl-parse-goal "double(5, Y)") env)
-      trail)
-    (pl-cmp-test! "compiled arithmetic in body" (pl-num-val (pl-walk y)) 10)))
-
-;; ── 6. Transitive ancestor ───────────────────────────────────────
-
-(define
-  pl-cmp-db6
-  (pl-cmp-mk
-    (str
-      "parent(a,b). parent(b,c). parent(c,d)."
-      "ancestor(X,Y) :- parent(X,Y)."
-      "ancestor(X,Y) :- parent(X,Z), ancestor(Z,Y).")))
-
-(pl-cmp-test!
-  "compiled ancestor direct"
-  (pl-cmp-once pl-cmp-db6 "ancestor(a,b)")
-  true)
-(pl-cmp-test!
-  "compiled ancestor 3-step"
-  (pl-cmp-once pl-cmp-db6 "ancestor(a,d)")
-  true)
-(pl-cmp-test!
-  "compiled ancestor fail"
-  (pl-cmp-once pl-cmp-db6 "ancestor(d,a)")
-  false)
-
-;; ── 7. Fallback: uncompiled predicate calls compiled sub-predicate
-
-(define
-  pl-cmp-db7
-  (let
-    ((db (pl-mk-db)))
-    (pl-db-load! db (pl-parse "q(1). q(2)."))
-    (pl-compile-db! db)
-    (pl-db-load! db (pl-parse "r(X) :- q(X)."))
-    db))
-
-(pl-cmp-test!
-  "uncompiled predicate resolves"
-  (pl-cmp-once pl-cmp-db7 "r(1)")
-  true)
-(pl-cmp-test!
-  "uncompiled calls compiled sub-pred count"
-  (pl-cmp-count pl-cmp-db7 "r(X)")
-  2)
-
-;; ── Runner ───────────────────────────────────────────────────────
-
-(define pl-compiler-tests-run! (fn () {:failed pl-cmp-test-fail :passed pl-cmp-test-pass :total pl-cmp-test-count :failures pl-cmp-test-failures}))

lib/prolog/tests/cross_validate.sx

@@ -1,86 +0,0 @@
-;; lib/prolog/tests/cross_validate.sx
-;; Verifies that the compiled solver produces the same solution counts as the
-;; interpreter for each classic program + built-in exercise.
-;; Interpreter is the reference: if they disagree, the compiler is wrong.
-
-(define pl-xv-test-count 0)
-(define pl-xv-test-pass 0)
-(define pl-xv-test-fail 0)
-(define pl-xv-test-failures (list))
-
-(define
-  pl-xv-test!
-  (fn
-    (name got expected)
-    (set! pl-xv-test-count (+ pl-xv-test-count 1))
-    (if
-      (= got expected)
-      (set! pl-xv-test-pass (+ pl-xv-test-pass 1))
-      (begin
-        (set! pl-xv-test-fail (+ pl-xv-test-fail 1))
-        (append! pl-xv-test-failures name)))))
-
-;; Shorthand: assert compiled result matches interpreter.
-(define
-  pl-xv-match!
-  (fn
-    (name src goal)
-    (pl-xv-test! name (pl-compiled-matches-interp? src goal) true)))
-
-;; ── 1. append/3 ─────────────────────────────────────────────────
-
-(define
-  pl-xv-append
-  "append([], L, L). append([H|T], L, [H|R]) :- append(T, L, R).")
-
-(pl-xv-match! "append build 2+2" pl-xv-append "append([1,2],[3,4],X)")
-(pl-xv-match! "append split [a,b,c]" pl-xv-append "append(X, Y, [a,b,c])")
-(pl-xv-match! "append member-mode" pl-xv-append "append(_, [3], [1,2,3])")
-
-;; ── 2. member/2 ─────────────────────────────────────────────────
-
-(define pl-xv-member "member(X, [X|_]). member(X, [_|T]) :- member(X, T).")
-
-(pl-xv-match! "member check hit" pl-xv-member "member(b, [a,b,c])")
-(pl-xv-match! "member count" pl-xv-member "member(X, [a,b,c])")
-(pl-xv-match! "member empty" pl-xv-member "member(X, [])")
-
-;; ── 3. facts + transitive rules ─────────────────────────────────
-
-(define
-  pl-xv-ancestor
-  (str
-    "parent(a,b). parent(b,c). parent(c,d). parent(a,c)."
-    "ancestor(X,Y) :- parent(X,Y)."
-    "ancestor(X,Y) :- parent(X,Z), ancestor(Z,Y)."))
-
-(pl-xv-match! "ancestor direct" pl-xv-ancestor "ancestor(a,b)")
-(pl-xv-match! "ancestor transitive" pl-xv-ancestor "ancestor(a,d)")
-(pl-xv-match! "ancestor all from a" pl-xv-ancestor "ancestor(a,Y)")
-
-;; ── 4. cut semantics ────────────────────────────────────────────
-
-(define pl-xv-cut "first(X,[X|_]) :- !. first(X,[_|T]) :- first(X,T).")
-
-(pl-xv-match! "cut one solution" pl-xv-cut "first(X,[a,b,c])")
-(pl-xv-match! "cut empty list" pl-xv-cut "first(X,[])")
-
-;; ── 5. arithmetic ───────────────────────────────────────────────
-
-(define pl-xv-arith "sq(X,Y) :- Y is X * X. even(X) :- 0 is X mod 2.")
-
-(pl-xv-match! "sq(3,Y) count" pl-xv-arith "sq(3,Y)")
-(pl-xv-match! "sq(3,9) check" pl-xv-arith "sq(3,9)")
-(pl-xv-match! "even(4) check" pl-xv-arith "even(4)")
-(pl-xv-match! "even(3) check" pl-xv-arith "even(3)")
-
-;; ── 6. if-then-else ─────────────────────────────────────────────
-
-(define pl-xv-ite "classify(X, pos) :- X > 0, !. classify(_, nonpos).")
-
-(pl-xv-match! "classify positive" pl-xv-ite "classify(5, C)")
-(pl-xv-match! "classify zero" pl-xv-ite "classify(0, C)")
-
-;; ── Runner ───────────────────────────────────────────────────────
-
-(define pl-cross-validate-tests-run! (fn () {:failed pl-xv-test-fail :passed pl-xv-test-pass :total pl-xv-test-count :failures pl-xv-test-failures}))

lib/prolog/tests/dynamic.sx

@@ -1,158 +0,0 @@
-;; lib/prolog/tests/dynamic.sx — assert/asserta/assertz/retract.
-
-(define pl-dy-test-count 0)
-(define pl-dy-test-pass 0)
-(define pl-dy-test-fail 0)
-(define pl-dy-test-failures (list))
-
-(define
-  pl-dy-test!
-  (fn
-    (name got expected)
-    (begin
-      (set! pl-dy-test-count (+ pl-dy-test-count 1))
-      (if
-        (= got expected)
-        (set! pl-dy-test-pass (+ pl-dy-test-pass 1))
-        (begin
-          (set! pl-dy-test-fail (+ pl-dy-test-fail 1))
-          (append!
-            pl-dy-test-failures
-            (str name "\n    expected: " expected "\n    got:      " got)))))))
-
-(define
-  pl-dy-goal
-  (fn
-    (src env)
-    (pl-instantiate (nth (first (pl-parse (str "g :- " src "."))) 2) env)))
-
-;; assertz then query
-(define pl-dy-db1 (pl-mk-db))
-(pl-solve-once!
-  pl-dy-db1
-  (pl-dy-goal "assertz(foo(1))" {})
-  (pl-mk-trail))
-(pl-dy-test!
-  "assertz(foo(1)) + foo(1)"
-  (pl-solve-once! pl-dy-db1 (pl-dy-goal "foo(1)" {}) (pl-mk-trail))
-  true)
-
-(pl-dy-test!
-  "after one assertz, foo/1 has 1 clause"
-  (pl-solve-count! pl-dy-db1 (pl-dy-goal "foo(X)" {}) (pl-mk-trail))
-  1)
-
-;; assertz appends — order preserved
-(define pl-dy-db2 (pl-mk-db))
-(pl-solve-once!
-  pl-dy-db2
-  (pl-dy-goal "assertz(p(1))" {})
-  (pl-mk-trail))
-(pl-solve-once!
-  pl-dy-db2
-  (pl-dy-goal "assertz(p(2))" {})
-  (pl-mk-trail))
-(pl-dy-test!
-  "assertz twice — count 2"
-  (pl-solve-count! pl-dy-db2 (pl-dy-goal "p(X)" {}) (pl-mk-trail))
-  2)
-
-(define pl-dy-env-a {})
-(pl-solve-once! pl-dy-db2 (pl-dy-goal "p(X)" pl-dy-env-a) (pl-mk-trail))
-(pl-dy-test!
-  "assertz: first solution is the first asserted (1)"
-  (pl-num-val (pl-walk-deep (dict-get pl-dy-env-a "X")))
-  1)
-
-;; asserta prepends
-(define pl-dy-db3 (pl-mk-db))
-(pl-solve-once!
-  pl-dy-db3
-  (pl-dy-goal "assertz(p(1))" {})
-  (pl-mk-trail))
-(pl-solve-once!
-  pl-dy-db3
-  (pl-dy-goal "asserta(p(99))" {})
-  (pl-mk-trail))
-(define pl-dy-env-b {})
-(pl-solve-once! pl-dy-db3 (pl-dy-goal "p(X)" pl-dy-env-b) (pl-mk-trail))
-(pl-dy-test!
-  "asserta: prepended clause is first solution"
-  (pl-num-val (pl-walk-deep (dict-get pl-dy-env-b "X")))
-  99)
-
-;; assert/1 = assertz/1
-(define pl-dy-db4 (pl-mk-db))
-(pl-solve-once!
-  pl-dy-db4
-  (pl-dy-goal "assert(g(7))" {})
-  (pl-mk-trail))
-(pl-dy-test!
-  "assert/1 alias"
-  (pl-solve-once! pl-dy-db4 (pl-dy-goal "g(7)" {}) (pl-mk-trail))
-  true)
-
-;; retract removes a fact
-(define pl-dy-db5 (pl-mk-db))
-(pl-solve-once!
-  pl-dy-db5
-  (pl-dy-goal "assertz(q(1))" {})
-  (pl-mk-trail))
-(pl-solve-once!
-  pl-dy-db5
-  (pl-dy-goal "assertz(q(2))" {})
-  (pl-mk-trail))
-(pl-solve-once!
-  pl-dy-db5
-  (pl-dy-goal "assertz(q(3))" {})
-  (pl-mk-trail))
-(pl-dy-test!
-  "before retract: 3 clauses"
-  (pl-solve-count! pl-dy-db5 (pl-dy-goal "q(X)" {}) (pl-mk-trail))
-  3)
-(pl-solve-once!
-  pl-dy-db5
-  (pl-dy-goal "retract(q(2))" {})
-  (pl-mk-trail))
-(pl-dy-test!
-  "after retract(q(2)): 2 clauses left"
-  (pl-solve-count! pl-dy-db5 (pl-dy-goal "q(X)" {}) (pl-mk-trail))
-  2)
-
-(define pl-dy-env-c {})
-(pl-solve-once! pl-dy-db5 (pl-dy-goal "q(X)" pl-dy-env-c) (pl-mk-trail))
-(pl-dy-test!
-  "after retract(q(2)): first remaining is 1"
-  (pl-num-val (pl-walk-deep (dict-get pl-dy-env-c "X")))
-  1)
-
-;; retract of non-existent
-(pl-dy-test!
-  "retract(missing(0)) on empty db fails"
-  (pl-solve-once!
-    (pl-mk-db)
-    (pl-dy-goal "retract(missing(0))" {})
-    (pl-mk-trail))
-  false)
-
-;; retract with unbound var matches first
-(define pl-dy-db6 (pl-mk-db))
-(pl-solve-once!
-  pl-dy-db6
-  (pl-dy-goal "assertz(r(11))" {})
-  (pl-mk-trail))
-(pl-solve-once!
-  pl-dy-db6
-  (pl-dy-goal "assertz(r(22))" {})
-  (pl-mk-trail))
-(define pl-dy-env-d {})
-(pl-solve-once!
-  pl-dy-db6
-  (pl-dy-goal "retract(r(X))" pl-dy-env-d)
-  (pl-mk-trail))
-(pl-dy-test!
-  "retract(r(X)) binds X to first match"
-  (pl-num-val (pl-walk-deep (dict-get pl-dy-env-d "X")))
-  11)
-
-(define pl-dynamic-tests-run! (fn () {:failed pl-dy-test-fail :passed pl-dy-test-pass :total pl-dy-test-count :failures pl-dy-test-failures}))

lib/prolog/tests/findall.sx

@@ -1,167 +0,0 @@
-;; lib/prolog/tests/findall.sx — findall/3, bagof/3, setof/3.
-
-(define pl-fb-test-count 0)
-(define pl-fb-test-pass 0)
-(define pl-fb-test-fail 0)
-(define pl-fb-test-failures (list))
-
-(define
-  pl-fb-test!
-  (fn
-    (name got expected)
-    (begin
-      (set! pl-fb-test-count (+ pl-fb-test-count 1))
-      (if
-        (= got expected)
-        (set! pl-fb-test-pass (+ pl-fb-test-pass 1))
-        (begin
-          (set! pl-fb-test-fail (+ pl-fb-test-fail 1))
-          (append!
-            pl-fb-test-failures
-            (str name "\n    expected: " expected "\n    got:      " got)))))))
-
-(define
-  pl-fb-term-to-sx
-  (fn
-    (t)
-    (cond
-      ((pl-num? t) (pl-num-val t))
-      ((pl-atom? t) (pl-atom-name t))
-      (true (list :complex)))))
-
-(define
-  pl-fb-list-walked
-  (fn
-    (w)
-    (cond
-      ((and (pl-atom? w) (= (pl-atom-name w) "[]")) (list))
-      ((and (pl-compound? w) (= (pl-fun w) ".") (= (len (pl-args w)) 2))
-        (cons
-          (pl-fb-term-to-sx (first (pl-args w)))
-          (pl-fb-list-walked (nth (pl-args w) 1))))
-      (true (list :not-list)))))
-
-(define pl-fb-list-to-sx (fn (t) (pl-fb-list-walked (pl-walk-deep t))))
-
-(define
-  pl-fb-goal
-  (fn
-    (src env)
-    (pl-instantiate (nth (first (pl-parse (str "g :- " src "."))) 2) env)))
-
-(define pl-fb-prog-src "member(X, [X|_]). member(X, [_|T]) :- member(X, T).")
-
-(define pl-fb-db (pl-mk-db))
-(pl-db-load! pl-fb-db (pl-parse pl-fb-prog-src))
-
-;; ── findall ──
-
-(define pl-fb-env-1 {})
-(pl-solve-once!
-  pl-fb-db
-  (pl-fb-goal "findall(X, member(X, [a, b, c]), L)" pl-fb-env-1)
-  (pl-mk-trail))
-(pl-fb-test!
-  "findall member [a, b, c]"
-  (pl-fb-list-to-sx (dict-get pl-fb-env-1 "L"))
-  (list "a" "b" "c"))
-
-(define pl-fb-env-2 {})
-(pl-solve-once!
-  pl-fb-db
-  (pl-fb-goal "findall(X, (member(X, [1, 2, 3]), X >= 2), L)" pl-fb-env-2)
-  (pl-mk-trail))
-(pl-fb-test!
-  "findall with comparison filter"
-  (pl-fb-list-to-sx (dict-get pl-fb-env-2 "L"))
-  (list 2 3))
-
-(define pl-fb-env-3 {})
-(pl-solve-once!
-  pl-fb-db
-  (pl-fb-goal "findall(X, fail, L)" pl-fb-env-3)
-  (pl-mk-trail))
-(pl-fb-test!
-  "findall on fail succeeds with empty list"
-  (pl-fb-list-to-sx (dict-get pl-fb-env-3 "L"))
-  (list))
-
-(pl-fb-test!
-  "findall(X, fail, L) the goal succeeds"
-  (pl-solve-once!
-    pl-fb-db
-    (pl-fb-goal "findall(X, fail, L)" {})
-    (pl-mk-trail))
-  true)
-
-(define pl-fb-env-4 {})
-(pl-solve-once!
-  pl-fb-db
-  (pl-fb-goal
-    "findall(p(X, Y), (member(X, [1, 2]), member(Y, [a, b])), L)"
-    pl-fb-env-4)
-  (pl-mk-trail))
-(pl-fb-test!
-  "findall over compound template — count = 4"
-  (len (pl-fb-list-to-sx (dict-get pl-fb-env-4 "L")))
-  4)
-
-;; ── bagof ──
-
-(pl-fb-test!
-  "bagof succeeds when results exist"
-  (pl-solve-once!
-    pl-fb-db
-    (pl-fb-goal "bagof(X, member(X, [1, 2, 3]), L)" {})
-    (pl-mk-trail))
-  true)
-
-(pl-fb-test!
-  "bagof fails on empty"
-  (pl-solve-once!
-    pl-fb-db
-    (pl-fb-goal "bagof(X, fail, L)" {})
-    (pl-mk-trail))
-  false)
-
-(define pl-fb-env-5 {})
-(pl-solve-once!
-  pl-fb-db
-  (pl-fb-goal "bagof(X, member(X, [c, a, b]), L)" pl-fb-env-5)
-  (pl-mk-trail))
-(pl-fb-test!
-  "bagof preserves order"
-  (pl-fb-list-to-sx (dict-get pl-fb-env-5 "L"))
-  (list "c" "a" "b"))
-
-;; ── setof ──
-
-(define pl-fb-env-6 {})
-(pl-solve-once!
-  pl-fb-db
-  (pl-fb-goal "setof(X, member(X, [c, a, b, a, c]), L)" pl-fb-env-6)
-  (pl-mk-trail))
-(pl-fb-test!
-  "setof sorts + dedupes atoms"
-  (pl-fb-list-to-sx (dict-get pl-fb-env-6 "L"))
-  (list "a" "b" "c"))
-
-(pl-fb-test!
-  "setof fails on empty"
-  (pl-solve-once!
-    pl-fb-db
-    (pl-fb-goal "setof(X, fail, L)" {})
-    (pl-mk-trail))
-  false)
-
-(define pl-fb-env-7 {})
-(pl-solve-once!
-  pl-fb-db
-  (pl-fb-goal "setof(X, member(X, [3, 1, 2, 1, 3]), L)" pl-fb-env-7)
-  (pl-mk-trail))
-(pl-fb-test!
-  "setof sorts + dedupes nums"
-  (pl-fb-list-to-sx (dict-get pl-fb-env-7 "L"))
-  (list 1 2 3))
-
-(define pl-findall-tests-run! (fn () {:failed pl-fb-test-fail :passed pl-fb-test-pass :total pl-fb-test-count :failures pl-fb-test-failures}))

lib/prolog/tests/io_predicates.sx

@@ -1,326 +0,0 @@
-;; lib/prolog/tests/io_predicates.sx — term_to_atom/2, term_string/2,
-;;   with_output_to/2, writeln/1, format/1, format/2
-
-(define pl-io-test-count 0)
-(define pl-io-test-pass 0)
-(define pl-io-test-fail 0)
-(define pl-io-test-failures (list))
-
-(define
-  pl-io-test!
-  (fn
-    (name got expected)
-    (begin
-      (set! pl-io-test-count (+ pl-io-test-count 1))
-      (if
-        (= got expected)
-        (set! pl-io-test-pass (+ pl-io-test-pass 1))
-        (begin
-          (set! pl-io-test-fail (+ pl-io-test-fail 1))
-          (append!
-            pl-io-test-failures
-            (str name "\n    expected: " expected "\n    got:      " got)))))))
-
-(define
-  pl-io-goal
-  (fn
-    (src env)
-    (pl-instantiate (nth (first (pl-parse (str "g :- " src "."))) 2) env)))
-
-(define pl-io-db (pl-mk-db))
-
-;; helper: get output buffer after running a goal
-(define
-  pl-io-capture!
-  (fn
-    (goal)
-    (do
-      (pl-output-clear!)
-      (pl-solve-once! pl-io-db goal (pl-mk-trail))
-      pl-output-buffer)))
-
-;; ─── term_to_atom/2 — bound Term direction ─────────────────────────────────
-
-(pl-io-test!
-  "term_to_atom(foo(a,b), A) — compound"
-  (let
-    ((env {}))
-    (pl-solve-once!
-      pl-io-db
-      (pl-io-goal "term_to_atom(foo(a,b), A)" env)
-      (pl-mk-trail))
-    (pl-atom-name (pl-walk-deep (dict-get env "A"))))
-  "foo(a, b)")
-
-(pl-io-test!
-  "term_to_atom(hello, A) — atom"
-  (let
-    ((env {}))
-    (pl-solve-once!
-      pl-io-db
-      (pl-io-goal "term_to_atom(hello, A)" env)
-      (pl-mk-trail))
-    (pl-atom-name (pl-walk-deep (dict-get env "A"))))
-  "hello")
-
-(pl-io-test!
-  "term_to_atom(42, A) — number"
-  (let
-    ((env {}))
-    (pl-solve-once!
-      pl-io-db
-      (pl-io-goal "term_to_atom(42, A)" env)
-      (pl-mk-trail))
-    (pl-atom-name (pl-walk-deep (dict-get env "A"))))
-  "42")
-
-(pl-io-test!
-  "term_to_atom(foo(a,b), 'foo(a, b)') — succeeds when Atom matches"
-  (pl-solve-once!
-    pl-io-db
-    (pl-io-goal "term_to_atom(foo(a,b), 'foo(a, b)')" {})
-    (pl-mk-trail))
-  true)
-
-(pl-io-test!
-  "term_to_atom(hello, world) — fails on mismatch"
-  (pl-solve-once!
-    pl-io-db
-    (pl-io-goal "term_to_atom(hello, world)" {})
-    (pl-mk-trail))
-  false)
-
-;; ─── term_to_atom/2 — parse direction (Atom bound, Term unbound) ───────────
-
-(pl-io-test!
-  "term_to_atom(T, 'foo(a)') — parse direction gives compound"
-  (let
-    ((env {}))
-    (pl-solve-once!
-      pl-io-db
-      (pl-io-goal "term_to_atom(T, 'foo(a)')" env)
-      (pl-mk-trail))
-    (let
-      ((t (pl-walk-deep (dict-get env "T"))))
-      (and (pl-compound? t) (= (pl-fun t) "foo"))))
-  true)
-
-(pl-io-test!
-  "term_to_atom(T, hello) — parse direction gives atom"
-  (let
-    ((env {}))
-    (pl-solve-once!
-      pl-io-db
-      (pl-io-goal "term_to_atom(T, hello)" env)
-      (pl-mk-trail))
-    (let
-      ((t (pl-walk-deep (dict-get env "T"))))
-      (and (pl-atom? t) (= (pl-atom-name t) "hello"))))
-  true)
-
-;; ─── term_string/2 — alias ──────────────────────────────────────────────────
-
-(pl-io-test!
-  "term_string(bar(x), A) — same as term_to_atom"
-  (let
-    ((env {}))
-    (pl-solve-once!
-      pl-io-db
-      (pl-io-goal "term_string(bar(x), A)" env)
-      (pl-mk-trail))
-    (pl-atom-name (pl-walk-deep (dict-get env "A"))))
-  "bar(x)")
-
-(pl-io-test!
-  "term_string(42, A) — number to string"
-  (let
-    ((env {}))
-    (pl-solve-once!
-      pl-io-db
-      (pl-io-goal "term_string(42, A)" env)
-      (pl-mk-trail))
-    (pl-atom-name (pl-walk-deep (dict-get env "A"))))
-  "42")
-
-;; ─── writeln/1 ─────────────────────────────────────────────────────────────
-
-(pl-io-test!
-  "writeln(hello) writes 'hello\n'"
-  (let
-    ((env {}))
-    (pl-solve-once!
-      pl-io-db
-      (pl-io-goal "with_output_to(atom(X), writeln(hello))" env)
-      (pl-mk-trail))
-    (pl-atom-name (pl-walk-deep (dict-get env "X"))))
-  "hello
-")
-
-(pl-io-test!
-  "writeln(42) writes '42\n'"
-  (let
-    ((env {}))
-    (pl-solve-once!
-      pl-io-db
-      (pl-io-goal "with_output_to(atom(X), writeln(42))" env)
-      (pl-mk-trail))
-    (pl-atom-name (pl-walk-deep (dict-get env "X"))))
-  "42
-")
-
-;; ─── with_output_to/2 ──────────────────────────────────────────────────────
-
-(pl-io-test!
-  "with_output_to(atom(X), write(foo)) — captures write output"
-  (let
-    ((env {}))
-    (pl-solve-once!
-      pl-io-db
-      (pl-io-goal "with_output_to(atom(X), write(foo))" env)
-      (pl-mk-trail))
-    (pl-atom-name (pl-walk-deep (dict-get env "X"))))
-  "foo")
-
-(pl-io-test!
-  "with_output_to(atom(X), (write(a), write(b))) — concat output"
-  (let
-    ((env {}))
-    (pl-solve-once!
-      pl-io-db
-      (pl-io-goal "with_output_to(atom(X), (write(a), write(b)))" env)
-      (pl-mk-trail))
-    (pl-atom-name (pl-walk-deep (dict-get env "X"))))
-  "ab")
-
-(pl-io-test!
-  "with_output_to(atom(X), nl) — captures newline"
-  (let
-    ((env {}))
-    (pl-solve-once!
-      pl-io-db
-      (pl-io-goal "with_output_to(atom(X), nl)" env)
-      (pl-mk-trail))
-    (pl-atom-name (pl-walk-deep (dict-get env "X"))))
-  "
-")
-
-(pl-io-test!
-  "with_output_to(atom(X), true) — captures empty string"
-  (let
-    ((env {}))
-    (pl-solve-once!
-      pl-io-db
-      (pl-io-goal "with_output_to(atom(X), true)" env)
-      (pl-mk-trail))
-    (pl-atom-name (pl-walk-deep (dict-get env "X"))))
-  "")
-
-(pl-io-test!
-  "with_output_to(string(X), write(hello)) — string sink works"
-  (let
-    ((env {}))
-    (pl-solve-once!
-      pl-io-db
-      (pl-io-goal "with_output_to(string(X), write(hello))" env)
-      (pl-mk-trail))
-    (pl-atom-name (pl-walk-deep (dict-get env "X"))))
-  "hello")
-
-(pl-io-test!
-  "with_output_to(atom(X), fail) — fails when goal fails"
-  (pl-solve-once!
-    pl-io-db
-    (pl-io-goal "with_output_to(atom(X), fail)" {})
-    (pl-mk-trail))
-  false)
-
-;; ─── format/1 ──────────────────────────────────────────────────────────────
-
-(pl-io-test!
-  "format('hello~n') — tilde-n becomes newline"
-  (let
-    ((env {}))
-    (pl-solve-once!
-      pl-io-db
-      (pl-io-goal "with_output_to(atom(X), format('hello~n'))" env)
-      (pl-mk-trail))
-    (pl-atom-name (pl-walk-deep (dict-get env "X"))))
-  "hello
-")
-
-(pl-io-test!
-  "format('~~') — double tilde becomes single tilde"
-  (let
-    ((env {}))
-    (pl-solve-once!
-      pl-io-db
-      (pl-io-goal "with_output_to(atom(X), format('~~'))" env)
-      (pl-mk-trail))
-    (pl-atom-name (pl-walk-deep (dict-get env "X"))))
-  "~")
-
-(pl-io-test!
-  "format('abc') — plain text passes through"
-  (let
-    ((env {}))
-    (pl-solve-once!
-      pl-io-db
-      (pl-io-goal "with_output_to(atom(X), format(abc))" env)
-      (pl-mk-trail))
-    (pl-atom-name (pl-walk-deep (dict-get env "X"))))
-  "abc")
-
-;; ─── format/2 ──────────────────────────────────────────────────────────────
-
-(pl-io-test!
-  "format('~w+~w', [1,2]) — two ~w args"
-  (let
-    ((env {}))
-    (pl-solve-once!
-      pl-io-db
-      (pl-io-goal "with_output_to(atom(X), format('~w+~w', [1,2]))" env)
-      (pl-mk-trail))
-    (pl-atom-name (pl-walk-deep (dict-get env "X"))))
-  "1+2")
-
-(pl-io-test!
-  "format('hello ~a!', [world]) — ~a with atom arg"
-  (let
-    ((env {}))
-    (pl-solve-once!
-      pl-io-db
-      (pl-io-goal "with_output_to(atom(X), format('hello ~a!', [world]))" env)
-      (pl-mk-trail))
-    (pl-atom-name (pl-walk-deep (dict-get env "X"))))
-  "hello world!")
-
-(pl-io-test!
-  "format('n=~d', [42]) — ~d with integer arg"
-  (let
-    ((env {}))
-    (pl-solve-once!
-      pl-io-db
-      (pl-io-goal "with_output_to(atom(X), format('n=~d', [42]))" env)
-      (pl-mk-trail))
-    (pl-atom-name (pl-walk-deep (dict-get env "X"))))
-  "n=42")
-
-(pl-io-test!
-  "format('~w', [foo(a)]) — ~w with compound"
-  (let
-    ((env {}))
-    (pl-solve-once!
-      pl-io-db
-      (pl-io-goal "with_output_to(atom(X), format('~w', [foo(a)]))" env)
-      (pl-mk-trail))
-    (pl-atom-name (pl-walk-deep (dict-get env "X"))))
-  "foo(a)")
-
-(define
-  pl-io-predicates-tests-run!
-  (fn
-    ()
-    {:failed pl-io-test-fail
-      :passed pl-io-test-pass
-      :total pl-io-test-count
-      :failures pl-io-test-failures}))

lib/prolog/tests/iso_predicates.sx

@@ -1,320 +0,0 @@
-;; lib/prolog/tests/iso_predicates.sx — succ/2, plus/3, between/3, length/2, last/2, nth0/3, nth1/3, max/min arith
-
-(define pl-ip-test-count 0)
-(define pl-ip-test-pass 0)
-(define pl-ip-test-fail 0)
-(define pl-ip-test-failures (list))
-
-(define
-  pl-ip-test!
-  (fn
-    (name got expected)
-    (begin
-      (set! pl-ip-test-count (+ pl-ip-test-count 1))
-      (if
-        (= got expected)
-        (set! pl-ip-test-pass (+ pl-ip-test-pass 1))
-        (begin
-          (set! pl-ip-test-fail (+ pl-ip-test-fail 1))
-          (append!
-            pl-ip-test-failures
-            (str name "\n    expected: " expected "\n    got:      " got)))))))
-
-(define
-  pl-ip-goal
-  (fn
-    (src env)
-    (pl-instantiate (nth (first (pl-parse (str "g :- " src "."))) 2) env)))
-
-(define pl-ip-db (pl-mk-db))
-
-;; ── succ/2 ──
-
-(define pl-ip-env-s1 {})
-(pl-solve-once!
-  pl-ip-db
-  (pl-ip-goal "succ(3, X)" pl-ip-env-s1)
-  (pl-mk-trail))
-(pl-ip-test!
-  "succ(3, X) → X=4"
-  (pl-num-val (pl-walk-deep (dict-get pl-ip-env-s1 "X")))
-  4)
-
-(define pl-ip-env-s2 {})
-(pl-solve-once!
-  pl-ip-db
-  (pl-ip-goal "succ(0, X)" pl-ip-env-s2)
-  (pl-mk-trail))
-(pl-ip-test!
-  "succ(0, X) → X=1"
-  (pl-num-val (pl-walk-deep (dict-get pl-ip-env-s2 "X")))
-  1)
-
-(define pl-ip-env-s3 {})
-(pl-solve-once!
-  pl-ip-db
-  (pl-ip-goal "succ(X, 5)" pl-ip-env-s3)
-  (pl-mk-trail))
-(pl-ip-test!
-  "succ(X, 5) → X=4"
-  (pl-num-val (pl-walk-deep (dict-get pl-ip-env-s3 "X")))
-  4)
-
-(pl-ip-test!
-  "succ(X, 0) fails"
-  (pl-solve-once!
-    pl-ip-db
-    (pl-ip-goal "succ(X, 0)" {})
-    (pl-mk-trail))
-  false)
-
-;; ── plus/3 ──
-
-(define pl-ip-env-p1 {})
-(pl-solve-once!
-  pl-ip-db
-  (pl-ip-goal "plus(2, 3, X)" pl-ip-env-p1)
-  (pl-mk-trail))
-(pl-ip-test!
-  "plus(2, 3, X) → X=5"
-  (pl-num-val (pl-walk-deep (dict-get pl-ip-env-p1 "X")))
-  5)
-
-(define pl-ip-env-p2 {})
-(pl-solve-once!
-  pl-ip-db
-  (pl-ip-goal "plus(2, X, 7)" pl-ip-env-p2)
-  (pl-mk-trail))
-(pl-ip-test!
-  "plus(2, X, 7) → X=5"
-  (pl-num-val (pl-walk-deep (dict-get pl-ip-env-p2 "X")))
-  5)
-
-(define pl-ip-env-p3 {})
-(pl-solve-once!
-  pl-ip-db
-  (pl-ip-goal "plus(X, 3, 7)" pl-ip-env-p3)
-  (pl-mk-trail))
-(pl-ip-test!
-  "plus(X, 3, 7) → X=4"
-  (pl-num-val (pl-walk-deep (dict-get pl-ip-env-p3 "X")))
-  4)
-
-(pl-ip-test!
-  "plus(0, 0, 0) succeeds"
-  (pl-solve-once!
-    pl-ip-db
-    (pl-ip-goal "plus(0, 0, 0)" {})
-    (pl-mk-trail))
-  true)
-
-;; ── between/3 ──
-
-(pl-ip-test!
-  "between(1, 3, X): 3 solutions"
-  (pl-solve-count!
-    pl-ip-db
-    (pl-ip-goal "between(1, 3, X)" {})
-    (pl-mk-trail))
-  3)
-
-(pl-ip-test!
-  "between(1, 3, 2) succeeds"
-  (pl-solve-once!
-    pl-ip-db
-    (pl-ip-goal "between(1, 3, 2)" {})
-    (pl-mk-trail))
-  true)
-
-(pl-ip-test!
-  "between(1, 3, 5) fails"
-  (pl-solve-once!
-    pl-ip-db
-    (pl-ip-goal "between(1, 3, 5)" {})
-    (pl-mk-trail))
-  false)
-
-(pl-ip-test!
-  "between(5, 3, X): 0 solutions (empty range)"
-  (pl-solve-count!
-    pl-ip-db
-    (pl-ip-goal "between(5, 3, X)" {})
-    (pl-mk-trail))
-  0)
-
-(define pl-ip-env-b1 {})
-(pl-solve-once!
-  pl-ip-db
-  (pl-ip-goal "between(1, 5, X)" pl-ip-env-b1)
-  (pl-mk-trail))
-(pl-ip-test!
-  "between(1, 5, X): first solution X=1"
-  (pl-num-val (pl-walk-deep (dict-get pl-ip-env-b1 "X")))
-  1)
-
-(pl-ip-test!
-  "between + condition: between(1,5,X), X > 3 → 2 solutions"
-  (pl-solve-count!
-    pl-ip-db
-    (pl-ip-goal "between(1, 5, X), X > 3" {})
-    (pl-mk-trail))
-  2)
-
-;; ── length/2 ──
-
-(define pl-ip-env-l1 {})
-(pl-solve-once!
-  pl-ip-db
-  (pl-ip-goal "length([1,2,3], N)" pl-ip-env-l1)
-  (pl-mk-trail))
-(pl-ip-test!
-  "length([1,2,3], N) → N=3"
-  (pl-num-val (pl-walk-deep (dict-get pl-ip-env-l1 "N")))
-  3)
-
-(define pl-ip-env-l2 {})
-(pl-solve-once!
-  pl-ip-db
-  (pl-ip-goal "length([], N)" pl-ip-env-l2)
-  (pl-mk-trail))
-(pl-ip-test!
-  "length([], N) → N=0"
-  (pl-num-val (pl-walk-deep (dict-get pl-ip-env-l2 "N")))
-  0)
-
-(pl-ip-test!
-  "length([a,b], 2) check succeeds"
-  (pl-solve-once!
-    pl-ip-db
-    (pl-ip-goal "length([a,b], 2)" {})
-    (pl-mk-trail))
-  true)
-
-(define pl-ip-env-l3 {})
-(pl-solve-once!
-  pl-ip-db
-  (pl-ip-goal "length(L, 3)" pl-ip-env-l3)
-  (pl-mk-trail))
-(pl-ip-test!
-  "length(L, 3): L is a list of length 3"
-  (pl-solve-once!
-    pl-ip-db
-    (pl-ip-goal "length(L, 3), is_list(L)" pl-ip-env-l3)
-    (pl-mk-trail))
-  true)
-
-;; ── last/2 ──
-
-(define pl-ip-env-la1 {})
-(pl-solve-once!
-  pl-ip-db
-  (pl-ip-goal "last([1,2,3], X)" pl-ip-env-la1)
-  (pl-mk-trail))
-(pl-ip-test!
-  "last([1,2,3], X) → X=3"
-  (pl-num-val (pl-walk-deep (dict-get pl-ip-env-la1 "X")))
-  3)
-
-(define pl-ip-env-la2 {})
-(pl-solve-once!
-  pl-ip-db
-  (pl-ip-goal "last([a], X)" pl-ip-env-la2)
-  (pl-mk-trail))
-(pl-ip-test!
-  "last([a], X) → X=a"
-  (pl-atom-name (pl-walk-deep (dict-get pl-ip-env-la2 "X")))
-  "a")
-
-(pl-ip-test!
-  "last([], X) fails"
-  (pl-solve-once!
-    pl-ip-db
-    (pl-ip-goal "last([], X)" {})
-    (pl-mk-trail))
-  false)
-
-;; ── nth0/3 ──
-
-(define pl-ip-env-n0 {})
-(pl-solve-once!
-  pl-ip-db
-  (pl-ip-goal "nth0(0, [a,b,c], X)" pl-ip-env-n0)
-  (pl-mk-trail))
-(pl-ip-test!
-  "nth0(0, [a,b,c], X) → X=a"
-  (pl-atom-name (pl-walk-deep (dict-get pl-ip-env-n0 "X")))
-  "a")
-
-(define pl-ip-env-n1 {})
-(pl-solve-once!
-  pl-ip-db
-  (pl-ip-goal "nth0(2, [a,b,c], X)" pl-ip-env-n1)
-  (pl-mk-trail))
-(pl-ip-test!
-  "nth0(2, [a,b,c], X) → X=c"
-  (pl-atom-name (pl-walk-deep (dict-get pl-ip-env-n1 "X")))
-  "c")
-
-(pl-ip-test!
-  "nth0(5, [a,b,c], X) fails"
-  (pl-solve-once!
-    pl-ip-db
-    (pl-ip-goal "nth0(5, [a,b,c], X)" {})
-    (pl-mk-trail))
-  false)
-
-;; ── nth1/3 ──
-
-(define pl-ip-env-n1a {})
-(pl-solve-once!
-  pl-ip-db
-  (pl-ip-goal "nth1(1, [a,b,c], X)" pl-ip-env-n1a)
-  (pl-mk-trail))
-(pl-ip-test!
-  "nth1(1, [a,b,c], X) → X=a"
-  (pl-atom-name (pl-walk-deep (dict-get pl-ip-env-n1a "X")))
-  "a")
-
-(define pl-ip-env-n1b {})
-(pl-solve-once!
-  pl-ip-db
-  (pl-ip-goal "nth1(3, [a,b,c], X)" pl-ip-env-n1b)
-  (pl-mk-trail))
-(pl-ip-test!
-  "nth1(3, [a,b,c], X) → X=c"
-  (pl-atom-name (pl-walk-deep (dict-get pl-ip-env-n1b "X")))
-  "c")
-
-;; ── max/min in arithmetic ──
-
-(define pl-ip-env-m1 {})
-(pl-solve-once!
-  pl-ip-db
-  (pl-ip-goal "X is max(3, 5)" pl-ip-env-m1)
-  (pl-mk-trail))
-(pl-ip-test!
-  "X is max(3, 5) → X=5"
-  (pl-num-val (pl-walk-deep (dict-get pl-ip-env-m1 "X")))
-  5)
-
-(define pl-ip-env-m2 {})
-(pl-solve-once!
-  pl-ip-db
-  (pl-ip-goal "X is min(3, 5)" pl-ip-env-m2)
-  (pl-mk-trail))
-(pl-ip-test!
-  "X is min(3, 5) → X=3"
-  (pl-num-val (pl-walk-deep (dict-get pl-ip-env-m2 "X")))
-  3)
-
-(define pl-ip-env-m3 {})
-(pl-solve-once!
-  pl-ip-db
-  (pl-ip-goal "X is max(7, 2) + min(1, 4)" pl-ip-env-m3)
-  (pl-mk-trail))
-(pl-ip-test!
-  "X is max(7,2) + min(1,4) → X=8"
-  (pl-num-val (pl-walk-deep (dict-get pl-ip-env-m3 "X")))
-  8)
-
-(define pl-iso-predicates-tests-run! (fn () {:failed pl-ip-test-fail :passed pl-ip-test-pass :total pl-ip-test-count :failures pl-ip-test-failures}))

lib/prolog/tests/list_predicates.sx

@@ -1,335 +0,0 @@
-;; lib/prolog/tests/list_predicates.sx — ==/2, \==/2, flatten/2, numlist/3,
-;;   atomic_list_concat/2,3, sum_list/2, max_list/2, min_list/2, delete/3
-
-(define pl-lp-test-count 0)
-(define pl-lp-test-pass 0)
-(define pl-lp-test-fail 0)
-(define pl-lp-test-failures (list))
-
-(define
-  pl-lp-test!
-  (fn
-    (name got expected)
-    (begin
-      (set! pl-lp-test-count (+ pl-lp-test-count 1))
-      (if
-        (= got expected)
-        (set! pl-lp-test-pass (+ pl-lp-test-pass 1))
-        (begin
-          (set! pl-lp-test-fail (+ pl-lp-test-fail 1))
-          (append!
-            pl-lp-test-failures
-            (str name "\n    expected: " expected "\n    got:      " got)))))))
-
-(define
-  pl-lp-goal
-  (fn
-    (src env)
-    (pl-instantiate (nth (first (pl-parse (str "g :- " src "."))) 2) env)))
-
-(define pl-lp-db (pl-mk-db))
-
-;; ── ==/2 ───────────────────────────────────────────────────────────
-
-(pl-lp-test!
-  "==(a, a) succeeds"
-  (pl-solve-once! pl-lp-db (pl-lp-goal "==(a, a)" {}) (pl-mk-trail))
-  true)
-
-(pl-lp-test!
-  "==(a, b) fails"
-  (pl-solve-once! pl-lp-db (pl-lp-goal "==(a, b)" {}) (pl-mk-trail))
-  false)
-
-(pl-lp-test!
-  "==(1, 1) succeeds"
-  (pl-solve-once! pl-lp-db (pl-lp-goal "==(1, 1)" {}) (pl-mk-trail))
-  true)
-
-(pl-lp-test!
-  "==(1, 2) fails"
-  (pl-solve-once! pl-lp-db (pl-lp-goal "==(1, 2)" {}) (pl-mk-trail))
-  false)
-
-(pl-lp-test!
-  "==(f(a,b), f(a,b)) succeeds"
-  (pl-solve-once!
-    pl-lp-db
-    (pl-lp-goal "==(f(a,b), f(a,b))" {})
-    (pl-mk-trail))
-  true)
-
-(pl-lp-test!
-  "==(f(a,b), f(a,c)) fails"
-  (pl-solve-once!
-    pl-lp-db
-    (pl-lp-goal "==(f(a,b), f(a,c))" {})
-    (pl-mk-trail))
-  false)
-
-;; unbound var vs atom: fails (different tags)
-(pl-lp-test!
-  "==(X, a) fails (unbound var vs atom)"
-  (pl-solve-once! pl-lp-db (pl-lp-goal "==(X, a)" {}) (pl-mk-trail))
-  false)
-
-;; two unbound vars with SAME name in same env share the same runtime var
-(define pl-lp-env-same-var {})
-(pl-lp-goal "==(X, X)" pl-lp-env-same-var)
-(pl-lp-test!
-  "==(X, X) succeeds (same runtime var)"
-  (pl-solve-once!
-    pl-lp-db
-    (pl-instantiate
-      (nth (first (pl-parse "g :- ==(X, X).")) 2)
-      pl-lp-env-same-var)
-    (pl-mk-trail))
-  true)
-
-;; ── \==/2 ──────────────────────────────────────────────────────────
-
-(pl-lp-test!
-  "\\==(a, b) succeeds"
-  (pl-solve-once! pl-lp-db (pl-lp-goal "\\==(a, b)" {}) (pl-mk-trail))
-  true)
-
-(pl-lp-test!
-  "\\==(a, a) fails"
-  (pl-solve-once! pl-lp-db (pl-lp-goal "\\==(a, a)" {}) (pl-mk-trail))
-  false)
-
-(pl-lp-test!
-  "\\==(X, a) succeeds (unbound var differs from atom)"
-  (pl-solve-once! pl-lp-db (pl-lp-goal "\\==(X, a)" {}) (pl-mk-trail))
-  true)
-
-(pl-lp-test!
-  "\\==(1, 2) succeeds"
-  (pl-solve-once! pl-lp-db (pl-lp-goal "\\==(1, 2)" {}) (pl-mk-trail))
-  true)
-
-;; ── flatten/2 ──────────────────────────────────────────────────────
-
-(define pl-lp-env-fl1 {})
-(pl-solve-once!
-  pl-lp-db
-  (pl-lp-goal "flatten([], F)" pl-lp-env-fl1)
-  (pl-mk-trail))
-(pl-lp-test!
-  "flatten([], []) -> empty"
-  (pl-format-term (pl-walk-deep (dict-get pl-lp-env-fl1 "F")))
-  "[]")
-
-(define pl-lp-env-fl2 {})
-(pl-solve-once!
-  pl-lp-db
-  (pl-lp-goal "flatten([1,2,3], F)" pl-lp-env-fl2)
-  (pl-mk-trail))
-(pl-lp-test!
-  "flatten([1,2,3], F) -> [1,2,3]"
-  (pl-format-term (pl-walk-deep (dict-get pl-lp-env-fl2 "F")))
-  ".(1, .(2, .(3, [])))")
-
-(define pl-lp-env-fl3 {})
-(pl-solve-once!
-  pl-lp-db
-  (pl-lp-goal "flatten([1,[2,[3]],4], F)" pl-lp-env-fl3)
-  (pl-mk-trail))
-(pl-lp-test!
-  "flatten([1,[2,[3]],4], F) -> [1,2,3,4]"
-  (pl-format-term (pl-walk-deep (dict-get pl-lp-env-fl3 "F")))
-  ".(1, .(2, .(3, .(4, []))))")
-
-(define pl-lp-env-fl4 {})
-(pl-solve-once!
-  pl-lp-db
-  (pl-lp-goal "flatten([[a,b],[c]], F)" pl-lp-env-fl4)
-  (pl-mk-trail))
-(pl-lp-test!
-  "flatten([[a,b],[c]], F) -> [a,b,c]"
-  (pl-format-term (pl-walk-deep (dict-get pl-lp-env-fl4 "F")))
-  ".(a, .(b, .(c, [])))")
-
-;; ── numlist/3 ──────────────────────────────────────────────────────
-
-(define pl-lp-env-nl1 {})
-(pl-solve-once!
-  pl-lp-db
-  (pl-lp-goal "numlist(1, 5, L)" pl-lp-env-nl1)
-  (pl-mk-trail))
-(pl-lp-test!
-  "numlist(1,5,L) -> [1,2,3,4,5]"
-  (pl-format-term (pl-walk-deep (dict-get pl-lp-env-nl1 "L")))
-  ".(1, .(2, .(3, .(4, .(5, [])))))")
-
-(define pl-lp-env-nl2 {})
-(pl-solve-once!
-  pl-lp-db
-  (pl-lp-goal "numlist(3, 3, L)" pl-lp-env-nl2)
-  (pl-mk-trail))
-(pl-lp-test!
-  "numlist(3,3,L) -> [3]"
-  (pl-format-term (pl-walk-deep (dict-get pl-lp-env-nl2 "L")))
-  ".(3, [])")
-
-(pl-lp-test!
-  "numlist(5, 3, L) fails (Low > High)"
-  (pl-solve-once!
-    pl-lp-db
-    (pl-lp-goal "numlist(5, 3, L)" {})
-    (pl-mk-trail))
-  false)
-
-;; ── atomic_list_concat/2 ───────────────────────────────────────────
-
-(define pl-lp-env-alc1 {})
-(pl-solve-once!
-  pl-lp-db
-  (pl-lp-goal "atomic_list_concat([a, b, c], R)" pl-lp-env-alc1)
-  (pl-mk-trail))
-(pl-lp-test!
-  "atomic_list_concat([a,b,c], R) -> abc"
-  (pl-atom-name (pl-walk-deep (dict-get pl-lp-env-alc1 "R")))
-  "abc")
-
-(define pl-lp-env-alc2 {})
-(pl-solve-once!
-  pl-lp-db
-  (pl-lp-goal "atomic_list_concat([hello, world], R)" pl-lp-env-alc2)
-  (pl-mk-trail))
-(pl-lp-test!
-  "atomic_list_concat([hello,world], R) -> helloworld"
-  (pl-atom-name (pl-walk-deep (dict-get pl-lp-env-alc2 "R")))
-  "helloworld")
-
-;; ── atomic_list_concat/3 ───────────────────────────────────────────
-
-(define pl-lp-env-alcs1 {})
-(pl-solve-once!
-  pl-lp-db
-  (pl-lp-goal "atomic_list_concat([a, b, c], '-', R)" pl-lp-env-alcs1)
-  (pl-mk-trail))
-(pl-lp-test!
-  "atomic_list_concat([a,b,c], '-', R) -> a-b-c"
-  (pl-atom-name (pl-walk-deep (dict-get pl-lp-env-alcs1 "R")))
-  "a-b-c")
-
-(define pl-lp-env-alcs2 {})
-(pl-solve-once!
-  pl-lp-db
-  (pl-lp-goal "atomic_list_concat([x], '-', R)" pl-lp-env-alcs2)
-  (pl-mk-trail))
-(pl-lp-test!
-  "atomic_list_concat([x], '-', R) -> x (single element, no sep)"
-  (pl-atom-name (pl-walk-deep (dict-get pl-lp-env-alcs2 "R")))
-  "x")
-
-;; ── sum_list/2 ─────────────────────────────────────────────────────
-
-(define pl-lp-env-sl1 {})
-(pl-solve-once!
-  pl-lp-db
-  (pl-lp-goal "sum_list([1,2,3], S)" pl-lp-env-sl1)
-  (pl-mk-trail))
-(pl-lp-test!
-  "sum_list([1,2,3], S) -> 6"
-  (pl-num-val (pl-walk-deep (dict-get pl-lp-env-sl1 "S")))
-  6)
-
-(define pl-lp-env-sl2 {})
-(pl-solve-once!
-  pl-lp-db
-  (pl-lp-goal "sum_list([10], S)" pl-lp-env-sl2)
-  (pl-mk-trail))
-(pl-lp-test!
-  "sum_list([10], S) -> 10"
-  (pl-num-val (pl-walk-deep (dict-get pl-lp-env-sl2 "S")))
-  10)
-
-(define pl-lp-env-sl3 {})
-(pl-solve-once!
-  pl-lp-db
-  (pl-lp-goal "sum_list([], S)" pl-lp-env-sl3)
-  (pl-mk-trail))
-(pl-lp-test!
-  "sum_list([], S) -> 0"
-  (pl-num-val (pl-walk-deep (dict-get pl-lp-env-sl3 "S")))
-  0)
-
-;; ── max_list/2 ─────────────────────────────────────────────────────
-
-(define pl-lp-env-mx1 {})
-(pl-solve-once!
-  pl-lp-db
-  (pl-lp-goal "max_list([3,1,4,1,5,9,2,6], M)" pl-lp-env-mx1)
-  (pl-mk-trail))
-(pl-lp-test!
-  "max_list([3,1,4,1,5,9,2,6], M) -> 9"
-  (pl-num-val (pl-walk-deep (dict-get pl-lp-env-mx1 "M")))
-  9)
-
-(define pl-lp-env-mx2 {})
-(pl-solve-once!
-  pl-lp-db
-  (pl-lp-goal "max_list([7], M)" pl-lp-env-mx2)
-  (pl-mk-trail))
-(pl-lp-test!
-  "max_list([7], M) -> 7"
-  (pl-num-val (pl-walk-deep (dict-get pl-lp-env-mx2 "M")))
-  7)
-
-;; ── min_list/2 ─────────────────────────────────────────────────────
-
-(define pl-lp-env-mn1 {})
-(pl-solve-once!
-  pl-lp-db
-  (pl-lp-goal "min_list([3,1,4,1,5,9,2,6], M)" pl-lp-env-mn1)
-  (pl-mk-trail))
-(pl-lp-test!
-  "min_list([3,1,4,1,5,9,2,6], M) -> 1"
-  (pl-num-val (pl-walk-deep (dict-get pl-lp-env-mn1 "M")))
-  1)
-
-(define pl-lp-env-mn2 {})
-(pl-solve-once!
-  pl-lp-db
-  (pl-lp-goal "min_list([5,2,8], M)" pl-lp-env-mn2)
-  (pl-mk-trail))
-(pl-lp-test!
-  "min_list([5,2,8], M) -> 2"
-  (pl-num-val (pl-walk-deep (dict-get pl-lp-env-mn2 "M")))
-  2)
-
-;; ── delete/3 ───────────────────────────────────────────────────────
-
-(define pl-lp-env-del1 {})
-(pl-solve-once!
-  pl-lp-db
-  (pl-lp-goal "delete([1,2,3,2,1], 2, R)" pl-lp-env-del1)
-  (pl-mk-trail))
-(pl-lp-test!
-  "delete([1,2,3,2,1], 2, R) -> [1,3,1]"
-  (pl-format-term (pl-walk-deep (dict-get pl-lp-env-del1 "R")))
-  ".(1, .(3, .(1, [])))")
-
-(define pl-lp-env-del2 {})
-(pl-solve-once!
-  pl-lp-db
-  (pl-lp-goal "delete([a,b,c], d, R)" pl-lp-env-del2)
-  (pl-mk-trail))
-(pl-lp-test!
-  "delete([a,b,c], d, R) -> [a,b,c] (nothing deleted)"
-  (pl-format-term (pl-walk-deep (dict-get pl-lp-env-del2 "R")))
-  ".(a, .(b, .(c, [])))")
-
-(define pl-lp-env-del3 {})
-(pl-solve-once!
-  pl-lp-db
-  (pl-lp-goal "delete([], x, R)" pl-lp-env-del3)
-  (pl-mk-trail))
-(pl-lp-test!
-  "delete([], x, R) -> []"
-  (pl-format-term (pl-walk-deep (dict-get pl-lp-env-del3 "R")))
-  "[]")
-
-(define pl-list-predicates-tests-run! (fn () {:failed pl-lp-test-fail :passed pl-lp-test-pass :total pl-lp-test-count :failures pl-lp-test-failures}))

lib/prolog/tests/meta_call.sx

@@ -1,197 +0,0 @@
-;; lib/prolog/tests/meta_call.sx — forall/2, maplist/2, maplist/3, include/3, exclude/3
-(define pl-mc-test-count 0)
-(define pl-mc-test-pass 0)
-(define pl-mc-test-fail 0)
-(define pl-mc-test-failures (list))
-
-(define
-  pl-mc-test!
-  (fn
-    (name got expected)
-    (begin
-      (set! pl-mc-test-count (+ pl-mc-test-count 1))
-      (if
-        (= got expected)
-        (set! pl-mc-test-pass (+ pl-mc-test-pass 1))
-        (begin
-          (set! pl-mc-test-fail (+ pl-mc-test-fail 1))
-          (append!
-            pl-mc-test-failures
-            (str name "\n    expected: " expected "\n    got:      " got)))))))
-
-(define
-  pl-mc-goal
-  (fn
-    (src env)
-    (pl-instantiate (nth (first (pl-parse (str "g :- " src "."))) 2) env)))
-
-(define
-  pl-mc-term-to-sx
-  (fn
-    (t)
-    (cond
-      ((pl-num? t) (pl-num-val t))
-      ((pl-atom? t) (pl-atom-name t))
-      (else t))))
-
-(define
-  pl-mc-list-sx
-  (fn
-    (t)
-    (let
-      ((w (pl-walk-deep t)))
-      (cond
-        ((and (pl-atom? w) (= (pl-atom-name w) "[]")) (list))
-        ((and (pl-compound? w) (= (pl-fun w) "."))
-          (cons
-            (pl-mc-term-to-sx (first (pl-args w)))
-            (pl-mc-list-sx (nth (pl-args w) 1))))
-        (else (list :not-list))))))
-
-(define pl-mc-db (pl-mk-db))
-
-(pl-db-load!
-  pl-mc-db
-  (pl-parse "member(X, [X|_]). member(X, [_|T]) :- member(X, T)."))
-
-(pl-db-load! pl-mc-db (pl-parse "double(X, Y) :- Y is X * 2."))
-
-(pl-db-load! pl-mc-db (pl-parse "even(X) :- 0 is X mod 2."))
-
-;; -- forall/2 --
-
-(pl-mc-test!
-  "forall(member(X,[2,4,6]), 0 is X mod 2) — all even"
-  (pl-solve-once!
-    pl-mc-db
-    (pl-mc-goal "forall(member(X,[2,4,6]), 0 is X mod 2)" {})
-    (pl-mk-trail))
-  true)
-
-(pl-mc-test!
-  "forall(member(X,[2,3,6]), 0 is X mod 2) — 3 is odd, fails"
-  (pl-solve-once!
-    pl-mc-db
-    (pl-mc-goal "forall(member(X,[2,3,6]), 0 is X mod 2)" {})
-    (pl-mk-trail))
-  false)
-
-(pl-mc-test!
-  "forall(member(_,[]), true) — vacuously true"
-  (pl-solve-once!
-    pl-mc-db
-    (pl-mc-goal "forall(member(_,[]), true)" {})
-    (pl-mk-trail))
-  true)
-
-;; -- maplist/2 --
-
-(pl-mc-test!
-  "maplist(atom, [a,b,c]) — all atoms"
-  (pl-solve-once!
-    pl-mc-db
-    (pl-mc-goal "maplist(atom, [a,b,c])" {})
-    (pl-mk-trail))
-  true)
-
-(pl-mc-test!
-  "maplist(atom, [a,1,c]) — 1 is not atom, fails"
-  (pl-solve-once!
-    pl-mc-db
-    (pl-mc-goal "maplist(atom, [a,1,c])" {})
-    (pl-mk-trail))
-  false)
-
-(pl-mc-test!
-  "maplist(atom, []) — vacuously true"
-  (pl-solve-once!
-    pl-mc-db
-    (pl-mc-goal "maplist(atom, [])" {})
-    (pl-mk-trail))
-  true)
-
-;; -- maplist/3 --
-
-(pl-mc-test!
-  "maplist(double, [1,2,3], [2,4,6]) — deterministic check"
-  (pl-solve-once!
-    pl-mc-db
-    (pl-mc-goal "maplist(double, [1,2,3], [2,4,6])" {})
-    (pl-mk-trail))
-  true)
-
-(pl-mc-test!
-  "maplist(double, [1,2,3], [2,4,7]) — wrong result fails"
-  (pl-solve-once!
-    pl-mc-db
-    (pl-mc-goal "maplist(double, [1,2,3], [2,4,7])" {})
-    (pl-mk-trail))
-  false)
-
-(define pl-mc-env-ml3 {:L (pl-mk-rt-var "L")})
-(pl-solve-once!
-  pl-mc-db
-  (pl-mc-goal "maplist(double, [1,2,3], L)" pl-mc-env-ml3)
-  (pl-mk-trail))
-(pl-mc-test!
-  "maplist(double, [1,2,3], L) — L bound to [2,4,6]"
-  (pl-mc-list-sx (dict-get pl-mc-env-ml3 "L"))
-  (list 2 4 6))
-
-;; -- include/3 --
-
-(pl-mc-test!
-  "include(even, [1,2,3,4,5,6], [2,4,6])"
-  (pl-solve-once!
-    pl-mc-db
-    (pl-mc-goal "include(even, [1,2,3,4,5,6], [2,4,6])" {})
-    (pl-mk-trail))
-  true)
-
-(pl-mc-test!
-  "include(even, [], [])"
-  (pl-solve-once!
-    pl-mc-db
-    (pl-mc-goal "include(even, [], [])" {})
-    (pl-mk-trail))
-  true)
-
-(define pl-mc-env-inc {:R (pl-mk-rt-var "R")})
-(pl-solve-once!
-  pl-mc-db
-  (pl-mc-goal "include(even, [1,2,3,4,5,6], R)" pl-mc-env-inc)
-  (pl-mk-trail))
-(pl-mc-test!
-  "include(even, [1,2,3,4,5,6], R) — R bound to [2,4,6]"
-  (pl-mc-list-sx (dict-get pl-mc-env-inc "R"))
-  (list 2 4 6))
-
-;; -- exclude/3 --
-
-(pl-mc-test!
-  "exclude(even, [1,2,3,4,5,6], [1,3,5])"
-  (pl-solve-once!
-    pl-mc-db
-    (pl-mc-goal "exclude(even, [1,2,3,4,5,6], [1,3,5])" {})
-    (pl-mk-trail))
-  true)
-
-(pl-mc-test!
-  "exclude(even, [], [])"
-  (pl-solve-once!
-    pl-mc-db
-    (pl-mc-goal "exclude(even, [], [])" {})
-    (pl-mk-trail))
-  true)
-
-(define pl-mc-env-exc {:R (pl-mk-rt-var "R")})
-(pl-solve-once!
-  pl-mc-db
-  (pl-mc-goal "exclude(even, [1,2,3,4,5,6], R)" pl-mc-env-exc)
-  (pl-mk-trail))
-(pl-mc-test!
-  "exclude(even, [1,2,3,4,5,6], R) — R bound to [1,3,5]"
-  (pl-mc-list-sx (dict-get pl-mc-env-exc "R"))
-  (list 1 3 5))
-
-(define pl-meta-call-tests-run! (fn () {:failed pl-mc-test-fail :passed pl-mc-test-pass :total pl-mc-test-count :failures pl-mc-test-failures}))

lib/prolog/tests/meta_predicates.sx

@@ -1,252 +0,0 @@
-;; lib/prolog/tests/meta_predicates.sx — \+/1, not/1, once/1, ignore/1, ground/1, sort/2, msort/2, atom_number/2, number_string/2
-
-(define pl-mp-test-count 0)
-(define pl-mp-test-pass 0)
-(define pl-mp-test-fail 0)
-(define pl-mp-test-failures (list))
-
-(define
-  pl-mp-test!
-  (fn
-    (name got expected)
-    (begin
-      (set! pl-mp-test-count (+ pl-mp-test-count 1))
-      (if
-        (= got expected)
-        (set! pl-mp-test-pass (+ pl-mp-test-pass 1))
-        (begin
-          (set! pl-mp-test-fail (+ pl-mp-test-fail 1))
-          (append!
-            pl-mp-test-failures
-            (str name "\n    expected: " expected "\n    got:      " got)))))))
-
-(define
-  pl-mp-goal
-  (fn
-    (src env)
-    (pl-instantiate (nth (first (pl-parse (str "g :- " src "."))) 2) env)))
-
-(define pl-mp-db (pl-mk-db))
-(pl-db-load!
-  pl-mp-db
-  (pl-parse "member(X, [X|_]). member(X, [_|T]) :- member(X, T)."))
-
-;; -- \+/1 --
-
-(pl-mp-test!
-  "\\+(fail) succeeds"
-  (pl-solve-once! pl-mp-db (pl-mp-goal "\\+(fail)" {}) (pl-mk-trail))
-  true)
-
-(pl-mp-test!
-  "\\+(true) fails"
-  (pl-solve-once! pl-mp-db (pl-mp-goal "\\+(true)" {}) (pl-mk-trail))
-  false)
-
-(pl-mp-test!
-  "\\+(member(d, [a,b,c])) succeeds"
-  (pl-solve-once!
-    pl-mp-db
-    (pl-mp-goal "\\+(member(d, [a,b,c]))" {})
-    (pl-mk-trail))
-  true)
-
-(pl-mp-test!
-  "\\+(member(a, [a,b,c])) fails"
-  (pl-solve-once!
-    pl-mp-db
-    (pl-mp-goal "\\+(member(a, [a,b,c]))" {})
-    (pl-mk-trail))
-  false)
-
-(define pl-mp-env-neg {})
-(pl-solve-once!
-  pl-mp-db
-  (pl-mp-goal "\\+(X = 5)" pl-mp-env-neg)
-  (pl-mk-trail))
-(pl-mp-test!
-  "\\+(X=5) fails, X stays unbound (bindings undone)"
-  (nil? (pl-var-binding (dict-get pl-mp-env-neg "X")))
-  true)
-
-;; -- not/1 --
-
-(pl-mp-test!
-  "not(fail) succeeds"
-  (pl-solve-once! pl-mp-db (pl-mp-goal "not(fail)" {}) (pl-mk-trail))
-  true)
-
-(pl-mp-test!
-  "not(true) fails"
-  (pl-solve-once! pl-mp-db (pl-mp-goal "not(true)" {}) (pl-mk-trail))
-  false)
-
-;; -- once/1 --
-
-(pl-mp-test!
-  "once(member(X,[1,2,3])) succeeds once"
-  (pl-solve-count!
-    pl-mp-db
-    (pl-mp-goal "once(member(X,[1,2,3]))" {})
-    (pl-mk-trail))
-  1)
-
-(define pl-mp-env-once {})
-(pl-solve-once!
-  pl-mp-db
-  (pl-mp-goal "once(member(X,[1,2,3]))" pl-mp-env-once)
-  (pl-mk-trail))
-(pl-mp-test!
-  "once(member(X,[1,2,3])): X=1 (first solution)"
-  (pl-num-val (pl-walk-deep (dict-get pl-mp-env-once "X")))
-  1)
-
-(pl-mp-test!
-  "once(fail) fails"
-  (pl-solve-once!
-    pl-mp-db
-    (pl-mp-goal "once(fail)" {})
-    (pl-mk-trail))
-  false)
-
-;; -- ignore/1 --
-
-(pl-mp-test!
-  "ignore(true) succeeds"
-  (pl-solve-once!
-    pl-mp-db
-    (pl-mp-goal "ignore(true)" {})
-    (pl-mk-trail))
-  true)
-
-(pl-mp-test!
-  "ignore(fail) still succeeds"
-  (pl-solve-once!
-    pl-mp-db
-    (pl-mp-goal "ignore(fail)" {})
-    (pl-mk-trail))
-  true)
-
-;; -- ground/1 --
-
-(pl-mp-test!
-  "ground(foo(1, a)) succeeds"
-  (pl-solve-once!
-    pl-mp-db
-    (pl-mp-goal "ground(foo(1, a))" {})
-    (pl-mk-trail))
-  true)
-
-(pl-mp-test!
-  "ground(foo(X, a)) fails (X unbound)"
-  (pl-solve-once!
-    pl-mp-db
-    (pl-mp-goal "ground(foo(X, a))" {})
-    (pl-mk-trail))
-  false)
-
-(pl-mp-test!
-  "ground(42) succeeds"
-  (pl-solve-once!
-    pl-mp-db
-    (pl-mp-goal "ground(42)" {})
-    (pl-mk-trail))
-  true)
-
-;; -- sort/2 --
-
-(pl-mp-test!
-  "sort([b,a,c], [a,b,c])"
-  (pl-solve-once!
-    pl-mp-db
-    (pl-mp-goal "sort([b,a,c], [a,b,c])" {})
-    (pl-mk-trail))
-  true)
-
-(pl-mp-test!
-  "sort([b,a,a,c], [a,b,c]) (removes duplicates)"
-  (pl-solve-once!
-    pl-mp-db
-    (pl-mp-goal "sort([b,a,a,c], [a,b,c])" {})
-    (pl-mk-trail))
-  true)
-
-(pl-mp-test!
-  "sort([], [])"
-  (pl-solve-once!
-    pl-mp-db
-    (pl-mp-goal "sort([], [])" {})
-    (pl-mk-trail))
-  true)
-
-;; -- msort/2 --
-
-(pl-mp-test!
-  "msort([b,a,a,c], [a,a,b,c]) (keeps duplicates)"
-  (pl-solve-once!
-    pl-mp-db
-    (pl-mp-goal "msort([b,a,a,c], [a,a,b,c])" {})
-    (pl-mk-trail))
-  true)
-
-(pl-mp-test!
-  "msort([3,1,2,1], [1,1,2,3])"
-  (pl-solve-once!
-    pl-mp-db
-    (pl-mp-goal "msort([3,1,2,1], [1,1,2,3])" {})
-    (pl-mk-trail))
-  true)
-
-;; -- atom_number/2 --
-
-(define pl-mp-env-an1 {})
-(pl-solve-once!
-  pl-mp-db
-  (pl-mp-goal "atom_number('42', N)" pl-mp-env-an1)
-  (pl-mk-trail))
-(pl-mp-test!
-  "atom_number('42', N) -> N=42"
-  (pl-num-val (pl-walk-deep (dict-get pl-mp-env-an1 "N")))
-  42)
-
-(define pl-mp-env-an2 {})
-(pl-solve-once!
-  pl-mp-db
-  (pl-mp-goal "atom_number(A, 7)" pl-mp-env-an2)
-  (pl-mk-trail))
-(pl-mp-test!
-  "atom_number(A, 7) -> A='7'"
-  (pl-atom-name (pl-walk-deep (dict-get pl-mp-env-an2 "A")))
-  "7")
-
-(pl-mp-test!
-  "atom_number(foo, N) fails (not a number)"
-  (pl-solve-once!
-    pl-mp-db
-    (pl-mp-goal "atom_number(foo, N)" {})
-    (pl-mk-trail))
-  false)
-
-;; -- number_string/2 --
-
-(define pl-mp-env-ns1 {})
-(pl-solve-once!
-  pl-mp-db
-  (pl-mp-goal "number_string(42, S)" pl-mp-env-ns1)
-  (pl-mk-trail))
-(pl-mp-test!
-  "number_string(42, S) -> S='42'"
-  (pl-atom-name (pl-walk-deep (dict-get pl-mp-env-ns1 "S")))
-  "42")
-
-(define pl-mp-env-ns2 {})
-(pl-solve-once!
-  pl-mp-db
-  (pl-mp-goal "number_string(N, '3.14')" pl-mp-env-ns2)
-  (pl-mk-trail))
-(pl-mp-test!
-  "number_string(N, '3.14') -> N=3.14"
-  (pl-num-val (pl-walk-deep (dict-get pl-mp-env-ns2 "N")))
-  3.14)
-
-(define pl-meta-predicates-tests-run! (fn () {:failed pl-mp-test-fail :passed pl-mp-test-pass :total pl-mp-test-count :failures pl-mp-test-failures}))

lib/prolog/tests/operators.sx

@@ -1,193 +0,0 @@
-;; lib/prolog/tests/operators.sx — operator-table parsing + comparison built-ins.
-
-(define pl-op-test-count 0)
-(define pl-op-test-pass 0)
-(define pl-op-test-fail 0)
-(define pl-op-test-failures (list))
-
-(define
-  pl-op-test!
-  (fn
-    (name got expected)
-    (begin
-      (set! pl-op-test-count (+ pl-op-test-count 1))
-      (if
-        (= got expected)
-        (set! pl-op-test-pass (+ pl-op-test-pass 1))
-        (begin
-          (set! pl-op-test-fail (+ pl-op-test-fail 1))
-          (append!
-            pl-op-test-failures
-            (str name "\n    expected: " expected "\n    got:      " got)))))))
-
-(define pl-op-empty-db (pl-mk-db))
-
-(define
-  pl-op-body
-  (fn (src) (nth (first (pl-parse (str "g :- " src "."))) 2)))
-
-(define pl-op-goal (fn (src env) (pl-instantiate (pl-op-body src) env)))
-
-;; ── parsing tests ──
-
-(pl-op-test!
-  "infix +"
-  (pl-op-body "a + b")
-  (list "compound" "+" (list (list "atom" "a") (list "atom" "b"))))
-
-(pl-op-test!
-  "infix * tighter than +"
-  (pl-op-body "a + b * c")
-  (list
-    "compound"
-    "+"
-    (list
-      (list "atom" "a")
-      (list "compound" "*" (list (list "atom" "b") (list "atom" "c"))))))
-
-(pl-op-test!
-  "parens override precedence"
-  (pl-op-body "(a + b) * c")
-  (list
-    "compound"
-    "*"
-    (list
-      (list "compound" "+" (list (list "atom" "a") (list "atom" "b")))
-      (list "atom" "c"))))
-
-(pl-op-test!
-  "+ is yfx (left-assoc)"
-  (pl-op-body "a + b + c")
-  (list
-    "compound"
-    "+"
-    (list
-      (list "compound" "+" (list (list "atom" "a") (list "atom" "b")))
-      (list "atom" "c"))))
-
-(pl-op-test!
-  "; is xfy (right-assoc)"
-  (pl-op-body "a ; b ; c")
-  (list
-    "compound"
-    ";"
-    (list
-      (list "atom" "a")
-      (list "compound" ";" (list (list "atom" "b") (list "atom" "c"))))))
-
-(pl-op-test!
-  "= folds at 700"
-  (pl-op-body "X = 5")
-  (list "compound" "=" (list (list "var" "X") (list "num" 5))))
-
-(pl-op-test!
-  "is + nests via 700>500>400"
-  (pl-op-body "X is 2 + 3 * 4")
-  (list
-    "compound"
-    "is"
-    (list
-      (list "var" "X")
-      (list
-        "compound"
-        "+"
-        (list
-          (list "num" 2)
-          (list "compound" "*" (list (list "num" 3) (list "num" 4))))))))
-
-(pl-op-test!
-  "< parses at 700"
-  (pl-op-body "2 < 3")
-  (list "compound" "<" (list (list "num" 2) (list "num" 3))))
-
-(pl-op-test!
-  "mod parses as yfx 400"
-  (pl-op-body "10 mod 3")
-  (list "compound" "mod" (list (list "num" 10) (list "num" 3))))
-
-(pl-op-test!
-  "comma in body folds right-assoc"
-  (pl-op-body "a, b, c")
-  (list
-    "compound"
-    ","
-    (list
-      (list "atom" "a")
-      (list "compound" "," (list (list "atom" "b") (list "atom" "c"))))))
-
-;; ── solver tests via infix ──
-
-(pl-op-test!
-  "X is 2 + 3 binds X = 5"
-  (let
-    ((env {}) (trail (pl-mk-trail)))
-    (begin
-      (pl-solve-once! pl-op-empty-db (pl-op-goal "X is 2 + 3" env) trail)
-      (pl-num-val (pl-walk-deep (dict-get env "X")))))
-  5)
-
-(pl-op-test!
-  "infix conjunction parses + solves"
-  (pl-solve-once!
-    pl-op-empty-db
-    (pl-op-goal "X = 5, X = 5" {})
-    (pl-mk-trail))
-  true)
-
-(pl-op-test!
-  "infix mismatch fails"
-  (pl-solve-once!
-    pl-op-empty-db
-    (pl-op-goal "X = 5, X = 6" {})
-    (pl-mk-trail))
-  false)
-
-(pl-op-test!
-  "infix disjunction picks left"
-  (pl-solve-once!
-    pl-op-empty-db
-    (pl-op-goal "true ; fail" {})
-    (pl-mk-trail))
-  true)
-
-(pl-op-test!
-  "2 < 5 succeeds"
-  (pl-solve-once!
-    pl-op-empty-db
-    (pl-op-goal "2 < 5" {})
-    (pl-mk-trail))
-  true)
-
-(pl-op-test!
-  "5 < 2 fails"
-  (pl-solve-once!
-    pl-op-empty-db
-    (pl-op-goal "5 < 2" {})
-    (pl-mk-trail))
-  false)
-
-(pl-op-test!
-  "5 >= 5 succeeds"
-  (pl-solve-once!
-    pl-op-empty-db
-    (pl-op-goal "5 >= 5" {})
-    (pl-mk-trail))
-  true)
-
-(pl-op-test!
-  "3 =< 5 succeeds"
-  (pl-solve-once!
-    pl-op-empty-db
-    (pl-op-goal "3 =< 5" {})
-    (pl-mk-trail))
-  true)
-
-(pl-op-test!
-  "infix < with arithmetic both sides"
-  (pl-solve-once!
-    pl-op-empty-db
-    (pl-op-goal "1 + 2 < 2 * 3" {})
-    (pl-mk-trail))
-  true)
-
-(define pl-operators-tests-run! (fn () {:failed pl-op-test-fail :passed pl-op-test-pass :total pl-op-test-count :failures pl-op-test-failures}))

lib/prolog/tests/programs/append.pl

@@ -1,5 +0,0 @@
-%% append/3 — list concatenation, classic Prolog
-%% Two clauses: empty-prefix base case + recursive cons-prefix.
-%% Bidirectional — works in all modes: build, check, split.
-append([], L, L).
-append([H|T], L, [H|R]) :- append(T, L, R).

lib/prolog/tests/programs/append.sx

@@ -1,114 +0,0 @@
-;; lib/prolog/tests/programs/append.sx — append/3 test runner
-;;
-;; Mirrors the Prolog source in append.pl (embedded as a string here because
-;; the SX runtime has no file-read primitive yet).
-
-(define pl-ap-test-count 0)
-(define pl-ap-test-pass 0)
-(define pl-ap-test-fail 0)
-(define pl-ap-test-failures (list))
-
-(define
-  pl-ap-test!
-  (fn
-    (name got expected)
-    (begin
-      (set! pl-ap-test-count (+ pl-ap-test-count 1))
-      (if
-        (= got expected)
-        (set! pl-ap-test-pass (+ pl-ap-test-pass 1))
-        (begin
-          (set! pl-ap-test-fail (+ pl-ap-test-fail 1))
-          (append!
-            pl-ap-test-failures
-            (str name "\n    expected: " expected "\n    got:      " got)))))))
-
-(define
-  pl-ap-term-to-sx
-  (fn
-    (t)
-    (cond
-      ((pl-num? t) (pl-num-val t))
-      ((pl-atom? t) (pl-atom-name t))
-      (true (list :complex)))))
-
-(define
-  pl-ap-list-walked
-  (fn
-    (w)
-    (cond
-      ((and (pl-atom? w) (= (pl-atom-name w) "[]")) (list))
-      ((and (pl-compound? w) (= (pl-fun w) ".") (= (len (pl-args w)) 2))
-        (cons
-          (pl-ap-term-to-sx (first (pl-args w)))
-          (pl-ap-list-walked (nth (pl-args w) 1))))
-      (true (list :not-list)))))
-
-(define pl-ap-list-to-sx (fn (t) (pl-ap-list-walked (pl-walk-deep t))))
-
-(define
-  pl-ap-goal
-  (fn
-    (src env)
-    (pl-instantiate (nth (first (pl-parse (str "g :- " src "."))) 2) env)))
-
-(define
-  pl-ap-prog-src
-  "append([], L, L). append([H|T], L, [H|R]) :- append(T, L, R).")
-
-(define pl-ap-db (pl-mk-db))
-
-(pl-db-load! pl-ap-db (pl-parse pl-ap-prog-src))
-
-(define pl-ap-env-1 {})
-(define pl-ap-goal-1 (pl-ap-goal "append([], [a, b], X)" pl-ap-env-1))
-(pl-solve-once! pl-ap-db pl-ap-goal-1 (pl-mk-trail))
-
-(pl-ap-test!
-  "append([], [a, b], X) → X = [a, b]"
-  (pl-ap-list-to-sx (dict-get pl-ap-env-1 "X"))
-  (list "a" "b"))
-
-(define pl-ap-env-2 {})
-(define pl-ap-goal-2 (pl-ap-goal "append([1, 2], [3, 4], X)" pl-ap-env-2))
-(pl-solve-once! pl-ap-db pl-ap-goal-2 (pl-mk-trail))
-
-(pl-ap-test!
-  "append([1, 2], [3, 4], X) → X = [1, 2, 3, 4]"
-  (pl-ap-list-to-sx (dict-get pl-ap-env-2 "X"))
-  (list 1 2 3 4))
-
-(pl-ap-test!
-  "append([1], [2, 3], [1, 2, 3]) succeeds"
-  (pl-solve-once!
-    pl-ap-db
-    (pl-ap-goal "append([1], [2, 3], [1, 2, 3])" {})
-    (pl-mk-trail))
-  true)
-
-(pl-ap-test!
-  "append([1, 2], [3], [1, 2, 4]) fails"
-  (pl-solve-once!
-    pl-ap-db
-    (pl-ap-goal "append([1, 2], [3], [1, 2, 4])" {})
-    (pl-mk-trail))
-  false)
-
-(pl-ap-test!
-  "append(X, Y, [1, 2, 3]) backtracks 4 times"
-  (pl-solve-count!
-    pl-ap-db
-    (pl-ap-goal "append(X, Y, [1, 2, 3])" {})
-    (pl-mk-trail))
-  4)
-
-(define pl-ap-env-6 {})
-(define pl-ap-goal-6 (pl-ap-goal "append(X, [3], [1, 2, 3])" pl-ap-env-6))
-(pl-solve-once! pl-ap-db pl-ap-goal-6 (pl-mk-trail))
-
-(pl-ap-test!
-  "append(X, [3], [1, 2, 3]) deduces X = [1, 2]"
-  (pl-ap-list-to-sx (dict-get pl-ap-env-6 "X"))
-  (list 1 2))
-
-(define pl-append-tests-run! (fn () {:failed pl-ap-test-fail :passed pl-ap-test-pass :total pl-ap-test-count :failures pl-ap-test-failures}))

lib/prolog/tests/programs/family.pl

@@ -1,24 +0,0 @@
-%% family — facts + transitive ancestor + derived relations.
-%% Five-generation tree: tom -> bob -> {ann, pat} -> jim, plus tom's
-%% other child liz.
-
-parent(tom, bob).
-parent(tom, liz).
-parent(bob, ann).
-parent(bob, pat).
-parent(pat, jim).
-
-male(tom).
-male(bob).
-male(jim).
-male(pat).
-female(liz).
-female(ann).
-
-father(F, C) :- parent(F, C), male(F).
-mother(M, C) :- parent(M, C), female(M).
-
-ancestor(X, Y) :- parent(X, Y).
-ancestor(X, Y) :- parent(X, Z), ancestor(Z, Y).
-
-sibling(X, Y) :- parent(P, X), parent(P, Y), \=(X, Y).

lib/prolog/tests/programs/family.sx

@@ -1,116 +0,0 @@
-;; lib/prolog/tests/programs/family.sx — facts + ancestor + sibling relations.
-
-(define pl-fa-test-count 0)
-(define pl-fa-test-pass 0)
-(define pl-fa-test-fail 0)
-(define pl-fa-test-failures (list))
-
-(define
-  pl-fa-test!
-  (fn
-    (name got expected)
-    (begin
-      (set! pl-fa-test-count (+ pl-fa-test-count 1))
-      (if
-        (= got expected)
-        (set! pl-fa-test-pass (+ pl-fa-test-pass 1))
-        (begin
-          (set! pl-fa-test-fail (+ pl-fa-test-fail 1))
-          (append!
-            pl-fa-test-failures
-            (str name "\n    expected: " expected "\n    got:      " got)))))))
-
-(define
-  pl-fa-goal
-  (fn
-    (src env)
-    (pl-instantiate (nth (first (pl-parse (str "g :- " src "."))) 2) env)))
-
-(define
-  pl-fa-prog-src
-  "parent(tom, bob). parent(tom, liz). parent(bob, ann). parent(bob, pat). parent(pat, jim). male(tom). male(bob). male(jim). male(pat). female(liz). female(ann). father(F, C) :- parent(F, C), male(F). mother(M, C) :- parent(M, C), female(M). ancestor(X, Y) :- parent(X, Y). ancestor(X, Y) :- parent(X, Z), ancestor(Z, Y). sibling(X, Y) :- parent(P, X), parent(P, Y), \\=(X, Y).")
-
-(define pl-fa-db (pl-mk-db))
-(pl-db-load! pl-fa-db (pl-parse pl-fa-prog-src))
-
-(pl-fa-test!
-  "parent(tom, bob) is a fact"
-  (pl-solve-once!
-    pl-fa-db
-    (pl-fa-goal "parent(tom, bob)" {})
-    (pl-mk-trail))
-  true)
-
-(pl-fa-test!
-  "parent(tom, ann) — not a direct parent"
-  (pl-solve-once!
-    pl-fa-db
-    (pl-fa-goal "parent(tom, ann)" {})
-    (pl-mk-trail))
-  false)
-
-(pl-fa-test!
-  "5 parent/2 facts in total"
-  (pl-solve-count!
-    pl-fa-db
-    (pl-fa-goal "parent(X, Y)" {})
-    (pl-mk-trail))
-  5)
-
-(pl-fa-test!
-  "ancestor(tom, jim) — three-step transitive"
-  (pl-solve-once!
-    pl-fa-db
-    (pl-fa-goal "ancestor(tom, jim)" {})
-    (pl-mk-trail))
-  true)
-
-(pl-fa-test!
-  "tom has 5 ancestors-of: bob, liz, ann, pat, jim"
-  (pl-solve-count!
-    pl-fa-db
-    (pl-fa-goal "ancestor(tom, X)" {})
-    (pl-mk-trail))
-  5)
-
-(pl-fa-test!
-  "father(bob, ann) succeeds"
-  (pl-solve-once!
-    pl-fa-db
-    (pl-fa-goal "father(bob, ann)" {})
-    (pl-mk-trail))
-  true)
-
-(pl-fa-test!
-  "father(liz, ann) fails (liz is female)"
-  (pl-solve-once!
-    pl-fa-db
-    (pl-fa-goal "father(liz, ann)" {})
-    (pl-mk-trail))
-  false)
-
-(pl-fa-test!
-  "mother(liz, X) fails (liz has no children)"
-  (pl-solve-once!
-    pl-fa-db
-    (pl-fa-goal "mother(liz, X)" {})
-    (pl-mk-trail))
-  false)
-
-(pl-fa-test!
-  "sibling(ann, pat) succeeds"
-  (pl-solve-once!
-    pl-fa-db
-    (pl-fa-goal "sibling(ann, pat)" {})
-    (pl-mk-trail))
-  true)
-
-(pl-fa-test!
-  "sibling(ann, ann) fails by \\="
-  (pl-solve-once!
-    pl-fa-db
-    (pl-fa-goal "sibling(ann, ann)" {})
-    (pl-mk-trail))
-  false)
-
-(define pl-family-tests-run! (fn () {:failed pl-fa-test-fail :passed pl-fa-test-pass :total pl-fa-test-count :failures pl-fa-test-failures}))

lib/prolog/tests/programs/member.pl

@@ -1,4 +0,0 @@
-%% member/2 — list membership.
-%% Generates all solutions on backtracking when the element is unbound.
-member(X, [X|_]).
-member(X, [_|T]) :- member(X, T).

lib/prolog/tests/programs/member.sx

@@ -1,91 +0,0 @@
-;; lib/prolog/tests/programs/member.sx — member/2 generator.
-
-(define pl-mb-test-count 0)
-(define pl-mb-test-pass 0)
-(define pl-mb-test-fail 0)
-(define pl-mb-test-failures (list))
-
-(define
-  pl-mb-test!
-  (fn
-    (name got expected)
-    (begin
-      (set! pl-mb-test-count (+ pl-mb-test-count 1))
-      (if
-        (= got expected)
-        (set! pl-mb-test-pass (+ pl-mb-test-pass 1))
-        (begin
-          (set! pl-mb-test-fail (+ pl-mb-test-fail 1))
-          (append!
-            pl-mb-test-failures
-            (str name "\n    expected: " expected "\n    got:      " got)))))))
-
-(define
-  pl-mb-goal
-  (fn
-    (src env)
-    (pl-instantiate (nth (first (pl-parse (str "g :- " src "."))) 2) env)))
-
-(define pl-mb-prog-src "member(X, [X|_]). member(X, [_|T]) :- member(X, T).")
-
-(define pl-mb-db (pl-mk-db))
-(pl-db-load! pl-mb-db (pl-parse pl-mb-prog-src))
-
-(pl-mb-test!
-  "member(2, [1, 2, 3]) succeeds"
-  (pl-solve-once!
-    pl-mb-db
-    (pl-mb-goal "member(2, [1, 2, 3])" {})
-    (pl-mk-trail))
-  true)
-
-(pl-mb-test!
-  "member(4, [1, 2, 3]) fails"
-  (pl-solve-once!
-    pl-mb-db
-    (pl-mb-goal "member(4, [1, 2, 3])" {})
-    (pl-mk-trail))
-  false)
-
-(pl-mb-test!
-  "member(X, []) fails"
-  (pl-solve-once!
-    pl-mb-db
-    (pl-mb-goal "member(X, [])" {})
-    (pl-mk-trail))
-  false)
-
-(pl-mb-test!
-  "member(X, [a, b, c]) generates 3 solutions"
-  (pl-solve-count!
-    pl-mb-db
-    (pl-mb-goal "member(X, [a, b, c])" {})
-    (pl-mk-trail))
-  3)
-
-(define pl-mb-env-1 {})
-(define pl-mb-goal-1 (pl-mb-goal "member(X, [11, 22, 33])" pl-mb-env-1))
-(pl-solve-once! pl-mb-db pl-mb-goal-1 (pl-mk-trail))
-
-(pl-mb-test!
-  "member(X, [11, 22, 33]) first solution X = 11"
-  (pl-num-val (pl-walk-deep (dict-get pl-mb-env-1 "X")))
-  11)
-
-(pl-mb-test!
-  "member(2, [1, 2, 3, 2, 1]) matches twice on backtrack"
-  (pl-solve-count!
-    pl-mb-db
-    (pl-mb-goal "member(2, [1, 2, 3, 2, 1])" {})
-    (pl-mk-trail))
-  2)
-
-(pl-mb-test!
-  "member with unbound list cell unifies"
-  (pl-solve-once!
-    pl-mb-db
-    (pl-mb-goal "member(a, [X, b, c])" {})
-    (pl-mk-trail))
-  true)
-
-(define pl-member-tests-run! (fn () {:failed pl-mb-test-fail :passed pl-mb-test-pass :total pl-mb-test-count :failures pl-mb-test-failures}))

lib/prolog/tests/programs/nqueens.pl

@@ -1,27 +0,0 @@
-%% nqueens — permutation-and-test formulation.
-%% Caller passes the row list [1..N]; queens/2 finds N column placements
-%% s.t. no two queens attack on a diagonal. Same-column attacks are
-%% structurally impossible — Qs is a permutation, all distinct.
-%%
-%% No `>/2` `</2` `=</2` built-ins yet, so range/3 is omitted; tests pass
-%; the literal range list. Once the operator table lands and arithmetic
-%% comparison built-ins are in, range/3 can be added.
-queens(L, Qs) :- permute(L, Qs), safe(Qs).
-
-permute([], []).
-permute(L, [H|T]) :- select(H, L, R), permute(R, T).
-
-select(X, [X|T], T).
-select(X, [H|T], [H|R]) :- select(X, T, R).
-
-safe([]).
-safe([Q|Qs]) :- safe(Qs), no_attack(Q, Qs, 1).
-
-no_attack(_, [], _).
-no_attack(Q, [Q1|Qs], D) :-
-  is(D2, +(Q, D)),
-  \=(D2, Q1),
-  is(D3, -(Q, D)),
-  \=(D3, Q1),
-  is(D1, +(D, 1)),
-  no_attack(Q, Qs, D1).

lib/prolog/tests/programs/nqueens.sx

@@ -1,108 +0,0 @@
-;; lib/prolog/tests/programs/nqueens.sx — N-queens via permute + safe.
-
-(define pl-nq-test-count 0)
-(define pl-nq-test-pass 0)
-(define pl-nq-test-fail 0)
-(define pl-nq-test-failures (list))
-
-(define
-  pl-nq-test!
-  (fn
-    (name got expected)
-    (begin
-      (set! pl-nq-test-count (+ pl-nq-test-count 1))
-      (if
-        (= got expected)
-        (set! pl-nq-test-pass (+ pl-nq-test-pass 1))
-        (begin
-          (set! pl-nq-test-fail (+ pl-nq-test-fail 1))
-          (append!
-            pl-nq-test-failures
-            (str name "\n    expected: " expected "\n    got:      " got)))))))
-
-(define
-  pl-nq-term-to-sx
-  (fn
-    (t)
-    (cond
-      ((pl-num? t) (pl-num-val t))
-      ((pl-atom? t) (pl-atom-name t))
-      (true (list :complex)))))
-
-(define
-  pl-nq-list-walked
-  (fn
-    (w)
-    (cond
-      ((and (pl-atom? w) (= (pl-atom-name w) "[]")) (list))
-      ((and (pl-compound? w) (= (pl-fun w) ".") (= (len (pl-args w)) 2))
-        (cons
-          (pl-nq-term-to-sx (first (pl-args w)))
-          (pl-nq-list-walked (nth (pl-args w) 1))))
-      (true (list :not-list)))))
-
-(define pl-nq-list-to-sx (fn (t) (pl-nq-list-walked (pl-walk-deep t))))
-
-(define
-  pl-nq-goal
-  (fn
-    (src env)
-    (pl-instantiate (nth (first (pl-parse (str "g :- " src "."))) 2) env)))
-
-(define
-  pl-nq-prog-src
-  "queens(L, Qs) :- permute(L, Qs), safe(Qs). permute([], []). permute(L, [H|T]) :- select(H, L, R), permute(R, T). select(X, [X|T], T). select(X, [H|T], [H|R]) :- select(X, T, R). safe([]). safe([Q|Qs]) :- safe(Qs), no_attack(Q, Qs, 1). no_attack(_, [], _). no_attack(Q, [Q1|Qs], D) :- is(D2, +(Q, D)), \\=(D2, Q1), is(D3, -(Q, D)), \\=(D3, Q1), is(D1, +(D, 1)), no_attack(Q, Qs, D1).")
-
-(define pl-nq-db (pl-mk-db))
-(pl-db-load! pl-nq-db (pl-parse pl-nq-prog-src))
-
-(pl-nq-test!
-  "queens([1], Qs) → 1 solution"
-  (pl-solve-count!
-    pl-nq-db
-    (pl-nq-goal "queens([1], Qs)" {})
-    (pl-mk-trail))
-  1)
-
-(pl-nq-test!
-  "queens([1, 2], Qs) → 0 solutions"
-  (pl-solve-count!
-    pl-nq-db
-    (pl-nq-goal "queens([1, 2], Qs)" {})
-    (pl-mk-trail))
-  0)
-
-(pl-nq-test!
-  "queens([1, 2, 3], Qs) → 0 solutions"
-  (pl-solve-count!
-    pl-nq-db
-    (pl-nq-goal "queens([1, 2, 3], Qs)" {})
-    (pl-mk-trail))
-  0)
-
-(pl-nq-test!
-  "queens([1, 2, 3, 4], Qs) → 2 solutions"
-  (pl-solve-count!
-    pl-nq-db
-    (pl-nq-goal "queens([1, 2, 3, 4], Qs)" {})
-    (pl-mk-trail))
-  2)
-
-(pl-nq-test!
-  "queens([1, 2, 3, 4, 5], Qs) → 10 solutions"
-  (pl-solve-count!
-    pl-nq-db
-    (pl-nq-goal "queens([1, 2, 3, 4, 5], Qs)" {})
-    (pl-mk-trail))
-  10)
-
-(define pl-nq-env-1 {})
-(define pl-nq-goal-1 (pl-nq-goal "queens([1, 2, 3, 4], Qs)" pl-nq-env-1))
-(pl-solve-once! pl-nq-db pl-nq-goal-1 (pl-mk-trail))
-
-(pl-nq-test!
-  "queens([1..4], Qs) first solution = [2, 4, 1, 3]"
-  (pl-nq-list-to-sx (dict-get pl-nq-env-1 "Qs"))
-  (list 2 4 1 3))
-
-(define pl-nqueens-tests-run! (fn () {:failed pl-nq-test-fail :passed pl-nq-test-pass :total pl-nq-test-count :failures pl-nq-test-failures}))

lib/prolog/tests/programs/reverse.pl

@@ -1,7 +0,0 @@
-%% reverse/2 — naive reverse via append/3.
-%% Quadratic — accumulates the reversed prefix one append per cons.
-reverse([], []).
-reverse([H|T], R) :- reverse(T, RT), append(RT, [H], R).
-
-append([], L, L).
-append([H|T], L, [H|R]) :- append(T, L, R).

lib/prolog/tests/programs/reverse.sx

@@ -1,113 +0,0 @@
-;; lib/prolog/tests/programs/reverse.sx — naive reverse/2 via append/3.
-;;
-;; Mirrors reverse.pl (embedded as a string here).
-
-(define pl-rv-test-count 0)
-(define pl-rv-test-pass 0)
-(define pl-rv-test-fail 0)
-(define pl-rv-test-failures (list))
-
-(define
-  pl-rv-test!
-  (fn
-    (name got expected)
-    (begin
-      (set! pl-rv-test-count (+ pl-rv-test-count 1))
-      (if
-        (= got expected)
-        (set! pl-rv-test-pass (+ pl-rv-test-pass 1))
-        (begin
-          (set! pl-rv-test-fail (+ pl-rv-test-fail 1))
-          (append!
-            pl-rv-test-failures
-            (str name "\n    expected: " expected "\n    got:      " got)))))))
-
-(define
-  pl-rv-term-to-sx
-  (fn
-    (t)
-    (cond
-      ((pl-num? t) (pl-num-val t))
-      ((pl-atom? t) (pl-atom-name t))
-      (true (list :complex)))))
-
-(define
-  pl-rv-list-walked
-  (fn
-    (w)
-    (cond
-      ((and (pl-atom? w) (= (pl-atom-name w) "[]")) (list))
-      ((and (pl-compound? w) (= (pl-fun w) ".") (= (len (pl-args w)) 2))
-        (cons
-          (pl-rv-term-to-sx (first (pl-args w)))
-          (pl-rv-list-walked (nth (pl-args w) 1))))
-      (true (list :not-list)))))
-
-(define pl-rv-list-to-sx (fn (t) (pl-rv-list-walked (pl-walk-deep t))))
-
-(define
-  pl-rv-goal
-  (fn
-    (src env)
-    (pl-instantiate (nth (first (pl-parse (str "g :- " src "."))) 2) env)))
-
-(define
-  pl-rv-prog-src
-  "reverse([], []). reverse([H|T], R) :- reverse(T, RT), append(RT, [H], R). append([], L, L). append([H|T], L, [H|R]) :- append(T, L, R).")
-
-(define pl-rv-db (pl-mk-db))
-(pl-db-load! pl-rv-db (pl-parse pl-rv-prog-src))
-
-(define pl-rv-env-1 {})
-(define pl-rv-goal-1 (pl-rv-goal "reverse([], X)" pl-rv-env-1))
-(pl-solve-once! pl-rv-db pl-rv-goal-1 (pl-mk-trail))
-
-(pl-rv-test!
-  "reverse([], X) → X = []"
-  (pl-rv-list-to-sx (dict-get pl-rv-env-1 "X"))
-  (list))
-
-(define pl-rv-env-2 {})
-(define pl-rv-goal-2 (pl-rv-goal "reverse([1], X)" pl-rv-env-2))
-(pl-solve-once! pl-rv-db pl-rv-goal-2 (pl-mk-trail))
-
-(pl-rv-test!
-  "reverse([1], X) → X = [1]"
-  (pl-rv-list-to-sx (dict-get pl-rv-env-2 "X"))
-  (list 1))
-
-(define pl-rv-env-3 {})
-(define pl-rv-goal-3 (pl-rv-goal "reverse([1, 2, 3], X)" pl-rv-env-3))
-(pl-solve-once! pl-rv-db pl-rv-goal-3 (pl-mk-trail))
-
-(pl-rv-test!
-  "reverse([1, 2, 3], X) → X = [3, 2, 1]"
-  (pl-rv-list-to-sx (dict-get pl-rv-env-3 "X"))
-  (list 3 2 1))
-
-(define pl-rv-env-4 {})
-(define pl-rv-goal-4 (pl-rv-goal "reverse([a, b, c, d], X)" pl-rv-env-4))
-(pl-solve-once! pl-rv-db pl-rv-goal-4 (pl-mk-trail))
-
-(pl-rv-test!
-  "reverse([a, b, c, d], X) → X = [d, c, b, a]"
-  (pl-rv-list-to-sx (dict-get pl-rv-env-4 "X"))
-  (list "d" "c" "b" "a"))
-
-(pl-rv-test!
-  "reverse([1, 2, 3], [3, 2, 1]) succeeds"
-  (pl-solve-once!
-    pl-rv-db
-    (pl-rv-goal "reverse([1, 2, 3], [3, 2, 1])" {})
-    (pl-mk-trail))
-  true)
-
-(pl-rv-test!
-  "reverse([1, 2], [1, 2]) fails"
-  (pl-solve-once!
-    pl-rv-db
-    (pl-rv-goal "reverse([1, 2], [1, 2])" {})
-    (pl-mk-trail))
-  false)
-
-(define pl-reverse-tests-run! (fn () {:failed pl-rv-test-fail :passed pl-rv-test-pass :total pl-rv-test-count :failures pl-rv-test-failures}))

lib/prolog/tests/query_api.sx

@@ -1,127 +0,0 @@
-;; lib/prolog/tests/query_api.sx — tests for pl-load/pl-query-all/pl-query-one/pl-query
-
-(define pl-qa-test-count 0)
-(define pl-qa-test-pass 0)
-(define pl-qa-test-fail 0)
-(define pl-qa-test-failures (list))
-
-(define
-  pl-qa-test!
-  (fn
-    (name got expected)
-    (begin
-      (set! pl-qa-test-count (+ pl-qa-test-count 1))
-      (if
-        (= got expected)
-        (set! pl-qa-test-pass (+ pl-qa-test-pass 1))
-        (begin
-          (set! pl-qa-test-fail (+ pl-qa-test-fail 1))
-          (append!
-            pl-qa-test-failures
-            (str name "\n    expected: " expected "\n    got:      " got)))))))
-
-(define
-  pl-qa-src
-  "parent(tom, bob). parent(tom, liz). parent(bob, ann). ancestor(X, Y) :- parent(X, Y). ancestor(X, Y) :- parent(X, Z), ancestor(Z, Y).")
-
-(define pl-qa-db (pl-load pl-qa-src))
-
-;; ── pl-load ──
-
-(pl-qa-test!
-  "pl-load returns a usable DB (pl-query-all non-nil)"
-  (not (nil? pl-qa-db))
-  true)
-
-;; ── pl-query-all: basic fact lookup ──
-
-(pl-qa-test!
-  "query-all parent(tom, X): 2 solutions"
-  (len (pl-query-all pl-qa-db "parent(tom, X)"))
-  2)
-
-(pl-qa-test!
-  "query-all parent(tom, X): first solution X=bob"
-  (dict-get (first (pl-query-all pl-qa-db "parent(tom, X)")) "X")
-  "bob")
-
-(pl-qa-test!
-  "query-all parent(tom, X): second solution X=liz"
-  (dict-get (nth (pl-query-all pl-qa-db "parent(tom, X)") 1) "X")
-  "liz")
-
-;; ── pl-query-all: no solutions ──
-
-(pl-qa-test!
-  "query-all no solutions returns empty list"
-  (pl-query-all pl-qa-db "parent(liz, X)")
-  (list))
-
-;; ── pl-query-all: boolean query (no vars) ──
-
-(pl-qa-test!
-  "boolean success: 1 solution (empty dict)"
-  (len (pl-query-all pl-qa-db "parent(tom, bob)"))
-  1)
-
-(pl-qa-test!
-  "boolean success: solution has no bindings"
-  (empty? (keys (first (pl-query-all pl-qa-db "parent(tom, bob)"))))
-  true)
-
-(pl-qa-test!
-  "boolean fail: 0 solutions"
-  (len (pl-query-all pl-qa-db "parent(bob, tom)"))
-  0)
-
-;; ── pl-query-all: multi-var ──
-
-(pl-qa-test!
-  "query-all parent(X, Y): 3 solutions total"
-  (len (pl-query-all pl-qa-db "parent(X, Y)"))
-  3)
-
-;; ── pl-query-all: rule-based (ancestor/2) ──
-
-(pl-qa-test!
-  "query-all ancestor(tom, X): 3 descendants (bob, liz, ann)"
-  (len (pl-query-all pl-qa-db "ancestor(tom, X)"))
-  3)
-
-;; ── pl-query-all: built-in in query ──
-
-(pl-qa-test!
-  "query with is/2 built-in"
-  (dict-get (first (pl-query-all pl-qa-db "X is 2 + 3")) "X")
-  "5")
-
-;; ── pl-query-one ──
-
-(pl-qa-test!
-  "query-one returns first solution"
-  (dict-get (pl-query-one pl-qa-db "parent(tom, X)") "X")
-  "bob")
-
-(pl-qa-test!
-  "query-one returns nil for no solutions"
-  (pl-query-one pl-qa-db "parent(liz, X)")
-  nil)
-
-;; ── pl-query convenience ──
-
-(pl-qa-test!
-  "pl-query convenience: count solutions"
-  (len (pl-query "likes(alice, bob). likes(alice, carol)." "likes(alice, X)"))
-  2)
-
-(pl-qa-test!
-  "pl-query convenience: first solution"
-  (dict-get (first (pl-query "likes(alice, bob). likes(alice, carol)." "likes(alice, X)")) "X")
-  "bob")
-
-(pl-qa-test!
-  "pl-query with empty source (built-ins only)"
-  (dict-get (first (pl-query "" "X is 6 * 7")) "X")
-  "42")
-
-(define pl-query-api-tests-run! (fn () {:failed pl-qa-test-fail :passed pl-qa-test-pass :total pl-qa-test-count :failures pl-qa-test-failures}))

lib/prolog/tests/set_predicates.sx

@@ -1,195 +0,0 @@
-;; lib/prolog/tests/set_predicates.sx — foldl/4, list_to_set/2, intersection/3, subtract/3, union/3
-
-(define pl-sp-test-count 0)
-(define pl-sp-test-pass 0)
-(define pl-sp-test-fail 0)
-(define pl-sp-test-failures (list))
-
-(define
-  pl-sp-test!
-  (fn
-    (name got expected)
-    (begin
-      (set! pl-sp-test-count (+ pl-sp-test-count 1))
-      (if
-        (= got expected)
-        (set! pl-sp-test-pass (+ pl-sp-test-pass 1))
-        (begin
-          (set! pl-sp-test-fail (+ pl-sp-test-fail 1))
-          (append!
-            pl-sp-test-failures
-            (str name "\n    expected: " expected "\n    got:      " got)))))))
-
-(define
-  pl-sp-goal
-  (fn
-    (src env)
-    (pl-instantiate (nth (first (pl-parse (str "g :- " src "."))) 2) env)))
-
-;; DB with add/3 for foldl tests
-(define pl-sp-db (pl-mk-db))
-(pl-db-load! pl-sp-db (pl-parse "add(X, Acc, NAcc) :- NAcc is Acc + X."))
-
-;; ── foldl/4 ────────────────────────────────────────────────────────
-
-(define pl-sp-env-fl1 {:S (pl-mk-rt-var "S")})
-(pl-solve-once!
-  pl-sp-db
-  (pl-sp-goal "foldl(add, [1,2,3,4], 0, S)" pl-sp-env-fl1)
-  (pl-mk-trail))
-(pl-sp-test!
-  "foldl(add,[1,2,3,4],0,S) -> S=10"
-  (pl-num-val (pl-walk-deep (dict-get pl-sp-env-fl1 "S")))
-  10)
-
-(define pl-sp-env-fl2 {:S (pl-mk-rt-var "S")})
-(pl-solve-once!
-  pl-sp-db
-  (pl-sp-goal "foldl(add, [], 5, S)" pl-sp-env-fl2)
-  (pl-mk-trail))
-(pl-sp-test!
-  "foldl(add,[],5,S) -> S=5"
-  (pl-num-val (pl-walk-deep (dict-get pl-sp-env-fl2 "S")))
-  5)
-
-(define pl-sp-env-fl3 {:S (pl-mk-rt-var "S")})
-(pl-solve-once!
-  pl-sp-db
-  (pl-sp-goal "foldl(add, [1,2,3], 0, S)" pl-sp-env-fl3)
-  (pl-mk-trail))
-(pl-sp-test!
-  "foldl(add,[1,2,3],0,S) -> S=6"
-  (pl-num-val (pl-walk-deep (dict-get pl-sp-env-fl3 "S")))
-  6)
-
-;; ── list_to_set/2 ──────────────────────────────────────────────────
-
-(define pl-sp-env-lts1 {:R (pl-mk-rt-var "R")})
-(pl-solve-once!
-  pl-sp-db
-  (pl-sp-goal "list_to_set([1,2,3,2,1], R)" pl-sp-env-lts1)
-  (pl-mk-trail))
-(pl-sp-test!
-  "list_to_set([1,2,3,2,1],R) -> [1,2,3]"
-  (pl-format-term (pl-walk-deep (dict-get pl-sp-env-lts1 "R")))
-  ".(1, .(2, .(3, [])))")
-
-(define pl-sp-env-lts2 {:R (pl-mk-rt-var "R")})
-(pl-solve-once!
-  pl-sp-db
-  (pl-sp-goal "list_to_set([], R)" pl-sp-env-lts2)
-  (pl-mk-trail))
-(pl-sp-test!
-  "list_to_set([],R) -> []"
-  (pl-format-term (pl-walk-deep (dict-get pl-sp-env-lts2 "R")))
-  "[]")
-
-(define pl-sp-env-lts3 {:R (pl-mk-rt-var "R")})
-(pl-solve-once!
-  pl-sp-db
-  (pl-sp-goal "list_to_set([a,b,a,c], R)" pl-sp-env-lts3)
-  (pl-mk-trail))
-(pl-sp-test!
-  "list_to_set([a,b,a,c],R) -> [a,b,c]"
-  (pl-format-term (pl-walk-deep (dict-get pl-sp-env-lts3 "R")))
-  ".(a, .(b, .(c, [])))")
-
-;; ── intersection/3 ─────────────────────────────────────────────────
-
-(define pl-sp-env-int1 {:R (pl-mk-rt-var "R")})
-(pl-solve-once!
-  pl-sp-db
-  (pl-sp-goal "intersection([1,2,3,4], [2,4,6], R)" pl-sp-env-int1)
-  (pl-mk-trail))
-(pl-sp-test!
-  "intersection([1,2,3,4],[2,4,6],R) -> [2,4]"
-  (pl-format-term (pl-walk-deep (dict-get pl-sp-env-int1 "R")))
-  ".(2, .(4, []))")
-
-(define pl-sp-env-int2 {:R (pl-mk-rt-var "R")})
-(pl-solve-once!
-  pl-sp-db
-  (pl-sp-goal "intersection([1,2,3], [4,5,6], R)" pl-sp-env-int2)
-  (pl-mk-trail))
-(pl-sp-test!
-  "intersection([1,2,3],[4,5,6],R) -> []"
-  (pl-format-term (pl-walk-deep (dict-get pl-sp-env-int2 "R")))
-  "[]")
-
-(define pl-sp-env-int3 {:R (pl-mk-rt-var "R")})
-(pl-solve-once!
-  pl-sp-db
-  (pl-sp-goal "intersection([], [1,2,3], R)" pl-sp-env-int3)
-  (pl-mk-trail))
-(pl-sp-test!
-  "intersection([],[1,2,3],R) -> []"
-  (pl-format-term (pl-walk-deep (dict-get pl-sp-env-int3 "R")))
-  "[]")
-
-;; ── subtract/3 ─────────────────────────────────────────────────────
-
-(define pl-sp-env-sub1 {:R (pl-mk-rt-var "R")})
-(pl-solve-once!
-  pl-sp-db
-  (pl-sp-goal "subtract([1,2,3,4], [2,4], R)" pl-sp-env-sub1)
-  (pl-mk-trail))
-(pl-sp-test!
-  "subtract([1,2,3,4],[2,4],R) -> [1,3]"
-  (pl-format-term (pl-walk-deep (dict-get pl-sp-env-sub1 "R")))
-  ".(1, .(3, []))")
-
-(define pl-sp-env-sub2 {:R (pl-mk-rt-var "R")})
-(pl-solve-once!
-  pl-sp-db
-  (pl-sp-goal "subtract([1,2,3], [], R)" pl-sp-env-sub2)
-  (pl-mk-trail))
-(pl-sp-test!
-  "subtract([1,2,3],[],R) -> [1,2,3]"
-  (pl-format-term (pl-walk-deep (dict-get pl-sp-env-sub2 "R")))
-  ".(1, .(2, .(3, [])))")
-
-(define pl-sp-env-sub3 {:R (pl-mk-rt-var "R")})
-(pl-solve-once!
-  pl-sp-db
-  (pl-sp-goal "subtract([], [1,2], R)" pl-sp-env-sub3)
-  (pl-mk-trail))
-(pl-sp-test!
-  "subtract([],[1,2],R) -> []"
-  (pl-format-term (pl-walk-deep (dict-get pl-sp-env-sub3 "R")))
-  "[]")
-
-;; ── union/3 ────────────────────────────────────────────────────────
-
-(define pl-sp-env-uni1 {:R (pl-mk-rt-var "R")})
-(pl-solve-once!
-  pl-sp-db
-  (pl-sp-goal "union([1,2,3], [2,3,4], R)" pl-sp-env-uni1)
-  (pl-mk-trail))
-(pl-sp-test!
-  "union([1,2,3],[2,3,4],R) -> [1,2,3,4]"
-  (pl-format-term (pl-walk-deep (dict-get pl-sp-env-uni1 "R")))
-  ".(1, .(2, .(3, .(4, []))))")
-
-(define pl-sp-env-uni2 {:R (pl-mk-rt-var "R")})
-(pl-solve-once!
-  pl-sp-db
-  (pl-sp-goal "union([], [1,2], R)" pl-sp-env-uni2)
-  (pl-mk-trail))
-(pl-sp-test!
-  "union([],[1,2],R) -> [1,2]"
-  (pl-format-term (pl-walk-deep (dict-get pl-sp-env-uni2 "R")))
-  ".(1, .(2, []))")
-
-(define pl-sp-env-uni3 {:R (pl-mk-rt-var "R")})
-(pl-solve-once!
-  pl-sp-db
-  (pl-sp-goal "union([1,2], [], R)" pl-sp-env-uni3)
-  (pl-mk-trail))
-(pl-sp-test!
-  "union([1,2],[],R) -> [1,2]"
-  (pl-format-term (pl-walk-deep (dict-get pl-sp-env-uni3 "R")))
-  ".(1, .(2, []))")
-
-;; ── Runner ─────────────────────────────────────────────────────────
-
-(define pl-set-predicates-tests-run! (fn () {:failed pl-sp-test-fail :passed pl-sp-test-pass :total pl-sp-test-count :failures pl-sp-test-failures}))

lib/prolog/tests/solve.sx

@@ -1,618 +0,0 @@
-;; lib/prolog/tests/solve.sx — DFS solver unit tests
-
-(define pl-s-test-count 0)
-(define pl-s-test-pass 0)
-(define pl-s-test-fail 0)
-(define pl-s-test-failures (list))
-
-(define
-  pl-s-test!
-  (fn
-    (name got expected)
-    (begin
-      (set! pl-s-test-count (+ pl-s-test-count 1))
-      (if
-        (= got expected)
-        (set! pl-s-test-pass (+ pl-s-test-pass 1))
-        (begin
-          (set! pl-s-test-fail (+ pl-s-test-fail 1))
-          (append!
-            pl-s-test-failures
-            (str name "\n    expected: " expected "\n    got:      " got)))))))
-
-(define
-  pl-s-goal
-  (fn
-    (src env)
-    (pl-instantiate (nth (first (pl-parse (str "g :- " src "."))) 2) env)))
-
-(define pl-s-empty-db (pl-mk-db))
-
-(pl-s-test!
-  "true succeeds"
-  (pl-solve-once! pl-s-empty-db (pl-s-goal "true" {}) (pl-mk-trail))
-  true)
-
-(pl-s-test!
-  "fail fails"
-  (pl-solve-once! pl-s-empty-db (pl-s-goal "fail" {}) (pl-mk-trail))
-  false)
-
-(pl-s-test!
-  "= identical atoms"
-  (pl-solve-once!
-    pl-s-empty-db
-    (pl-s-goal "=(a, a)" {})
-    (pl-mk-trail))
-  true)
-
-(pl-s-test!
-  "= different atoms"
-  (pl-solve-once!
-    pl-s-empty-db
-    (pl-s-goal "=(a, b)" {})
-    (pl-mk-trail))
-  false)
-
-(pl-s-test!
-  "= var to atom"
-  (pl-solve-once!
-    pl-s-empty-db
-    (pl-s-goal "=(X, foo)" {})
-    (pl-mk-trail))
-  true)
-
-(define pl-s-env-bind {})
-(define pl-s-trail-bind (pl-mk-trail))
-(define pl-s-goal-bind (pl-s-goal "=(X, foo)" pl-s-env-bind))
-(pl-solve-once! pl-s-empty-db pl-s-goal-bind pl-s-trail-bind)
-
-(pl-s-test!
-  "X bound to foo after =(X, foo)"
-  (pl-atom-name (pl-walk-deep (dict-get pl-s-env-bind "X")))
-  "foo")
-
-(pl-s-test!
-  "true , true succeeds"
-  (pl-solve-once!
-    pl-s-empty-db
-    (pl-s-goal "true, true" {})
-    (pl-mk-trail))
-  true)
-
-(pl-s-test!
-  "true , fail fails"
-  (pl-solve-once!
-    pl-s-empty-db
-    (pl-s-goal "true, fail" {})
-    (pl-mk-trail))
-  false)
-
-(pl-s-test!
-  "consistent X bindings succeed"
-  (pl-solve-once!
-    pl-s-empty-db
-    (pl-s-goal "=(X, a), =(X, a)" {})
-    (pl-mk-trail))
-  true)
-
-(pl-s-test!
-  "conflicting X bindings fail"
-  (pl-solve-once!
-    pl-s-empty-db
-    (pl-s-goal "=(X, a), =(X, b)" {})
-    (pl-mk-trail))
-  false)
-
-(define pl-s-db1 (pl-mk-db))
-(pl-db-load!
-  pl-s-db1
-  (pl-parse "parent(tom, bob). parent(bob, liz). parent(bob, ann)."))
-
-(pl-s-test!
-  "fact lookup hit"
-  (pl-solve-once!
-    pl-s-db1
-    (pl-s-goal "parent(tom, bob)" {})
-    (pl-mk-trail))
-  true)
-
-(pl-s-test!
-  "fact lookup miss"
-  (pl-solve-once!
-    pl-s-db1
-    (pl-s-goal "parent(tom, liz)" {})
-    (pl-mk-trail))
-  false)
-
-(pl-s-test!
-  "all parent solutions"
-  (pl-solve-count!
-    pl-s-db1
-    (pl-s-goal "parent(X, Y)" {})
-    (pl-mk-trail))
-  3)
-
-(pl-s-test!
-  "fixed first arg solutions"
-  (pl-solve-count!
-    pl-s-db1
-    (pl-s-goal "parent(bob, Y)" {})
-    (pl-mk-trail))
-  2)
-
-(define pl-s-db2 (pl-mk-db))
-(pl-db-load!
-  pl-s-db2
-  (pl-parse
-    "parent(tom, bob). parent(bob, ann). ancestor(X, Y) :- parent(X, Y). ancestor(X, Z) :- parent(X, Y), ancestor(Y, Z)."))
-
-(pl-s-test!
-  "rule direct ancestor"
-  (pl-solve-once!
-    pl-s-db2
-    (pl-s-goal "ancestor(tom, bob)" {})
-    (pl-mk-trail))
-  true)
-
-(pl-s-test!
-  "rule transitive ancestor"
-  (pl-solve-once!
-    pl-s-db2
-    (pl-s-goal "ancestor(tom, ann)" {})
-    (pl-mk-trail))
-  true)
-
-(pl-s-test!
-  "rule no path"
-  (pl-solve-once!
-    pl-s-db2
-    (pl-s-goal "ancestor(ann, tom)" {})
-    (pl-mk-trail))
-  false)
-
-(define pl-s-env-undo {})
-(define pl-s-trail-undo (pl-mk-trail))
-(define pl-s-goal-undo (pl-s-goal "=(X, a), fail" pl-s-env-undo))
-(pl-solve-once! pl-s-empty-db pl-s-goal-undo pl-s-trail-undo)
-
-(pl-s-test!
-  "trail undone after failure leaves X unbound"
-  (pl-var-bound? (dict-get pl-s-env-undo "X"))
-  false)
-
-(define pl-s-db-cut1 (pl-mk-db))
-
-(pl-db-load! pl-s-db-cut1 (pl-parse "g :- !. g :- true."))
-
-(pl-s-test!
-  "bare cut succeeds"
-  (pl-solve-once! pl-s-db-cut1 (pl-s-goal "g" {}) (pl-mk-trail))
-  true)
-
-(pl-s-test!
-  "cut commits to first matching clause"
-  (pl-solve-count! pl-s-db-cut1 (pl-s-goal "g" {}) (pl-mk-trail))
-  1)
-
-(define pl-s-db-cut2 (pl-mk-db))
-
-(pl-db-load! pl-s-db-cut2 (pl-parse "a(1). a(2). g(X) :- a(X), !."))
-
-(pl-s-test!
-  "cut commits to first a solution"
-  (pl-solve-count! pl-s-db-cut2 (pl-s-goal "g(X)" {}) (pl-mk-trail))
-  1)
-
-(define pl-s-db-cut3 (pl-mk-db))
-
-(pl-db-load!
-  pl-s-db-cut3
-  (pl-parse "a(1). a(2). g(X) :- a(X), !, fail. g(99)."))
-
-(pl-s-test!
-  "cut then fail blocks alt clauses"
-  (pl-solve-count! pl-s-db-cut3 (pl-s-goal "g(X)" {}) (pl-mk-trail))
-  0)
-
-(define pl-s-db-cut4 (pl-mk-db))
-
-(pl-db-load!
-  pl-s-db-cut4
-  (pl-parse "a(1). b(10). b(20). g(X, Y) :- a(X), !, b(Y)."))
-
-(pl-s-test!
-  "post-cut goal backtracks freely"
-  (pl-solve-count!
-    pl-s-db-cut4
-    (pl-s-goal "g(X, Y)" {})
-    (pl-mk-trail))
-  2)
-
-(define pl-s-db-cut5 (pl-mk-db))
-
-(pl-db-load!
-  pl-s-db-cut5
-  (pl-parse "r(1). r(2). q :- r(X), !. p :- q. p :- true."))
-
-(pl-s-test!
-  "inner cut does not commit outer predicate"
-  (pl-solve-count! pl-s-db-cut5 (pl-s-goal "p" {}) (pl-mk-trail))
-  2)
-
-(pl-s-test!
-  "\\= different atoms succeeds"
-  (pl-solve-once!
-    pl-s-empty-db
-    (pl-s-goal "\\=(a, b)" {})
-    (pl-mk-trail))
-  true)
-
-(pl-s-test!
-  "\\= same atoms fails"
-  (pl-solve-once!
-    pl-s-empty-db
-    (pl-s-goal "\\=(a, a)" {})
-    (pl-mk-trail))
-  false)
-
-(pl-s-test!
-  "\\= var-vs-atom would unify so fails"
-  (pl-solve-once!
-    pl-s-empty-db
-    (pl-s-goal "\\=(X, a)" {})
-    (pl-mk-trail))
-  false)
-
-(define pl-s-env-ne {})
-
-(define pl-s-trail-ne (pl-mk-trail))
-
-(define pl-s-goal-ne (pl-s-goal "\\=(X, a)" pl-s-env-ne))
-
-(pl-solve-once! pl-s-empty-db pl-s-goal-ne pl-s-trail-ne)
-
-(pl-s-test!
-  "\\= leaves no bindings"
-  (pl-var-bound? (dict-get pl-s-env-ne "X"))
-  false)
-
-(pl-s-test!
-  "; left succeeds"
-  (pl-solve-once!
-    pl-s-empty-db
-    (pl-s-goal ";(true, fail)" {})
-    (pl-mk-trail))
-  true)
-
-(pl-s-test!
-  "; right succeeds when left fails"
-  (pl-solve-once!
-    pl-s-empty-db
-    (pl-s-goal ";(fail, true)" {})
-    (pl-mk-trail))
-  true)
-
-(pl-s-test!
-  "; both fail"
-  (pl-solve-once!
-    pl-s-empty-db
-    (pl-s-goal ";(fail, fail)" {})
-    (pl-mk-trail))
-  false)
-
-(pl-s-test!
-  "; both branches counted"
-  (pl-solve-count!
-    pl-s-empty-db
-    (pl-s-goal ";(true, true)" {})
-    (pl-mk-trail))
-  2)
-
-(define pl-s-db-call (pl-mk-db))
-
-(pl-db-load! pl-s-db-call (pl-parse "p(1). p(2)."))
-
-(pl-s-test!
-  "call(true) succeeds"
-  (pl-solve-once!
-    pl-s-db-call
-    (pl-s-goal "call(true)" {})
-    (pl-mk-trail))
-  true)
-
-(pl-s-test!
-  "call(p(X)) yields all solutions"
-  (pl-solve-count!
-    pl-s-db-call
-    (pl-s-goal "call(p(X))" {})
-    (pl-mk-trail))
-  2)
-
-(pl-s-test!
-  "call of bound goal var resolves"
-  (pl-solve-once!
-    pl-s-db-call
-    (pl-s-goal "=(G, true), call(G)" {})
-    (pl-mk-trail))
-  true)
-
-(define pl-s-db-ite (pl-mk-db))
-
-(pl-db-load! pl-s-db-ite (pl-parse "p(1). p(2). q(yes). q(no)."))
-
-(pl-s-test!
-  "if-then-else: cond true → then runs"
-  (pl-solve-once!
-    pl-s-db-ite
-    (pl-s-goal ";(->(true, =(X, ok)), =(X, fallback))" {})
-    (pl-mk-trail))
-  true)
-
-(define pl-s-env-ite1 {})
-
-(pl-solve-once!
-  pl-s-db-ite
-  (pl-s-goal ";(->(true, =(X, ok)), =(X, fallback))" pl-s-env-ite1)
-  (pl-mk-trail))
-
-(pl-s-test!
-  "if-then-else: cond true binds via then"
-  (pl-atom-name (pl-walk-deep (dict-get pl-s-env-ite1 "X")))
-  "ok")
-
-(pl-s-test!
-  "if-then-else: cond false → else"
-  (pl-solve-once!
-    pl-s-db-ite
-    (pl-s-goal ";(->(fail, =(X, ok)), =(X, fallback))" {})
-    (pl-mk-trail))
-  true)
-
-(define pl-s-env-ite2 {})
-
-(pl-solve-once!
-  pl-s-db-ite
-  (pl-s-goal ";(->(fail, =(X, ok)), =(X, fallback))" pl-s-env-ite2)
-  (pl-mk-trail))
-
-(pl-s-test!
-  "if-then-else: cond false binds via else"
-  (pl-atom-name (pl-walk-deep (dict-get pl-s-env-ite2 "X")))
-  "fallback")
-
-(pl-s-test!
-  "if-then-else: cond commits to first solution (count = 1)"
-  (pl-solve-count!
-    pl-s-db-ite
-    (pl-s-goal ";(->(p(X), =(Y, found)), =(Y, none))" {})
-    (pl-mk-trail))
-  1)
-
-(pl-s-test!
-  "if-then-else: then can backtrack"
-  (pl-solve-count!
-    pl-s-db-ite
-    (pl-s-goal ";(->(true, p(X)), =(X, none))" {})
-    (pl-mk-trail))
-  2)
-
-(pl-s-test!
-  "if-then-else: else can backtrack"
-  (pl-solve-count!
-    pl-s-db-ite
-    (pl-s-goal ";(->(fail, =(X, ignored)), p(X))" {})
-    (pl-mk-trail))
-  2)
-
-(pl-s-test!
-  "standalone -> with true cond succeeds"
-  (pl-solve-once!
-    pl-s-db-ite
-    (pl-s-goal "->(true, =(X, hi))" {})
-    (pl-mk-trail))
-  true)
-
-(pl-s-test!
-  "standalone -> with false cond fails"
-  (pl-solve-once!
-    pl-s-db-ite
-    (pl-s-goal "->(fail, =(X, hi))" {})
-    (pl-mk-trail))
-  false)
-
-(pl-s-test!
-  "write(hello)"
-  (begin
-    (pl-output-clear!)
-    (pl-solve-once!
-      pl-s-empty-db
-      (pl-s-goal "write(hello)" {})
-      (pl-mk-trail))
-    pl-output-buffer)
-  "hello")
-
-(pl-s-test!
-  "nl outputs newline"
-  (begin
-    (pl-output-clear!)
-    (pl-solve-once! pl-s-empty-db (pl-s-goal "nl" {}) (pl-mk-trail))
-    pl-output-buffer)
-  "\n")
-
-(pl-s-test!
-  "write(42) outputs digits"
-  (begin
-    (pl-output-clear!)
-    (pl-solve-once!
-      pl-s-empty-db
-      (pl-s-goal "write(42)" {})
-      (pl-mk-trail))
-    pl-output-buffer)
-  "42")
-
-(pl-s-test!
-  "write(foo(a, b)) formats compound"
-  (begin
-    (pl-output-clear!)
-    (pl-solve-once!
-      pl-s-empty-db
-      (pl-s-goal "write(foo(a, b))" {})
-      (pl-mk-trail))
-    pl-output-buffer)
-  "foo(a, b)")
-
-(pl-s-test!
-  "write conjunction"
-  (begin
-    (pl-output-clear!)
-    (pl-solve-once!
-      pl-s-empty-db
-      (pl-s-goal "write(a), write(b)" {})
-      (pl-mk-trail))
-    pl-output-buffer)
-  "ab")
-
-(pl-s-test!
-  "write of bound var walks binding"
-  (begin
-    (pl-output-clear!)
-    (pl-solve-once!
-      pl-s-empty-db
-      (pl-s-goal "=(X, hello), write(X)" {})
-      (pl-mk-trail))
-    pl-output-buffer)
-  "hello")
-
-(pl-s-test!
-  "write then nl"
-  (begin
-    (pl-output-clear!)
-    (pl-solve-once!
-      pl-s-empty-db
-      (pl-s-goal "write(hi), nl" {})
-      (pl-mk-trail))
-    pl-output-buffer)
-  "hi\n")
-
-(define pl-s-env-arith1 {})
-
-(pl-solve-once!
-  pl-s-empty-db
-  (pl-s-goal "is(X, 42)" pl-s-env-arith1)
-  (pl-mk-trail))
-
-(pl-s-test!
-  "is(X, 42) binds X to 42"
-  (pl-num-val (pl-walk-deep (dict-get pl-s-env-arith1 "X")))
-  42)
-
-(define pl-s-env-arith2 {})
-
-(pl-solve-once!
-  pl-s-empty-db
-  (pl-s-goal "is(X, +(2, 3))" pl-s-env-arith2)
-  (pl-mk-trail))
-
-(pl-s-test!
-  "is(X, +(2, 3)) binds X to 5"
-  (pl-num-val (pl-walk-deep (dict-get pl-s-env-arith2 "X")))
-  5)
-
-(define pl-s-env-arith3 {})
-
-(pl-solve-once!
-  pl-s-empty-db
-  (pl-s-goal "is(X, *(2, 3))" pl-s-env-arith3)
-  (pl-mk-trail))
-
-(pl-s-test!
-  "is(X, *(2, 3)) binds X to 6"
-  (pl-num-val (pl-walk-deep (dict-get pl-s-env-arith3 "X")))
-  6)
-
-(define pl-s-env-arith4 {})
-
-(pl-solve-once!
-  pl-s-empty-db
-  (pl-s-goal "is(X, -(10, 3))" pl-s-env-arith4)
-  (pl-mk-trail))
-
-(pl-s-test!
-  "is(X, -(10, 3)) binds X to 7"
-  (pl-num-val (pl-walk-deep (dict-get pl-s-env-arith4 "X")))
-  7)
-
-(define pl-s-env-arith5 {})
-
-(pl-solve-once!
-  pl-s-empty-db
-  (pl-s-goal "is(X, /(10, 2))" pl-s-env-arith5)
-  (pl-mk-trail))
-
-(pl-s-test!
-  "is(X, /(10, 2)) binds X to 5"
-  (pl-num-val (pl-walk-deep (dict-get pl-s-env-arith5 "X")))
-  5)
-
-(define pl-s-env-arith6 {})
-
-(pl-solve-once!
-  pl-s-empty-db
-  (pl-s-goal "is(X, mod(10, 3))" pl-s-env-arith6)
-  (pl-mk-trail))
-
-(pl-s-test!
-  "is(X, mod(10, 3)) binds X to 1"
-  (pl-num-val (pl-walk-deep (dict-get pl-s-env-arith6 "X")))
-  1)
-
-(define pl-s-env-arith7 {})
-
-(pl-solve-once!
-  pl-s-empty-db
-  (pl-s-goal "is(X, abs(-(0, 5)))" pl-s-env-arith7)
-  (pl-mk-trail))
-
-(pl-s-test!
-  "is(X, abs(-(0, 5))) binds X to 5"
-  (pl-num-val (pl-walk-deep (dict-get pl-s-env-arith7 "X")))
-  5)
-
-(define pl-s-env-arith8 {})
-
-(pl-solve-once!
-  pl-s-empty-db
-  (pl-s-goal "is(X, +(2, *(3, 4)))" pl-s-env-arith8)
-  (pl-mk-trail))
-
-(pl-s-test!
-  "is(X, +(2, *(3, 4))) binds X to 14 (nested)"
-  (pl-num-val (pl-walk-deep (dict-get pl-s-env-arith8 "X")))
-  14)
-
-(pl-s-test!
-  "is(5, +(2, 3)) succeeds (LHS num matches)"
-  (pl-solve-once!
-    pl-s-empty-db
-    (pl-s-goal "is(5, +(2, 3))" {})
-    (pl-mk-trail))
-  true)
-
-(pl-s-test!
-  "is(6, +(2, 3)) fails (LHS num mismatch)"
-  (pl-solve-once!
-    pl-s-empty-db
-    (pl-s-goal "is(6, +(2, 3))" {})
-    (pl-mk-trail))
-  false)
-
-(pl-s-test!
-  "is propagates bound vars on RHS"
-  (pl-solve-once!
-    pl-s-empty-db
-    (pl-s-goal "=(Y, 4), is(X, +(Y, 1)), =(X, 5)" {})
-    (pl-mk-trail))
-  true)
-
-(define pl-solve-tests-run! (fn () {:failed pl-s-test-fail :passed pl-s-test-pass :total pl-s-test-count :failures pl-s-test-failures}))

lib/prolog/tests/string_agg.sx

@@ -1,273 +0,0 @@
-;; lib/prolog/tests/string_agg.sx -- sub_atom/5 + aggregate_all/3
-
-(define pl-sa-test-count 0)
-(define pl-sa-test-pass 0)
-(define pl-sa-test-fail 0)
-(define pl-sa-test-failures (list))
-
-(define
-  pl-sa-test!
-  (fn
-    (name got expected)
-    (begin
-      (set! pl-sa-test-count (+ pl-sa-test-count 1))
-      (if
-        (= got expected)
-        (set! pl-sa-test-pass (+ pl-sa-test-pass 1))
-        (begin
-          (set! pl-sa-test-fail (+ pl-sa-test-fail 1))
-          (append!
-            pl-sa-test-failures
-            (str name "\n    expected: " expected "\n    got:      " got)))))))
-
-(define
-  pl-sa-goal
-  (fn
-    (src env)
-    (pl-instantiate (nth (first (pl-parse (str "g :- " src "."))) 2) env)))
-
-(define pl-sa-db (pl-mk-db))
-
-(define
-  pl-sa-num-val
-  (fn (env key) (pl-num-val (pl-walk-deep (dict-get env key)))))
-
-(define
-  pl-sa-list-to-atoms
-  (fn
-    (t)
-    (let
-      ((w (pl-walk-deep t)))
-      (cond
-        ((and (pl-atom? w) (= (pl-atom-name w) "[]")) (list))
-        ((and (pl-compound? w) (= (pl-fun w) ".") (= (len (pl-args w)) 2))
-          (cons
-            (pl-atom-name (first (pl-args w)))
-            (pl-sa-list-to-atoms (nth (pl-args w) 1))))
-        (true (list))))))
-
-(define pl-sa-prog-src "member(X, [X|_]). member(X, [_|T]) :- member(X, T).")
-(pl-db-load! pl-sa-db (pl-parse pl-sa-prog-src))
-
-;; -- sub_atom/5 --
-
-(pl-sa-test!
-  "sub_atom ground: sub_atom(abcde,0,3,2,abc)"
-  (pl-solve-once!
-    pl-sa-db
-    (pl-sa-goal "sub_atom(abcde, 0, 3, 2, abc)" {})
-    (pl-mk-trail))
-  true)
-
-(pl-sa-test!
-  "sub_atom ground: sub_atom(abcde,2,2,1,cd)"
-  (pl-solve-once!
-    pl-sa-db
-    (pl-sa-goal "sub_atom(abcde, 2, 2, 1, cd)" {})
-    (pl-mk-trail))
-  true)
-
-(pl-sa-test!
-  "sub_atom ground mismatch fails"
-  (pl-solve-once!
-    pl-sa-db
-    (pl-sa-goal "sub_atom(abcde, 0, 2, 3, cd)" {})
-    (pl-mk-trail))
-  false)
-
-(pl-sa-test!
-  "sub_atom empty sub at start"
-  (pl-solve-once!
-    pl-sa-db
-    (pl-sa-goal "sub_atom(abcde, 0, 0, 5, '')" {})
-    (pl-mk-trail))
-  true)
-
-(pl-sa-test!
-  "sub_atom whole string"
-  (pl-solve-once!
-    pl-sa-db
-    (pl-sa-goal "sub_atom(hello, 0, 5, 0, hello)" {})
-    (pl-mk-trail))
-  true)
-
-(define pl-sa-env-b1 {})
-(pl-solve-once!
-  pl-sa-db
-  (pl-sa-goal "sub_atom(abcde, B, 2, A, cd)" pl-sa-env-b1)
-  (pl-mk-trail))
-(pl-sa-test!
-  "sub_atom bound SubAtom gives B=2"
-  (pl-sa-num-val pl-sa-env-b1 "B")
-  2)
-(pl-sa-test!
-  "sub_atom bound SubAtom gives A=1"
-  (pl-sa-num-val pl-sa-env-b1 "A")
-  1)
-
-(define pl-sa-env-b2 {})
-(pl-solve-once!
-  pl-sa-db
-  (pl-sa-goal "sub_atom(hello, B, L, A, ello)" pl-sa-env-b2)
-  (pl-mk-trail))
-(pl-sa-test! "sub_atom ello: B=1" (pl-sa-num-val pl-sa-env-b2 "B") 1)
-(pl-sa-test! "sub_atom ello: L=4" (pl-sa-num-val pl-sa-env-b2 "L") 4)
-(pl-sa-test! "sub_atom ello: A=0" (pl-sa-num-val pl-sa-env-b2 "A") 0)
-
-(pl-sa-test!
-  "sub_atom ab: 6 total solutions"
-  (let
-    ((env {}))
-    (pl-solve-once!
-      pl-sa-db
-      (pl-sa-goal "aggregate_all(count, sub_atom(ab, _, _, _, _), N)" env)
-      (pl-mk-trail))
-    (pl-sa-num-val env "N"))
-  6)
-
-(pl-sa-test!
-  "sub_atom a: 3 total solutions"
-  (let
-    ((env {}))
-    (pl-solve-once!
-      pl-sa-db
-      (pl-sa-goal "aggregate_all(count, sub_atom(a, _, _, _, _), N)" env)
-      (pl-mk-trail))
-    (pl-sa-num-val env "N"))
-  3)
-
-;; -- aggregate_all/3 --
-
-(pl-sa-test!
-  "aggregate_all count member [a,b,c] = 3"
-  (let
-    ((env {}))
-    (pl-solve-once!
-      pl-sa-db
-      (pl-sa-goal "aggregate_all(count, member(_, [a,b,c]), N)" env)
-      (pl-mk-trail))
-    (pl-sa-num-val env "N"))
-  3)
-
-(pl-sa-test!
-  "aggregate_all count fail = 0"
-  (let
-    ((env {}))
-    (pl-solve-once!
-      pl-sa-db
-      (pl-sa-goal "aggregate_all(count, fail, N)" env)
-      (pl-mk-trail))
-    (pl-sa-num-val env "N"))
-  0)
-
-(pl-sa-test!
-  "aggregate_all count always succeeds"
-  (pl-solve-once!
-    pl-sa-db
-    (pl-sa-goal "aggregate_all(count, fail, _)" {})
-    (pl-mk-trail))
-  true)
-
-(define pl-sa-env-bag1 {})
-(pl-solve-once!
-  pl-sa-db
-  (pl-sa-goal "aggregate_all(bag(X), member(X, [a,b,c]), L)" pl-sa-env-bag1)
-  (pl-mk-trail))
-(pl-sa-test!
-  "aggregate_all bag [a,b,c]"
-  (pl-sa-list-to-atoms (dict-get pl-sa-env-bag1 "L"))
-  (list "a" "b" "c"))
-
-(define pl-sa-env-bag2 {})
-(pl-solve-once!
-  pl-sa-db
-  (pl-sa-goal "aggregate_all(bag(X), member(X, []), L)" pl-sa-env-bag2)
-  (pl-mk-trail))
-(pl-sa-test!
-  "aggregate_all bag empty goal = []"
-  (pl-sa-list-to-atoms (dict-get pl-sa-env-bag2 "L"))
-  (list))
-
-(pl-sa-test!
-  "aggregate_all sum [1,2,3,4] = 10"
-  (let
-    ((env {}))
-    (pl-solve-once!
-      pl-sa-db
-      (pl-sa-goal "aggregate_all(sum(X), member(X, [1,2,3,4]), S)" env)
-      (pl-mk-trail))
-    (pl-sa-num-val env "S"))
-  10)
-
-(pl-sa-test!
-  "aggregate_all max [3,1,4,1,5,9,2,6] = 9"
-  (let
-    ((env {}))
-    (pl-solve-once!
-      pl-sa-db
-      (pl-sa-goal "aggregate_all(max(X), member(X, [3,1,4,1,5,9,2,6]), M)" env)
-      (pl-mk-trail))
-    (pl-sa-num-val env "M"))
-  9)
-
-(pl-sa-test!
-  "aggregate_all max empty fails"
-  (pl-solve-once!
-    pl-sa-db
-    (pl-sa-goal "aggregate_all(max(X), member(X, []), M)" {})
-    (pl-mk-trail))
-  false)
-
-(pl-sa-test!
-  "aggregate_all min [3,1,4,1,5,9,2,6] = 1"
-  (let
-    ((env {}))
-    (pl-solve-once!
-      pl-sa-db
-      (pl-sa-goal "aggregate_all(min(X), member(X, [3,1,4,1,5,9,2,6]), M)" env)
-      (pl-mk-trail))
-    (pl-sa-num-val env "M"))
-  1)
-
-(pl-sa-test!
-  "aggregate_all min empty fails"
-  (pl-solve-once!
-    pl-sa-db
-    (pl-sa-goal "aggregate_all(min(X), member(X, []), M)" {})
-    (pl-mk-trail))
-  false)
-
-(define pl-sa-env-set1 {})
-(pl-solve-once!
-  pl-sa-db
-  (pl-sa-goal
-    "aggregate_all(set(X), member(X, [b,a,c,a,b]), S)"
-    pl-sa-env-set1)
-  (pl-mk-trail))
-(pl-sa-test!
-  "aggregate_all set [b,a,c,a,b] = [a,b,c]"
-  (pl-sa-list-to-atoms (dict-get pl-sa-env-set1 "S"))
-  (list "a" "b" "c"))
-
-(define pl-sa-env-set2 {})
-(pl-solve-once!
-  pl-sa-db
-  (pl-sa-goal "aggregate_all(set(X), fail, S)" pl-sa-env-set2)
-  (pl-mk-trail))
-(pl-sa-test!
-  "aggregate_all set fail = []"
-  (pl-sa-list-to-atoms (dict-get pl-sa-env-set2 "S"))
-  (list))
-
-(pl-sa-test!
-  "aggregate_all sum empty = 0"
-  (let
-    ((env {}))
-    (pl-solve-once!
-      pl-sa-db
-      (pl-sa-goal "aggregate_all(sum(X), fail, S)" env)
-      (pl-mk-trail))
-    (pl-sa-num-val env "S"))
-  0)
-
-(define pl-string-agg-tests-run! (fn () {:failed pl-sa-test-fail :passed pl-sa-test-pass :total pl-sa-test-count :failures pl-sa-test-failures}))

lib/prolog/tests/term_inspect.sx

@@ -1,147 +0,0 @@
-;; lib/prolog/tests/term_inspect.sx — copy_term/2, functor/3, arg/3.
-
-(define pl-tt-test-count 0)
-(define pl-tt-test-pass 0)
-(define pl-tt-test-fail 0)
-(define pl-tt-test-failures (list))
-
-(define
-  pl-tt-test!
-  (fn
-    (name got expected)
-    (begin
-      (set! pl-tt-test-count (+ pl-tt-test-count 1))
-      (if
-        (= got expected)
-        (set! pl-tt-test-pass (+ pl-tt-test-pass 1))
-        (begin
-          (set! pl-tt-test-fail (+ pl-tt-test-fail 1))
-          (append!
-            pl-tt-test-failures
-            (str name "\n    expected: " expected "\n    got:      " got)))))))
-
-(define
-  pl-tt-goal
-  (fn
-    (src env)
-    (pl-instantiate (nth (first (pl-parse (str "g :- " src "."))) 2) env)))
-
-(define pl-tt-db (pl-mk-db))
-
-;; ── copy_term/2 ──
-
-(pl-tt-test!
-  "copy_term ground compound succeeds + copy = original"
-  (pl-solve-once!
-    pl-tt-db
-    (pl-tt-goal "copy_term(foo(a, b), X), X = foo(a, b)" {})
-    (pl-mk-trail))
-  true)
-
-(pl-tt-test!
-  "copy_term preserves var aliasing in source"
-  (pl-solve-once!
-    pl-tt-db
-    (pl-tt-goal "copy_term(p(Y, Y), p(A, B)), A = 5, B = 5" {})
-    (pl-mk-trail))
-  true)
-
-(pl-tt-test!
-  "copy_term distinct vars stay distinct"
-  (pl-solve-once!
-    pl-tt-db
-    (pl-tt-goal "copy_term(p(Y, Y), p(A, B)), A = 5, B = 6" {})
-    (pl-mk-trail))
-  false)
-
-(define pl-tt-env-1 {})
-(pl-solve-once!
-  pl-tt-db
-  (pl-tt-goal "copy_term(X, Y), Y = 5" pl-tt-env-1)
-  (pl-mk-trail))
-(pl-tt-test!
-  "copy_term: binding the copy doesn't bind the source"
-  (pl-var-bound? (dict-get pl-tt-env-1 "X"))
-  false)
-
-;; ── functor/3 ──
-
-(define pl-tt-env-2 {})
-(pl-solve-once!
-  pl-tt-db
-  (pl-tt-goal "functor(foo(a, b, c), F, N)" pl-tt-env-2)
-  (pl-mk-trail))
-(pl-tt-test!
-  "functor of compound: F = foo"
-  (pl-atom-name (pl-walk-deep (dict-get pl-tt-env-2 "F")))
-  "foo")
-(pl-tt-test!
-  "functor of compound: N = 3"
-  (pl-num-val (pl-walk-deep (dict-get pl-tt-env-2 "N")))
-  3)
-
-(define pl-tt-env-3 {})
-(pl-solve-once!
-  pl-tt-db
-  (pl-tt-goal "functor(hello, F, N)" pl-tt-env-3)
-  (pl-mk-trail))
-(pl-tt-test!
-  "functor of atom: F = hello"
-  (pl-atom-name (pl-walk-deep (dict-get pl-tt-env-3 "F")))
-  "hello")
-(pl-tt-test!
-  "functor of atom: N = 0"
-  (pl-num-val (pl-walk-deep (dict-get pl-tt-env-3 "N")))
-  0)
-
-(pl-tt-test!
-  "functor construct compound: T unifies with foo(a, b)"
-  (pl-solve-once!
-    pl-tt-db
-    (pl-tt-goal "functor(T, foo, 2), T = foo(a, b)" {})
-    (pl-mk-trail))
-  true)
-
-(pl-tt-test!
-  "functor construct atom: T = hello"
-  (pl-solve-once!
-    pl-tt-db
-    (pl-tt-goal "functor(T, hello, 0), T = hello" {})
-    (pl-mk-trail))
-  true)
-
-;; ── arg/3 ──
-
-(pl-tt-test!
-  "arg(1, foo(a, b, c), a)"
-  (pl-solve-once!
-    pl-tt-db
-    (pl-tt-goal "arg(1, foo(a, b, c), a)" {})
-    (pl-mk-trail))
-  true)
-
-(pl-tt-test!
-  "arg(2, foo(a, b, c), X) → X = b"
-  (pl-solve-once!
-    pl-tt-db
-    (pl-tt-goal "arg(2, foo(a, b, c), X), X = b" {})
-    (pl-mk-trail))
-  true)
-
-(pl-tt-test!
-  "arg out-of-range high fails"
-  (pl-solve-once!
-    pl-tt-db
-    (pl-tt-goal "arg(4, foo(a, b, c), X)" {})
-    (pl-mk-trail))
-  false)
-
-(pl-tt-test!
-  "arg(0, ...) fails (1-indexed)"
-  (pl-solve-once!
-    pl-tt-db
-    (pl-tt-goal "arg(0, foo(a), X)" {})
-    (pl-mk-trail))
-  false)
-
-(define pl-term-inspect-tests-run! (fn () {:failed pl-tt-test-fail :passed pl-tt-test-pass :total pl-tt-test-count :failures pl-tt-test-failures}))

plans/agent-briefings/apl-loop.md

@@ -0,0 +1,81 @@
+# apl-on-sx loop agent (single agent, queue-driven)
+
+Role: iterates `plans/apl-on-sx.md` forever. Rank-polymorphic primitives + 6 operators on the JIT is the headline showcase — APL is the densest combinator algebra you can put on top of a primitive table. Every program is `array → array` pure pipelines, exactly what the JIT was built for.
+
+```
+description: apl-on-sx queue loop
+subagent_type: general-purpose
+run_in_background: true
+isolation: worktree
+```
+
+## Prompt
+
+You are the sole background agent working `/root/rose-ash/plans/apl-on-sx.md`. Isolated worktree, forever, one commit per feature. Never push.
+
+## Restart baseline — check before iterating
+
+1. Read `plans/apl-on-sx.md` — roadmap + Progress log.
+2. `ls lib/apl/` — pick up from the most advanced file.
+3. If `lib/apl/tests/*.sx` exist, run them. Green before new work.
+4. If `lib/apl/scoreboard.md` exists, that's your baseline.
+
+## The queue
+
+Phase order per `plans/apl-on-sx.md`:
+
+- **Phase 1** — tokenizer + parser. Unicode glyphs, `¯` for negative, strands (juxtaposition), right-to-left, valence resolution by syntactic position
+- **Phase 2** — array model + scalar primitives. `make-array {shape, ravel}`, scalar promotion, broadcast for `+ - × ÷ ⌈ ⌊ * ⍟ | ! ○`, comparison, logical, `⍳`, `⎕IO`
+- **Phase 3** — structural primitives + indexing. `⍴ , ⍉ ↑ ↓ ⌽ ⊖ ⌷ ⍋ ⍒ ⊂ ⊃ ∊`
+- **Phase 4** — **THE SHOWCASE**: operators. `f/` (reduce), `f¨` (each), `∘.f` (outer), `f.g` (inner), `f⍨` (commute), `f∘g` (compose), `f⍣n` (power), `f⍤k` (rank), `@` (at)
+- **Phase 5** — dfns + tradfns + control flow. `{⍺+⍵}`, `∇` recurse, `⍺←default`, tradfn header, `:If/:While/:For/:Select`
+- **Phase 6** — classic programs (life, mandelbrot, primes, n-queens, quicksort) + idiom corpus + drive to 100+
+
+Within a phase, pick the checkbox that unlocks the most tests per effort.
+
+Every iteration: implement → test → commit → tick `[ ]` → Progress log → next.
+
+## Ground rules (hard)
+
+- **Scope:** only `lib/apl/**` and `plans/apl-on-sx.md`. Do **not** edit `spec/`, `hosts/`, `shared/`, other `lib/<lang>/` dirs, `lib/stdlib.sx`, or `lib/` root. APL primitives go in `lib/apl/runtime.sx`.
+- **NEVER call `sx_build`.** 600s watchdog. If sx_server binary broken → Blockers entry, stop.
+- **Shared-file issues** → plan's Blockers with minimal repro.
+- **SX files:** `sx-tree` MCP tools ONLY. `sx_validate` after edits.
+- **Unicode in `.sx`:** raw UTF-8 only, never `\uXXXX` escapes. Glyphs land directly in source.
+- **Worktree:** commit locally. Never push. Never touch `main`.
+- **Commit granularity:** one feature per commit.
+- **Plan file:** update Progress log + tick boxes every commit.
+
+## APL-specific gotchas
+
+- **Right-to-left, no precedence among functions.** `2 × 3 + 4` is `2 × (3 + 4)` = 14, not 10. Operators bind tighter than functions: `+/ ⍳5` is `+/(⍳5)`, and `2 +.× 3 4` is `2 (+.×) 3 4`.
+- **Valence by position.** `-3` is monadic negate (`-` with no left arg). `5-3` is dyadic subtract. The parser must look left to decide. Same glyph; different fn.
+- **`¯` is part of a number literal**, not a prefix function. `¯3` is the literal negative three; `-3` is the function call. Tokenizer eats `¯` into the numeric token.
+- **Strands.** `1 2 3` is a 3-element vector, not three separate calls. Adjacent literals fuse into a strand at parse time. Adjacent names do *not* fuse — `a b c` is three separate references.
+- **Scalar promotion.** `1 + 2 3 4` ↦ `3 4 5`. Any scalar broadcasts against any-rank conformable shape.
+- **Conformability** = exactly matching shapes, OR one side scalar, OR (in some dialects) one side rank-1 cycling against rank-N. Keep strict in v1: matching shape or scalar only.
+- **`⍳` is overloaded.** Monadic `⍳N` = vector 1..N (or 0..N-1 if `⎕IO=0`). Dyadic `V ⍳ W` = first-index lookup, returns `≢V+1` for not-found.
+- **Reduce with `+/⍳0`** = `0` (identity for `+`). Each scalar primitive has a defined identity used by reduce-on-empty. Don't crash; return identity.
+- **Reduce direction.** `f/` reduces the *last* axis. `f⌿` reduces the *first*. Matters for matrices.
+- **Indexing is 1-based** by default (`⎕IO=1`). Do not silently translate to 0-based; respect `⎕IO`.
+- **Bracket indexing** `A[I]` is sugar for `I⌷A` (squad-quad). Multi-axis: `A[I;J]` is `I J⌷A` with semicolon-separated axes; `A[;J]` selects all of axis 0.
+- **Dfn `{...}`** — `⍺` = left arg (may be unbound for monadic call → check with `⍺←default`), `⍵` = right arg, `∇` = recurse. Default left arg syntax: `⍺←0`.
+- **Tradfn vs dfn** — tradfns use line-numbered `→linenum` for goto; dfns use guards `cond:expr`. Pick the right one for the user's syntax.
+- **Empty array** = rank-N array where some dim is 0. `0⍴⍳0` is empty rank-1. Scalar prototype matters for empty-array operations; ignore in v1, return 0/space.
+- **Test corpus:** custom + idioms. Place programs in `lib/apl/tests/programs/` with `.apl` extension.
+
+## General gotchas (all loops)
+
+- SX `do` = R7RS iteration. Use `begin` for multi-expr sequences.
+- `cond`/`when`/`let` clauses evaluate only the last expr.
+- `type-of` on user fn returns `"lambda"`.
+- Shell heredoc `||` gets eaten — escape or use `case`.
+
+## Style
+
+- No comments in `.sx` unless non-obvious.
+- No new planning docs — update `plans/apl-on-sx.md` inline.
+- Short, factual commit messages (`apl: outer product ∘. (+9)`).
+- One feature per iteration. Commit. Log. Next.
+
+Go. Read the plan; find first `[ ]`; implement.

plans/agent-briefings/common-lisp-loop.md

@@ -0,0 +1,80 @@
+# common-lisp-on-sx loop agent (single agent, queue-driven)
+
+Role: iterates `plans/common-lisp-on-sx.md` forever. Conditions + restarts on delimited continuations is the headline showcase — every other Lisp reinvents resumable exceptions on the host stack. On SX `signal`/`invoke-restart` is just a captured continuation. Plus CLOS, the LOOP macro, packages.
+
+```
+description: common-lisp-on-sx queue loop
+subagent_type: general-purpose
+run_in_background: true
+isolation: worktree
+```
+
+## Prompt
+
+You are the sole background agent working `/root/rose-ash/plans/common-lisp-on-sx.md`. Isolated worktree, forever, one commit per feature. Never push.
+
+## Restart baseline — check before iterating
+
+1. Read `plans/common-lisp-on-sx.md` — roadmap + Progress log.
+2. `ls lib/common-lisp/` — pick up from the most advanced file.
+3. If `lib/common-lisp/tests/*.sx` exist, run them. Green before new work.
+4. If `lib/common-lisp/scoreboard.md` exists, that's your baseline.
+
+## The queue
+
+Phase order per `plans/common-lisp-on-sx.md`:
+
+- **Phase 1** — reader + parser (read macros `#'` `'` `` ` `` `,` `,@` `#( … )` `#:` `#\char` `#xFF` `#b1010`, ratios, dispatch chars, lambda lists with `&optional`/`&rest`/`&key`/`&aux`)
+- **Phase 2** — sequential eval + special forms (`let`/`let*`/`flet`/`labels`, `block`/`return-from`, `tagbody`/`go`, `unwind-protect`, multiple values, `setf` subset, dynamic variables)
+- **Phase 3** — **THE SHOWCASE**: condition system + restarts. `define-condition`, `signal`/`error`/`cerror`/`warn`, `handler-bind` (non-unwinding), `handler-case` (unwinding), `restart-case`, `restart-bind`, `find-restart`/`invoke-restart`/`compute-restarts`, `with-condition-restarts`. Classic programs (restart-demo, parse-recover, interactive-debugger) green.
+- **Phase 4** — CLOS: `defclass`, `defgeneric`, `defmethod` with `:before`/`:after`/`:around`, `call-next-method`, multiple dispatch
+- **Phase 5** — macros + LOOP macro + reader macros
+- **Phase 6** — packages + stdlib (sequence functions, FORMAT directives, drive corpus to 200+)
+
+Within a phase, pick the checkbox that unlocks the most tests per effort.
+
+Every iteration: implement → test → commit → tick `[ ]` → Progress log → next.
+
+## Ground rules (hard)
+
+- **Scope:** only `lib/common-lisp/**` and `plans/common-lisp-on-sx.md`. Do **not** edit `spec/`, `hosts/`, `shared/`, other `lib/<lang>/` dirs, `lib/stdlib.sx`, or `lib/` root. CL primitives go in `lib/common-lisp/runtime.sx`.
+- **NEVER call `sx_build`.** 600s watchdog. If sx_server binary broken → Blockers entry, stop.
+- **Shared-file issues** → plan's Blockers with minimal repro.
+- **Delimited continuations** are in `lib/callcc.sx` + `spec/evaluator.sx` Step 5. `sx_summarise` spec/evaluator.sx first — 2300+ lines.
+- **SX files:** `sx-tree` MCP tools ONLY. `sx_validate` after edits.
+- **Worktree:** commit locally. Never push. Never touch `main`.
+- **Commit granularity:** one feature per commit.
+- **Plan file:** update Progress log + tick boxes every commit.
+
+## Common-Lisp-specific gotchas
+
+- **`handler-bind` is non-unwinding** — handlers can decline by returning normally, in which case `signal` keeps walking the chain. **`handler-case` is unwinding** — picking a handler aborts the protected form via a captured continuation. Don't conflate them.
+- **Restarts are not handlers.** `restart-case` establishes named *resumption points*; `signal` runs handler code with restarts visible; the handler chooses a restart by calling `invoke-restart`, which abandons handler stack and resumes at the restart point. Two stacks: handlers walk down, restarts wait to be invoked.
+- **`block` / `return-from`** is lexical. `block name … (return-from name v) …` captures `^k` once at entry; `return-from` invokes it. `return-from` to a name not in scope is an error (don't fall back to outer block).
+- **`tagbody` / `go`** — each tag in tagbody is a continuation; `go tag` invokes it. Tags are lexical, can only target tagbodies in scope.
+- **`unwind-protect`** runs cleanup on *any* non-local exit (return-from, throw, condition unwind). Implement as a scope frame fired by the cleanup machinery.
+- **Multiple values**: primary-value-only contexts (function args, `if` test, etc.) drop extras silently. `values` produces multiple. `multiple-value-bind` / `multiple-value-call` consume them. Don't auto-list.
+- **CLOS dispatch:** sort applicable methods by argument-list specificity (`subclassp` per arg, left-to-right); standard method combination calls primary methods most-specific-first via `call-next-method` chain. `:before` runs all before primaries; `:after` runs all after, in reverse-specificity. `:around` wraps everything.
+- **`call-next-method`** is a *continuation* available only inside a method body. Implement as a thunk stored in a dynamic-extent variable.
+- **Generalised reference (`setf`)**: `(setf (foo x) v)` ↦ `(setf-foo v x)`. Look up the setf-expander, not just a writer fn. `define-setf-expander` is mandatory for non-trivial places. Start with the symbolic / list / aref / slot-value cases.
+- **Dynamic variables (specials):** `defvar`/`defparameter` mark a symbol as special. `let` over a special name *rebinds* in dynamic extent (use parameterize-style scope), not lexical.
+- **Symbols are package-qualified.** Reader resolves `cl:car`, `mypkg::internal`, bare `foo` (current package). Internal vs external matters for `:` (one colon) reads.
+- **`nil` is also `()` is also the empty list.** Same object. `nil` is also false. CL has no distinct unit value.
+- **LOOP macro is huge.** Build incrementally — start with `for/in`, `for/from`, `collect`, `sum`, `count`, `repeat`. Add conditional clauses (`when`, `if`, `else`) once iteration drivers stable. `named` blocks + `return-from named` last.
+- **Test corpus:** custom + curated `ansi-test` slice. Place programs in `lib/common-lisp/tests/programs/` with `.lisp` extension.
+
+## General gotchas (all loops)
+
+- SX `do` = R7RS iteration. Use `begin` for multi-expr sequences.
+- `cond`/`when`/`let` clauses evaluate only the last expr.
+- `type-of` on user fn returns `"lambda"`.
+- Shell heredoc `||` gets eaten — escape or use `case`.
+
+## Style
+
+- No comments in `.sx` unless non-obvious.
+- No new planning docs — update `plans/common-lisp-on-sx.md` inline.
+- Short, factual commit messages (`common-lisp: handler-bind + 12 tests`).
+- One feature per iteration. Commit. Log. Next.
+
+Go. Read the plan; find first `[ ]`; implement.

plans/agent-briefings/ruby-loop.md

@@ -0,0 +1,83 @@
+# ruby-on-sx loop agent (single agent, queue-driven)
+
+Role: iterates `plans/ruby-on-sx.md` forever. Fibers via delcc is the headline showcase — `Fiber.new`/`Fiber.yield`/`Fiber.resume` are textbook delimited continuations with sugar, where MRI does it via C-stack swapping. Plus blocks/yield (lexical escape continuations, same shape as Smalltalk's non-local return), method_missing, and singleton classes.
+
+```
+description: ruby-on-sx queue loop
+subagent_type: general-purpose
+run_in_background: true
+isolation: worktree
+```
+
+## Prompt
+
+You are the sole background agent working `/root/rose-ash/plans/ruby-on-sx.md`. Isolated worktree, forever, one commit per feature. Never push.
+
+## Restart baseline — check before iterating
+
+1. Read `plans/ruby-on-sx.md` — roadmap + Progress log.
+2. `ls lib/ruby/` — pick up from the most advanced file.
+3. If `lib/ruby/tests/*.sx` exist, run them. Green before new work.
+4. If `lib/ruby/scoreboard.md` exists, that's your baseline.
+
+## The queue
+
+Phase order per `plans/ruby-on-sx.md`:
+
+- **Phase 1** — tokenizer + parser. Keywords, identifier sigils (`@` ivar, `@@` cvar, `$` global), strings with interpolation, `%w[]`/`%i[]`, symbols, blocks `{|x| …}` and `do |x| … end`, splats, default args, method def
+- **Phase 2** — object model + sequential eval. Class table, ancestor-chain dispatch, `super`, singleton classes, `method_missing` fallback, dynamic constant lookup
+- **Phase 3** — blocks + procs + lambdas. Method captures escape continuation `^k`; `yield` / `return` / `break` / `next` / `redo` semantics; lambda strict arity vs proc lax
+- **Phase 4** — **THE SHOWCASE**: fibers via delcc. `Fiber.new`/`Fiber.resume`/`Fiber.yield`/`Fiber.transfer`. Classic programs (generator, producer-consumer, tree-walk) green
+- **Phase 5** — modules + mixins + metaprogramming. `include`/`prepend`/`extend`, `define_method`, `class_eval`/`instance_eval`, `respond_to?`/`respond_to_missing?`, hooks
+- **Phase 6** — stdlib drive. `Enumerable` mixin, `Comparable`, Array/Hash/Range/String/Integer methods, drive corpus to 200+
+
+Within a phase, pick the checkbox that unlocks the most tests per effort.
+
+Every iteration: implement → test → commit → tick `[ ]` → Progress log → next.
+
+## Ground rules (hard)
+
+- **Scope:** only `lib/ruby/**` and `plans/ruby-on-sx.md`. Do **not** edit `spec/`, `hosts/`, `shared/`, other `lib/<lang>/` dirs, `lib/stdlib.sx`, or `lib/` root. Ruby primitives go in `lib/ruby/runtime.sx`.
+- **NEVER call `sx_build`.** 600s watchdog. If sx_server binary broken → Blockers entry, stop.
+- **Shared-file issues** → plan's Blockers with minimal repro.
+- **Delimited continuations** are in `lib/callcc.sx` + `spec/evaluator.sx` Step 5. `sx_summarise` spec/evaluator.sx first — 2300+ lines.
+- **SX files:** `sx-tree` MCP tools ONLY. `sx_validate` after edits.
+- **Worktree:** commit locally. Never push. Never touch `main`.
+- **Commit granularity:** one feature per commit.
+- **Plan file:** update Progress log + tick boxes every commit.
+
+## Ruby-specific gotchas
+
+- **Block `return` vs lambda `return`.** Inside a block `{ ... return v }`, `return` invokes the *enclosing method's* escape continuation (non-local return). Inside a lambda `->(){ ... return v }`, `return` returns from the *lambda*. Don't conflate. Implement: blocks bind their `^method-k`; lambdas bind their own `^lambda-k`.
+- **`break` from inside a block** invokes a different escape — the *iteration loop's* escape — and the loop returns the break-value. `next` is escape from current iteration, returns iteration value. `redo` re-enters current iteration without advancing.
+- **Proc arity is lax.** `proc { |a, b, c| … }.call(1, 2)` ↦ `c = nil`. Lambda is strict — same call raises ArgumentError. Check arity at call site for lambdas only.
+- **Block argument unpacking.** `[[1,2],[3,4]].each { |a, b| … }` — single Array arg auto-unpacks for blocks (not lambdas). One arg, one Array → unpack. Frequent footgun.
+- **Method dispatch chain order:** prepended modules → class methods → included modules → superclass → BasicObject → method_missing. `super` walks from the *defining* class's position, not the receiver class's.
+- **Singleton classes** are lazily allocated. Looking up the chain for an object passes through its singleton class first, then its actual class. `class << obj; …; end` opens the singleton.
+- **`method_missing`** — fallback when ancestor walk misses. Receives `(name_symbol, *args, &blk)`. Pair with `respond_to_missing?` for `respond_to?` to also report true. Do **not** swallow NoMethodError silently.
+- **Ivars are per-object dicts.** Reading an unset ivar yields `nil` and a warning (`-W`). Don't error.
+- **Constant lookup** is first lexical (Module.nesting), then inheritance (Module.ancestors of the innermost class). Different from method lookup.
+- **`Object#send`** invokes private and public methods alike; `Object#public_send` skips privates.
+- **Class reopening.** `class Foo; def bar; …; end; end` plus a later `class Foo; def baz; …; end; end` adds methods to the same class. Class table lookups must be by-name, mutable; methods dict is mutable.
+- **Fiber semantics.** `Fiber.new { |arg| … }` creates a fiber suspended at entry. First `Fiber.resume(v)` enters with `arg = v`. Inside, `Fiber.yield(w)` returns `w` to the resumer; the next `Fiber.resume(v')` returns `v'` to the yield site. End of block returns final value to last resumer; subsequent `Fiber.resume` raises FiberError.
+- **`Fiber.transfer`** is symmetric — either side can transfer to the other; no resume/yield asymmetry. Implement on top of the same continuation pair, just don't enforce direction.
+- **Symbols are interned.** `:foo == :foo` is identity. Use SX symbols.
+- **Strings are mutable.** `s = "abc"; s << "d"; s == "abcd"`. Hash keys can be strings; hash dups string keys at insertion to be safe (or freeze them).
+- **Truthiness:** only `false` and `nil` are falsy. `0`, `""`, `[]` are truthy.
+- **Test corpus:** custom + curated RubySpec slice. Place programs in `lib/ruby/tests/programs/` with `.rb` extension.
+
+## General gotchas (all loops)
+
+- SX `do` = R7RS iteration. Use `begin` for multi-expr sequences.
+- `cond`/`when`/`let` clauses evaluate only the last expr.
+- `type-of` on user fn returns `"lambda"`.
+- Shell heredoc `||` gets eaten — escape or use `case`.
+
+## Style
+
+- No comments in `.sx` unless non-obvious.
+- No new planning docs — update `plans/ruby-on-sx.md` inline.
+- Short, factual commit messages (`ruby: Fiber.yield + Fiber.resume (+8)`).
+- One feature per iteration. Commit. Log. Next.
+
+Go. Read the plan; find first `[ ]`; implement.

plans/agent-briefings/smalltalk-loop.md

@@ -0,0 +1,77 @@
+# smalltalk-on-sx loop agent (single agent, queue-driven)
+
+Role: iterates `plans/smalltalk-on-sx.md` forever. Message-passing OO + **blocks with non-local return** on delimited continuations. Non-local return is the headline showcase — every other Smalltalk reinvents it on the host stack; on SX it falls out of the captured method-return continuation.
+
+```
+description: smalltalk-on-sx queue loop
+subagent_type: general-purpose
+run_in_background: true
+isolation: worktree
+```
+
+## Prompt
+
+You are the sole background agent working `/root/rose-ash/plans/smalltalk-on-sx.md`. Isolated worktree, forever, one commit per feature. Never push.
+
+## Restart baseline — check before iterating
+
+1. Read `plans/smalltalk-on-sx.md` — roadmap + Progress log.
+2. `ls lib/smalltalk/` — pick up from the most advanced file.
+3. If `lib/smalltalk/tests/*.sx` exist, run them. Green before new work.
+4. If `lib/smalltalk/scoreboard.md` exists, that's your baseline.
+
+## The queue
+
+Phase order per `plans/smalltalk-on-sx.md`:
+
+- **Phase 1** — tokenizer + parser (chunk format, identifiers, keywords `foo:`, binary selectors, `#sym`, `#(…)`, `$c`, blocks `[:a | …]`, cascades, message precedence)
+- **Phase 2** — object model + sequential eval (class table bootstrap, message dispatch, `super`, `doesNotUnderstand:`, instance variables)
+- **Phase 3** — **THE SHOWCASE**: blocks with non-local return via captured method-return continuation. `whileTrue:` / `ifTrue:ifFalse:` as block sends. 5 classic programs (eight-queens, quicksort, mandelbrot, life, fibonacci) green.
+- **Phase 4** — reflection + MOP: `perform:`, `respondsTo:`, runtime method addition, `becomeForward:`, `Exception` / `on:do:` / `ensure:` on top of `handler-bind`/`raise`
+- **Phase 5** — collections + numeric tower + streams
+- **Phase 6** — port SUnit, vendor Pharo Kernel-Tests slice, drive corpus to 200+
+- **Phase 7** — speed (optional): inline caching, block intrinsification
+
+Within a phase, pick the checkbox that unlocks the most tests per effort.
+
+Every iteration: implement → test → commit → tick `[ ]` → Progress log → next.
+
+## Ground rules (hard)
+
+- **Scope:** only `lib/smalltalk/**` and `plans/smalltalk-on-sx.md`. Do **not** edit `spec/`, `hosts/`, `shared/`, other `lib/<lang>/` dirs, `lib/stdlib.sx`, or `lib/` root. Smalltalk primitives go in `lib/smalltalk/runtime.sx`.
+- **NEVER call `sx_build`.** 600s watchdog. If sx_server binary broken → Blockers entry, stop.
+- **Shared-file issues** → plan's Blockers with minimal repro.
+- **Delimited continuations** are in `lib/callcc.sx` + `spec/evaluator.sx` Step 5. `sx_summarise` spec/evaluator.sx first — 2300+ lines.
+- **SX files:** `sx-tree` MCP tools ONLY. `sx_validate` after edits.
+- **Worktree:** commit locally. Never push. Never touch `main`.
+- **Commit granularity:** one feature per commit.
+- **Plan file:** update Progress log + tick boxes every commit.
+
+## Smalltalk-specific gotchas
+
+- **Method invocation captures `^k`** — the return continuation. Bind it as the block's escape token. `^expr` from inside any nested block invokes that captured `^k`. Escape past method return raises `BlockContext>>cannotReturn:`.
+- **Blocks are lambdas + escape token**, not bare lambdas. `value`/`value:`/… invoke the lambda; `^` invokes the escape.
+- **`ifTrue:` / `ifFalse:` / `whileTrue:` are ordinary block sends** — no special form. The runtime intrinsifies them in the JIT path (Tier 1 of bytecode expansion already covers this pattern).
+- **Cascade** `r m1; m2; m3` desugars to `(let ((tmp r)) (st-send tmp 'm1 ()) (st-send tmp 'm2 ()) (st-send tmp 'm3 ()))`. Result is the cascade's last send (or first, depending on parser variant — pick one and document).
+- **`super` send** looks up starting from the *defining* class's superclass, not the receiver class. Stash the defining class on the method record.
+- **Selectors are interned symbols.** Use SX symbols.
+- **Receiver dispatch:** tagged ints / floats / strings / symbols / `nil` / `true` / `false` aren't boxed. Their classes (`SmallInteger`, `Float`, `String`, `Symbol`, `UndefinedObject`, `True`, `False`) are looked up by SX type-of, not by an `:class` field.
+- **Method precedence:** unary > binary > keyword. `3 + 4 factorial` is `3 + (4 factorial)`. `a foo: b bar` is `a foo: (b bar)` (keyword absorbs trailing unary).
+- **Image / fileIn / become: between sessions** = out of scope. One-way `becomeForward:` only.
+- **Test corpus:** ~200 hand-written + a slice of Pharo Kernel-Tests. Place programs in `lib/smalltalk/tests/programs/`.
+
+## General gotchas (all loops)
+
+- SX `do` = R7RS iteration. Use `begin` for multi-expr sequences.
+- `cond`/`when`/`let` clauses evaluate only the last expr.
+- `type-of` on user fn returns `"lambda"`.
+- Shell heredoc `||` gets eaten — escape or use `case`.
+
+## Style
+
+- No comments in `.sx` unless non-obvious.
+- No new planning docs — update `plans/smalltalk-on-sx.md` inline.
+- Short, factual commit messages (`smalltalk: tokenizer + 56 tests`).
+- One feature per iteration. Commit. Log. Next.
+
+Go. Read the plan; find first `[ ]`; implement.

plans/agent-briefings/tcl-loop.md

@@ -0,0 +1,83 @@
+# tcl-on-sx loop agent (single agent, queue-driven)
+
+Role: iterates `plans/tcl-on-sx.md` forever. `uplevel`/`upvar` is the headline showcase — Tcl's superpower for defining your own control structures, requiring deep VM cooperation in any normal host but falling out of SX's first-class env-chain. Plus the Dodekalogue (12 rules), command-substitution everywhere, and "everything is a string" homoiconicity.
+
+```
+description: tcl-on-sx queue loop
+subagent_type: general-purpose
+run_in_background: true
+isolation: worktree
+```
+
+## Prompt
+
+You are the sole background agent working `/root/rose-ash/plans/tcl-on-sx.md`. Isolated worktree, forever, one commit per feature. Never push.
+
+## Restart baseline — check before iterating
+
+1. Read `plans/tcl-on-sx.md` — roadmap + Progress log.
+2. `ls lib/tcl/` — pick up from the most advanced file.
+3. If `lib/tcl/tests/*.sx` exist, run them. Green before new work.
+4. If `lib/tcl/scoreboard.md` exists, that's your baseline.
+
+## The queue
+
+Phase order per `plans/tcl-on-sx.md`:
+
+- **Phase 1** — tokenizer + parser. The Dodekalogue (12 rules): word-splitting, command sub `[…]`, var sub `$name`/`${name}`/`$arr(idx)`, double-quote vs brace word, backslash, `;`, `#` comments only at command start, single-pass left-to-right substitution
+- **Phase 2** — sequential eval + core commands. `set`/`unset`/`incr`/`append`/`lappend`, `puts`/`gets`, `expr` (own mini-language), `if`/`while`/`for`/`foreach`/`switch`, string commands, list commands, dict commands
+- **Phase 3** — **THE SHOWCASE**: `proc` + `uplevel` + `upvar`. Frame stack with proc-call push/pop; `uplevel #N script` evaluates in caller's frame; `upvar` aliases names across frames. Classic programs (for-each-line, assert macro, with-temp-var) green
+- **Phase 4** — `return -code N`, `catch`, `try`/`trap`/`finally`, `throw`. Control flow as integer codes
+- **Phase 5** — namespaces + ensembles. `namespace eval`, qualified names `::ns::cmd`, ensembles, `namespace path`
+- **Phase 6** — coroutines (built on fibers, same delcc as Ruby fibers) + system commands + drive corpus to 150+
+
+Within a phase, pick the checkbox that unlocks the most tests per effort.
+
+Every iteration: implement → test → commit → tick `[ ]` → Progress log → next.
+
+## Ground rules (hard)
+
+- **Scope:** only `lib/tcl/**` and `plans/tcl-on-sx.md`. Do **not** edit `spec/`, `hosts/`, `shared/`, other `lib/<lang>/` dirs, `lib/stdlib.sx`, or `lib/` root. Tcl primitives go in `lib/tcl/runtime.sx`.
+- **NEVER call `sx_build`.** 600s watchdog. If sx_server binary broken → Blockers entry, stop.
+- **Shared-file issues** → plan's Blockers with minimal repro.
+- **Delimited continuations** are in `lib/callcc.sx` + `spec/evaluator.sx` Step 5. `sx_summarise` spec/evaluator.sx first — 2300+ lines.
+- **SX files:** `sx-tree` MCP tools ONLY. `sx_validate` after edits.
+- **Worktree:** commit locally. Never push. Never touch `main`.
+- **Commit granularity:** one feature per commit.
+- **Plan file:** update Progress log + tick boxes every commit.
+
+## Tcl-specific gotchas
+
+- **Everything is a string.** Internally cache shimmer reps (list, dict, int, double) for performance, but every value must be re-stringifiable. Mutating one rep dirties the cached string and vice versa.
+- **The Dodekalogue is strict.** Substitution is **one-pass**, **left-to-right**. The result of a substitution is a value, not a script — it does NOT get re-parsed for further substitutions. This is what makes Tcl safe-by-default. Don't accidentally re-parse.
+- **Brace word `{…}`** is the only way to defer evaluation. No substitution inside, just balanced braces. Used for `if {expr}` body, `proc body`, `expr` arguments.
+- **Double-quote word `"…"`** is identical to a bare word for substitution purposes — it just allows whitespace in a single word. `\` escapes still apply.
+- **Comments are only at command position.** `# this is a comment` after a `;` or newline; *not* inside a command. `set x 1 # not a comment` is a 4-arg `set`.
+- **`expr` has its own grammar** — operator precedence, function calls — and does its own substitution. Brace `expr {$x + 1}` to avoid double-substitution and to enable bytecode caching.
+- **`if` and `while` re-parse** the condition only if not braced. Always use `if {…}`/`while {…}` form. The unbraced form re-substitutes per iteration.
+- **`return` from a `proc`** uses control code 2. `break` is 3, `continue` is 4. `error` is 1. `catch` traps any non-zero code; user can return non-zero with `return -code error -errorcode FOO message`.
+- **`uplevel #0 script`** is global frame. `uplevel 1 script` (or just `uplevel script`) is caller's frame. `uplevel #N` is absolute level N (0=global, 1=top-level proc, 2=proc-called-from-top, …). Negative levels are errors.
+- **`upvar #N otherVar localVar`** binds `localVar` in the current frame as an *alias* — both names refer to the same storage. Reads and writes go through the alias.
+- **`info level`** with no arg returns current level number. `info level N` (positive) returns the command list that invoked level N. `info level -N` returns the command list of the level N relative-up.
+- **Variable names with `(…)`** are array elements: `set arr(foo) 1`. Arrays are not first-class values — you can't `set x $arr`. `array get arr` gives a flat list `{key1 val1 key2 val2 …}`.
+- **List vs string.** `set l "a b c"` and `set l [list a b c]` look the same when printed but the second has a cached list rep. `lindex` works on both via shimmering. Most user code can't tell the difference.
+- **`incr x`** errors if x doesn't exist; pre-set with `set x 0` or use `incr x 0` first if you mean "create-or-increment". Or use `dict incr` for dicts.
+- **Coroutines are fibers.** `coroutine name body` starts a coroutine; calling `name` resumes it; `yield value` from inside suspends and returns `value` to the resumer. Same primitive as Ruby fibers — share the implementation under the hood.
+- **`switch`** matches first clause whose pattern matches. Default is `default`. Variant matches: glob (default), `-exact`, `-glob`, `-regexp`. Body `-` means "fall through to next clause's body".
+- **Test corpus:** custom + slice of Tcl's own tests. Place programs in `lib/tcl/tests/programs/` with `.tcl` extension.
+
+## General gotchas (all loops)
+
+- SX `do` = R7RS iteration. Use `begin` for multi-expr sequences.
+- `cond`/`when`/`let` clauses evaluate only the last expr.
+- `type-of` on user fn returns `"lambda"`.
+- Shell heredoc `||` gets eaten — escape or use `case`.
+
+## Style
+
+- No comments in `.sx` unless non-obvious.
+- No new planning docs — update `plans/tcl-on-sx.md` inline.
+- Short, factual commit messages (`tcl: uplevel + upvar (+11)`).
+- One feature per iteration. Commit. Log. Next.
+
+Go. Read the plan; find first `[ ]`; implement.

plans/apl-on-sx.md

@@ -0,0 +1,115 @@
+# APL-on-SX: rank-polymorphic primitives + glyph parser
+
+The headline showcase is **rank polymorphism** — a single primitive (`+`, `⌈`, `⊂`, `⍳`) works uniformly on scalars, vectors, matrices, and higher-rank arrays. ~80 glyph primitives + 6 operators bind together with right-to-left evaluation; the entire language is a high-density combinator algebra. The JIT compiler + primitive table pay off massively here because almost every program is `array → array` pure pipelines.
+
+End-state goal: Dyalog-flavoured APL subset, dfns + tradfns, classic programs (game-of-life, mandelbrot, prime-sieve, n-queens, conway), 100+ green tests.
+
+## Scope decisions (defaults — override by editing before we spawn)
+
+- **Syntax:** Dyalog APL surface, Unicode glyphs. `⎕`-quad system functions for I/O. `∇` tradfn header.
+- **Conformance:** "Reads like APL, runs like APL." Not byte-compat with Dyalog; we care about right-to-left semantics and rank polymorphism.
+- **Test corpus:** custom — APL idioms (Roger Hui style), classic programs, plus ~50 pattern tests for primitives.
+- **Out of scope:** ⎕-namespaces beyond a handful, complex numbers, full TAO ordering, `⎕FX` runtime function definition (use static `∇` only), nested-array-of-functions higher orders, the editor.
+- **Glyphs:** input via plain Unicode in `.apl` source files. Backtick-prefix shortcuts handled by the user's editor — we don't ship one.
+
+## Ground rules
+
+- **Scope:** only touch `lib/apl/**` and `plans/apl-on-sx.md`. Don't edit `spec/`, `hosts/`, `shared/`, or any other `lib/<lang>/**`. APL primitives go in `lib/apl/runtime.sx`.
+- **SX files:** use `sx-tree` MCP tools only.
+- **Commits:** one feature per commit. Keep `## Progress log` updated and tick roadmap boxes.
+
+## Architecture sketch
+
+```
+APL source (Unicode glyphs)
+    │
+    ▼
+lib/apl/tokenizer.sx   — glyphs, identifiers, numbers (¯ for negative), strings, strands
+    │
+    ▼
+lib/apl/parser.sx      — right-to-left with valence resolution (mon vs dyadic by position)
+    │
+    ▼
+lib/apl/transpile.sx   — AST → SX AST (entry: apl-eval-ast)
+    │
+    ▼
+lib/apl/runtime.sx     — array model, ~80 primitives, 6 operators, dfns/tradfns
+```
+
+Core mapping:
+- **Array** = SX dict `{:shape (d1 d2 …) :ravel #(v1 v2 …)}`. Scalar is rank-0 (empty shape), vector is rank-1, matrix rank-2, etc. Type uniformity not required (heterogeneous nested arrays via "boxed" elements `⊂x`).
+- **Rank polymorphism** — every scalar primitive is broadcast: `1 2 3 + 4 5 6` ↦ `5 7 9`; `(2 3⍴⍳6) + 1` ↦ broadcast scalar to matrix.
+- **Conformability** = matching shapes, or one-side scalar, or rank-1 cycling (deferred — keep strict in v1).
+- **Valence** = each glyph has a monadic and a dyadic meaning; resolution is purely positional (left-arg present → dyadic).
+- **Operator** = takes one or two function operands, returns a derived function (`f¨` = `each f`, `f/` = `reduce f`, `f∘g` = `compose`, `f⍨` = `commute`).
+- **Tradfn** `∇R←L F R; locals` = named function with explicit header.
+- **Dfn** `{⍺+⍵}` = anonymous, `⍺` = left arg, `⍵` = right arg, `∇` = recurse.
+
+## Roadmap
+
+### Phase 1 — tokenizer + parser
+- [ ] Tokenizer: Unicode glyphs (the full APL set: `+ - × ÷ * ⍟ ⌈ ⌊ | ! ? ○ ~ < ≤ = ≥ > ≠ ∊ ∧ ∨ ⍱ ⍲ , ⍪ ⍴ ⌽ ⊖ ⍉ ↑ ↓ ⊂ ⊃ ⊆ ∪ ∩ ⍳ ⍸ ⌷ ⍋ ⍒ ⊥ ⊤ ⊣ ⊢ ⍎ ⍕ ⍝`), operators (`/ \ ¨ ⍨ ∘ . ⍣ ⍤ ⍥ @`), numbers (`¯` for negative, `1E2`, `1J2` complex deferred), characters (`'a'`, `''` escape), strands (juxtaposition of literals: `1 2 3`), names, comments `⍝ …`
+- [ ] Parser: right-to-left; classify each token as function, operator, value, or name; resolve valence positionally; dfn `{…}` body, tradfn `∇` header, guards `:`, control words `:If :While :For …` (Dyalog-style)
+- [ ] Unit tests in `lib/apl/tests/parse.sx`
+
+### Phase 2 — array model + scalar primitives
+- [ ] Array constructor: `make-array shape ravel`, `scalar v`, `vector v…`, `enclose`/`disclose`
+- [ ] Shape arithmetic: `⍴` (shape), `,` (ravel), `≢` (tally / first-axis-length), `≡` (depth)
+- [ ] Scalar arithmetic primitives broadcast: `+ - × ÷ ⌈ ⌊ * ⍟ | ! ○`
+- [ ] Scalar comparison primitives: `< ≤ = ≥ > ≠`
+- [ ] Scalar logical: `~ ∧ ∨ ⍱ ⍲`
+- [ ] Index generator: `⍳n` (vector 1..n or 0..n-1 depending on `⎕IO`)
+- [ ] `⎕IO` = 1 default (Dyalog convention)
+- [ ] 40+ tests in `lib/apl/tests/scalar.sx`
+
+### Phase 3 — structural primitives + indexing
+- [ ] Reshape `⍴`, ravel `,`, transpose `⍉` (full + dyadic axis spec)
+- [ ] Take `↑`, drop `↓`, rotate `⌽` (last axis), `⊖` (first axis)
+- [ ] Catenate `,` (last axis) and `⍪` (first axis)
+- [ ] Index `⌷` (squad), bracket-indexing `A[I]` (sugar for `⌷`)
+- [ ] Grade-up `⍋`, grade-down `⍒`
+- [ ] Enclose `⊂`, disclose `⊃`, partition (subset deferred)
+- [ ] Membership `∊`, find `⍳` (dyadic), without `~` (dyadic), unique `∪` (deferred to phase 6)
+- [ ] 40+ tests in `lib/apl/tests/structural.sx`
+
+### Phase 4 — operators (THE SHOWCASE)
+- [ ] Reduce `f/` (last axis), `f⌿` (first axis) — including `∧/`, `∨/`, `+/`, `×/`, `⌈/`, `⌊/`
+- [ ] Scan `f\`, `f⍀`
+- [ ] Each `f¨` — applies `f` to each scalar/element
+- [ ] Outer product `∘.f` — `1 2 3 ∘.× 1 2 3` ↦ multiplication table
+- [ ] Inner product `f.g` — `+.×` is matrix multiply
+- [ ] Commute `f⍨` — `f⍨ x` ↔ `x f x`, `x f⍨ y` ↔ `y f x`
+- [ ] Compose `f∘g` — applies `g` first then `f`
+- [ ] Power `f⍣n` — apply f n times; `f⍣≡` until fixed point
+- [ ] Rank `f⍤k` — apply f at sub-rank k
+- [ ] At `@` — selective replace
+- [ ] 40+ tests in `lib/apl/tests/operators.sx`
+
+### Phase 5 — dfns + tradfns + control flow
+- [ ] Dfn `{…}` with `⍺` (left arg, may be absent → niladic/monadic), `⍵` (right arg), `∇` (recurse), guards `cond:expr`, default left arg `⍺←default`
+- [ ] Local assignment via `←` (lexical inside dfn)
+- [ ] Tradfn `∇` header: `R←L F R;l1;l2`, statement-by-statement, branch via `→linenum`
+- [ ] Dyalog control words: `:If/:Else/:EndIf`, `:While/:EndWhile`, `:For X :In V :EndFor`, `:Select/:Case/:EndSelect`, `:Trap`/`:EndTrap`
+- [ ] Niladic / monadic / dyadic dispatch (function valence at definition time)
+- [ ] `lib/apl/conformance.sh` + runner, `scoreboard.json` + `scoreboard.md`
+
+### Phase 6 — classic programs + drive corpus
+- [ ] Classic programs in `lib/apl/tests/programs/`:
+  - [ ] `life.apl` — Conway's Game of Life as a one-liner using `⊂` `⊖` `⌽` `+/`
+  - [ ] `mandelbrot.apl` — complex iteration with rank-polymorphic `+ × ⌊` (or real-axis subset)
+  - [ ] `primes.apl` — `(2=+⌿0=A∘.|A)/A←⍳N` sieve
+  - [ ] `n-queens.apl` — backtracking via reduce
+  - [ ] `quicksort.apl` — the classic Roger Hui one-liner
+- [ ] System functions: `⎕FMT`, `⎕FR` (float repr), `⎕TS` (timestamp), `⎕IO`, `⎕ML` (migration level — fixed at 1), `⎕←` (print)
+- [ ] Drive corpus to 100+ green
+- [ ] Idiom corpus — `lib/apl/tests/idioms.sx` covering classic Roger Hui / Phil Last idioms
+
+## Progress log
+
+_Newest first._
+
+- _(none yet)_
+
+## Blockers
+
+- _(none yet)_

plans/common-lisp-on-sx.md

@@ -0,0 +1,124 @@
+# Common-Lisp-on-SX: conditions + restarts on delimited continuations
+
+The headline showcase is the **condition system**. Restarts are *resumable* exceptions — every other Lisp implementation reinvents this on host-stack unwind tricks. On SX restarts are textbook delimited continuations: `signal` walks the handler chain; `invoke-restart` resumes the captured continuation at the restart point. Same delcc primitive that powers Erlang actors, expressed as a different surface.
+
+End-state goal: ANSI Common Lisp subset with a working condition/restart system, CLOS multimethods (with `:before`/`:after`/`:around`), the LOOP macro, packages, and ~150 hand-written + classic programs.
+
+## Scope decisions (defaults — override by editing before we spawn)
+
+- **Syntax:** ANSI Common Lisp surface. Read tables, dispatch macros (`#'`, `#(`, `#\`, `#:`, `#x`, `#b`, `#o`, ratios `1/3`).
+- **Conformance:** ANSI X3.226 *as a target*, not bug-for-bug SBCL/CCL. "Reads like CL, runs like CL."
+- **Test corpus:** custom + a curated slice of `ansi-test`. Plus classic programs: condition-system demo, restart-driven debugger, multiple-dispatch geometry, LOOP corpus.
+- **Out of scope:** compilation to native, FFI, sockets, threads, MOP class redefinition, full pathname/logical-pathname machinery, structures with `:include` deep customization.
+- **Packages:** simple — `defpackage`/`in-package`/`export`/`use-package`/`:cl`/`:cl-user`. No nicknames, no shadowing-import edge cases.
+
+## Ground rules
+
+- **Scope:** only touch `lib/common-lisp/**` and `plans/common-lisp-on-sx.md`. Don't edit `spec/`, `hosts/`, `shared/`, or any other `lib/<lang>/**`. CL primitives go in `lib/common-lisp/runtime.sx`.
+- **SX files:** use `sx-tree` MCP tools only.
+- **Commits:** one feature per commit. Keep `## Progress log` updated and tick roadmap boxes.
+
+## Architecture sketch
+
+```
+Common Lisp source
+    │
+    ▼
+lib/common-lisp/reader.sx     — tokenizer + reader (read macros, dispatch chars)
+    │
+    ▼
+lib/common-lisp/parser.sx     — AST: forms, declarations, lambda lists
+    │
+    ▼
+lib/common-lisp/transpile.sx  — AST → SX AST (entry: cl-eval-ast)
+    │
+    ▼
+lib/common-lisp/runtime.sx    — special forms, condition system, CLOS, packages, BIFs
+```
+
+Core mapping:
+- **Symbol** = SX symbol with package prefix; package table is a flat dict.
+- **Cons cell** = SX pair via `cons`/`car`/`cdr`; lists native.
+- **Multiple values** = thread through `values`/`multiple-value-bind`; primary-value default for one-context callers.
+- **Block / return-from** = captured continuation; `return-from name v` invokes the block-named `^k`.
+- **Tagbody / go** = each tag is a continuation; `go tag` invokes it.
+- **Unwind-protect** = scope frame with a cleanup thunk fired on any non-local exit.
+- **Conditions / restarts** = layered handler chain on top of `handler-bind` + delcc. `signal` walks handlers; `invoke-restart` resumes a captured continuation.
+- **CLOS** = generic functions are dispatch tables on argument-class lists; method combination computed lazily; `call-next-method` is a continuation.
+- **Macros** = SX macros (sentinel-body) — defmacro lowers directly.
+
+## Roadmap
+
+### Phase 1 — reader + parser
+- [x] Tokenizer: symbols (with package qualification `pkg:sym` / `pkg::sym`), numbers (int, float, ratio `1/3`, `#xFF`, `#b1010`, `#o17`), strings `"…"` with `\` escapes, characters `#\Space` `#\Newline` `#\a`, comments `;`, block comments `#| … |#`
+- [x] Reader: list, dotted pair, quote `'`, function `#'`, quasiquote `` ` ``, unquote `,`, splice `,@`, vector `#(…)`, uninterned `#:foo`, nil/t literals
+- [x] Parser: lambda lists with `&optional` `&rest` `&key` `&aux` `&allow-other-keys`, defaults, supplied-p variables
+- [x] Unit tests in `lib/common-lisp/tests/read.sx`
+
+### Phase 2 — sequential eval + special forms
+- [x] `cl-eval-ast`: `quote`, `if`, `progn`, `let`, `let*`, `flet`, `labels`, `setq`, `setf` (subset), `function`, `lambda`, `the`, `locally`, `eval-when`
+- [ ] `block` + `return-from` via captured continuation
+- [ ] `tagbody` + `go` via per-tag continuations
+- [ ] `unwind-protect` cleanup frame
+- [ ] `multiple-value-bind`, `multiple-value-call`, `multiple-value-prog1`, `values`, `nth-value`
+- [x] `defun`, `defparameter`, `defvar`, `defconstant`, `declaim`, `proclaim` (no-op)
+- [ ] Dynamic variables — `defvar`/`defparameter` produce specials; `let` rebinds via parameterize-style scope
+- [x] 127 tests in `lib/common-lisp/tests/eval.sx`
+
+### Phase 3 — conditions + restarts (THE SHOWCASE)
+- [ ] `define-condition` — class hierarchy rooted at `condition`/`error`/`warning`/`simple-error`/`simple-warning`/`type-error`/`arithmetic-error`/`division-by-zero`
+- [ ] `signal`, `error`, `cerror`, `warn` — all walk the handler chain
+- [ ] `handler-bind` — non-unwinding handlers, may decline by returning normally
+- [ ] `handler-case` — unwinding handlers (delcc abort)
+- [ ] `restart-case`, `with-simple-restart`, `restart-bind`
+- [ ] `find-restart`, `invoke-restart`, `invoke-restart-interactively`, `compute-restarts`
+- [ ] `with-condition-restarts` — associate restarts with a specific condition
+- [ ] `*break-on-signals*`, `*debugger-hook*` (basic)
+- [ ] Classic programs in `lib/common-lisp/tests/programs/`:
+  - [ ] `restart-demo.lisp` — division with `:use-zero` and `:retry` restarts
+  - [ ] `parse-recover.lisp` — parser with skipped-token restart
+  - [ ] `interactive-debugger.lisp` — ASCII REPL using `:debugger-hook`
+- [ ] `lib/common-lisp/conformance.sh` + runner, `scoreboard.json` + `scoreboard.md`
+
+### Phase 4 — CLOS
+- [ ] `defclass` with `:initarg`/`:initform`/`:accessor`/`:reader`/`:writer`/`:allocation`
+- [ ] `make-instance`, `slot-value`, `(setf slot-value)`, `with-slots`, `with-accessors`
+- [ ] `defgeneric` with `:method-combination` (standard, plus `+`, `and`, `or`)
+- [ ] `defmethod` with `:before` / `:after` / `:around` qualifiers
+- [ ] `call-next-method` (continuation), `next-method-p`
+- [ ] `class-of`, `find-class`, `slot-boundp`, `change-class` (basic)
+- [ ] Multiple dispatch — method specificity by argument-class precedence list
+- [ ] Built-in classes registered for tagged values (`integer`, `float`, `string`, `symbol`, `cons`, `null`, `t`)
+- [ ] Classic programs:
+  - [ ] `geometry.lisp` — `intersect` generic dispatching on (point line), (line line), (line plane)…
+  - [ ] `mop-trace.lisp` — `:before` + `:after` printing call trace
+
+### Phase 5 — macros + LOOP + reader macros
+- [ ] `defmacro`, `macrolet`, `symbol-macrolet`, `macroexpand-1`, `macroexpand`
+- [ ] `gensym`, `gentemp`
+- [ ] `set-macro-character`, `set-dispatch-macro-character`, `get-macro-character`
+- [ ] **The LOOP macro** — iteration drivers (`for … in/across/from/upto/downto/by`, `while`, `until`, `repeat`), accumulators (`collect`, `append`, `nconc`, `count`, `sum`, `maximize`, `minimize`), conditional clauses (`if`/`when`/`unless`/`else`), termination (`finally`/`thereis`/`always`/`never`), `named` blocks
+- [ ] LOOP test corpus: 30+ tests covering all clause types
+
+### Phase 6 — packages + stdlib drive
+- [ ] `defpackage`, `in-package`, `export`, `use-package`, `import`, `find-package`
+- [ ] Package qualification at the reader level — `cl:car`, `mypkg::internal`
+- [ ] `:common-lisp` (`:cl`) and `:common-lisp-user` (`:cl-user`) packages
+- [ ] Sequence functions — `mapcar`, `mapc`, `mapcan`, `reduce`, `find`, `find-if`, `position`, `count`, `every`, `some`, `notany`, `notevery`, `remove`, `remove-if`, `subst`
+- [ ] List ops — `assoc`, `getf`, `nth`, `last`, `butlast`, `nthcdr`, `tailp`, `ldiff`
+- [ ] String ops — `string=`, `string-upcase`, `string-downcase`, `subseq`, `concatenate`
+- [ ] FORMAT — basic directives `~A`, `~S`, `~D`, `~F`, `~%`, `~&`, `~T`, `~{...~}` (iteration), `~[...~]` (conditional), `~^` (escape), `~P` (plural)
+- [ ] Drive corpus to 200+ green
+
+## Progress log
+
+_Newest first._
+
+- 2026-04-25: Phase 2 eval — 127 tests, 299 total green. `lib/common-lisp/eval.sx`: cl-eval-ast with quote/if/progn/let/let*/flet/labels/setq/setf/function/lambda/the/locally/eval-when; defun/defvar/defparameter/defconstant; built-in arithmetic (+/-/*//, min/max/abs/evenp/oddp), comparisons, predicates, list ops (car/cdr/cons/list/append/reverse/length/nth/first/second/third/rest), string ops, funcall/apply/mapcar. Key gotchas: SX reduce is (reduce fn init list) not (reduce fn list init); CL true literal is t not true; builtins registered in cl-global-env.fns via wrapper dicts for #' syntax.
+- 2026-04-25: Phase 1 lambda-list parser — 31 new tests, 172 total green. `cl-parse-lambda-list` in `parser.sx` + `tests/lambda.sx`. Handles &optional/&rest/&body/&key/&aux/&allow-other-keys, defaults, supplied-p. Key gotchas: `(when (> (len items) 0) ...)` not `(when items ...)` (empty list is truthy); custom `cl-deep=` needed for dict/list structural equality in tests.
+- 2026-04-25: Phase 1 reader/parser — 62 new tests, 141 total green. `lib/common-lisp/parser.sx`: cl-read/cl-read-all, lists, dotted pairs, quote/backquote/unquote/splice/#', vectors, #:uninterned, NIL→nil, T→true, reader macro wrappers.
+- 2026-04-25: Phase 1 tokenizer — 79 tests green. `lib/common-lisp/reader.sx` + `tests/read.sx` + `test.sh`. Handles symbols (pkg:sym, pkg::sym), integers, floats, ratios, hex/binary/octal, strings, #\ chars, reader macros (#' #( #: ,@), line/block comments. Key gotcha: SX `str` for string concat (not `concat`), substring-based read-while.
+
+## Blockers
+
+- _(none yet)_

plans/hs-blockers-drain.md

@@ -0,0 +1,96 @@
+# HS conformance — blockers drain
+
+Goal: take hyperscript conformance from **1277/1496 (85.4%)** to **1496/1496 (100%)** by clearing the blocked clusters and the design-done Bucket E subsystems.
+
+This plan exists because the per-iteration `loops/hs` agent can't fit these into its 30-min budget — they need dedicated multi-commit sit-downs. Track progress here; refer to `plans/hs-conformance-to-100.md` for the canonical cluster ledger.
+
+## Current state (2026-04-25)
+
+- Loop running in `/root/rose-ash-loops/hs` (branch `loops/hs`)
+- sx-tree MCP **fixed** (was a session-stale binary issue — restart of claude in the tmux window picked it up). Loop hinted to retry **#32**, **#29** first.
+- Recent loop progress: ~1 commit/6h — easy wins drained, what's left needs focused attention.
+
+## Remaining work
+
+### Bucket-A/B/C blockers (small, in-place fixes)
+
+| # | Cluster | Tests | Effort | Blocker | Fix sketch |
+|---|---------|------:|--------|---------|------------|
+| **17** | `tell` semantics | +3 | ~1h | Implicit-default-target ambiguity. `bare add .bar` inside `tell X` should target `X` but explicit `to me` must reach the original element. | Add `beingTold` symbol distinct from `me`; bare commands compile to `beingTold-or-me`; explicit `me` always the original. |
+| **22** | window global fn fallback | +2-4 | ~1h | `foo()` where `foo` isn't SX-defined needs to fall back to `(host-global "foo")`. Three attempts failed: guard (host-level error not catchable), `env-has?` (not in HS kernel), `hs-win-call` (NativeFn not callable from CALL). | Add `symbol-bound?` predicate to HS kernel **OR** a host-call-fn primitive with arity-agnostic dispatch. |
+| **29** | `hyperscript:before:init` / `:after:init` / `:parse-error` events | +4-6 | ~30m (post sx-tree fix) | Was sx-tree MCP outage. Now unblocked — loop should retry. 4 of 6 tests need stricter parser error-rejection (out of scope; mark partial). | Edit `integration.sx` to fire DOM events at activation boundaries. |
+
+### Bucket D — medium features
+
+| # | Cluster | Tests | Effort | Status |
+|---|---------|------:|--------|--------|
+| **31** | runtime null-safety error reporting | **+15-18** | **2-4h** | **THIS SESSION'S TARGET.** Plan node fully spec'd: 5 pieces of work. |
+| **32** | MutationObserver mock + `on mutation` | +10-15 | ~2h | Was sx-tree-blocked. Now unblocked — loop hinted to retry. Multi-file: parser, compiler, runtime, runner mock, generator skip-list. |
+| **33** | cookie API | +2 (remaining) | ~30m | Partial done (+3). Remaining 2 need `hs-method-call` runtime fallback for unknown methods + `hs-for-each` recognising host-array/proxy collections. |
+| 34 | event modifier DSL | +6-8 | ~1-2h | `elsewhere`, `every`, count filters (`once`/`twice`/`3 times`/ranges), `from elsewhere`. Pending. |
+| 35 | namespaced `def` | +3 | ~30m | Pending. |
+
+### Bucket E — subsystems (design docs landed, multi-commit each)
+
+Each has a design doc with a step-by-step checklist. These are 1-2 days of focused work each, not loop-fits.
+
+| # | Subsystem | Tests | Design doc | Branch |
+|---|-----------|------:|------------|--------|
+| 36 | WebSocket + `socket` + RPC Proxy | +12-16 | `plans/designs/e36-websocket.md` | `worktree-agent-a9daf73703f520257` |
+| 37 | Tokenizer-as-API | +16-17 | `plans/designs/e37-tokenizer-api.md` | `worktree-agent-a6bb61d59cc0be8b4` |
+| 38 | SourceInfo API | +4 | `plans/designs/e38-sourceinfo.md` | `agent-e38-sourceinfo` |
+| 39 | WebWorker plugin (parser-only stub) | +1 | `plans/designs/e39-webworker.md` | `hs-design-e39-webworker` |
+| 40 | Real Fetch / non-2xx / before-fetch | +7 | `plans/designs/e40-real-fetch.md` | `worktree-agent-a94612a4283eaa5e0` |
+
+### Bucket F — generator translation gaps
+
+~25 tests SKIP'd because `tests/playwright/generate-sx-tests.py` bails with `return None`. Single dedicated generator-repair sit-down once Bucket D is drained. ~half-day.
+
+## Order of attack
+
+In approximate cost-per-test order:
+
+1. **Loop self-heal** (no human work) — wait for #29, #32 to land via the running loop ⏱️ ~next 1-2 hours
+2. **#31 null-safety** — biggest scoped single win, dedicated worktree agent (this session)
+3. **#33 cookie API remainder** — quick partial completion
+4. **#17 / #22 / #34 / #35** — small fiddly fixes, one sit-down each
+5. **Bucket E** — pick one subsystem at a time. **#39 (WebWorker stub) first** — single commit, smallest. Then **#38 (SourceInfo)** — 4 commits. Then the bigger three (#36, #37, #40).
+6. **Bucket F** — generator repair sweep at the end.
+
+Estimated total to 100%: ~10-15 days of focused work, parallelisable across branches.
+
+## Cluster #31 spec (full detail)
+
+The plan note from `hs-conformance-to-100.md`:
+
+> 18 tests in `runtimeErrors`. When accessing `.foo` on nil, emit a structured error with position info. One coordinated fix in the compiler emit paths for property access, function calls, set/put.
+
+**Required pieces:**
+
+1. **Generator-side `eval-hs-error` helper + recognizer** for `expect(await error("HS")).toBe("MSG")` blocks. In `tests/playwright/generate-sx-tests.py`.
+2. **Runtime helpers** in `lib/hyperscript/runtime.sx`:
+   - `hs-null-error!` raising `'<sel>' is null`
+   - `hs-named-target` — wraps a query result with the original selector source
+   - `hs-named-target-list` — same for list results
+3. **Compiler patches at every target-position `(query SEL)` emit** — wrap in named-target carrying the original selector source. ~17 command emit paths in `lib/hyperscript/compiler.sx`:
+   add, remove, hide, show, measure, settle, trigger, send, set, default, increment, decrement, put, toggle, transition, append, take.
+4. **Function-call null-check** at bare `(name)`, `hs-method-call`, and `host-get` chains, deriving the leftmost-uncalled-name (`'x'` / `'x.y'`) from the parse tree.
+5. **Possessive-base null-check** (`set x's y to true` → `'x' is null`).
+
+**Files in scope:**
+- `lib/hyperscript/runtime.sx` (new helpers)
+- `lib/hyperscript/compiler.sx` (~17 emit-path edits)
+- `tests/playwright/generate-sx-tests.py` (test recognizer)
+- `tests/hs-run-filtered.js` (if mock helpers needed)
+- `shared/static/wasm/sx/hs-runtime.sx` + `hs-compiler.sx` (WASM staging copies)
+
+**Approach:** target-named pieces incrementally — runtime helpers first (no compiler change), then compiler emit paths in batches (group similar commands), then function-call/possessive at the end. Each batch is one commit if it lands +N tests; mark partial if it only unlocks part.
+
+**Watch for:** smoke-range regressions (tests flipping pass→fail). Each commit: rerun smoke 0-195 and the `runtimeErrors` suite.
+
+## Notes for future sessions
+
+- `plans/hs-conformance-to-100.md` is the canonical cluster ledger — update it on every commit.
+- `plans/hs-conformance-scoreboard.md` is the live tally — bump `Merged:` and the bucket roll-up.
+- Loop has scope rule "never edit `spec/evaluator.sx` or broader SX kernel" — most fixes here stay in `lib/hyperscript/**`, `tests/`, generator. If a fix needs kernel work, surface to the user; don't merge silently.
+- Cluster #22's `symbol-bound?` predicate would be a kernel addition — that's a real cross-boundary scope expansion.

plans/prolog-on-sx.md

@@ -39,91 +39,59 @@ Representation choices (finalise in phase 1, document here):
 ## Roadmap
 
 ### Phase 1 — tokenizer + term parser (no operator table)
-- [x] Tokenizer: atoms (lowercase/quoted), variables (uppercase/`_`), numbers, strings, punct `( ) , . [ ] | ! :-`, comments (`%`, `/* */`)
+- [ ] Tokenizer: atoms (lowercase/quoted), variables (uppercase/`_`), numbers, strings, punct `( ) , . [ ] | ! :-`, comments (`%`, `/* */`)
-- [x] Parser: clauses `head :- body.` and facts `head.`; terms `atom | Var | number | compound(args) | [list,sugar]`
+- [ ] Parser: clauses `head :- body.` and facts `head.`; terms `atom | Var | number | compound(args) | [list,sugar]`
-- [x] **Skip for phase 1:** operator table. `X is Y + 1` must be written `is(X, '+'(Y, 1))`; `=` written `=(X, Y)`. Operators land in phase 4.
+- [ ] **Skip for phase 1:** operator table. `X is Y + 1` must be written `is(X, '+'(Y, 1))`; `=` written `=(X, Y)`. Operators land in phase 4.
-- [x] Unit tests in `lib/prolog/tests/parse.sx` — 25 pass
+- [ ] Unit tests in `lib/prolog/tests/parse.sx`
 
 ### Phase 2 — unification + trail
-- [x] `make-var`, `walk` (follow binding chain), `prolog-unify!` (terms + trail → bool), `trail-undo-to!`
+- [ ] `make-var`, `walk` (follow binding chain), `prolog-unify!` (terms + trail → bool), `trail-undo-to!`
-- [x] Occurs-check off by default, exposed as flag
+- [ ] Occurs-check off by default, exposed as flag
-- [x] 30+ unification tests in `lib/prolog/tests/unify.sx`: atoms, vars, compounds, lists, cyclic (no-occurs-check), mutual occurs — 47 pass
+- [ ] 30+ unification tests in `lib/prolog/tests/unify.sx`: atoms, vars, compounds, lists, cyclic (no-occurs-check), mutual occurs
 
 ### Phase 3 — clause DB + DFS solver + cut + first classic programs
-- [x] Clause DB: `"functor/arity" → list-of-clauses`, loader inserts — `pl-mk-db` / `pl-db-add!` / `pl-db-load!` / `pl-db-lookup` / `pl-db-lookup-goal`, 14 tests in `tests/clausedb.sx`
+- [ ] Clause DB: `"functor/arity" → list-of-clauses`, loader inserts
-- [x] Solver: DFS with choice points backed by delimited continuations (`lib/callcc.sx`). On goal entry, capture; per matching clause, unify head + recurse body; on failure, undo trail, try next — first cut: trail-based undo + CPS k (no shift/reset yet, per briefing gotcha). Built-ins so far: `true/0`, `fail/0`, `=/2`, `,/2`. Refactor to delimited conts later.
+- [ ] Solver: DFS with choice points backed by delimited continuations (`lib/callcc.sx`). On goal entry, capture; per matching clause, unify head + recurse body; on failure, undo trail, try next
-- [x] Cut (`!`): cut barrier at current choice-point frame; collapse all up to barrier — two-cut-box scheme: each `pl-solve-user!` creates a fresh inner-cut-box (set by `!` in this predicate's body) AND snapshots the outer-cut-box state on entry. After body fails, abandon clause alternatives if (a) inner was set or (b) outer transitioned false→true during this call. Lets post-cut goals backtrack normally while blocking pre-cut alternatives. 6 cut tests cover bare cut, clause-commit, choice-commit, cut+fail, post-cut backtracking, nested-cut isolation.
+- [ ] Cut (`!`): cut barrier at current choice-point frame; collapse all up to barrier
-- [x] Built-ins: `=/2`, `\\=/2`, `true/0`, `fail/0`, `!/0`, `,/2`, `;/2`, `->/2` inside `;`, `call/1`, `write/1`, `nl/0` — all 11 done. `write/1` and `nl/0` use a global `pl-output-buffer` string + `pl-output-clear!` for testability; `pl-format-term` walks deep then renders atoms/nums/strs/compounds/vars (var → `_<id>`). Note: cut-transparency via `;` not testable yet without operator support — `;(,(a,!), b)` parser-rejects because `,` is body-operator-only; revisit in phase 4.
+- [ ] Built-ins: `=/2`, `\\=/2`, `true/0`, `fail/0`, `!/0`, `,/2`, `;/2`, `->/2` inside `;`, `call/1`, `write/1`, `nl/0`
-- [x] Arithmetic `is/2` with `+ - * / mod abs` — `pl-eval-arith` walks deep, recurses on compounds, dispatches on functor; binary `+ - * / mod`, binary AND unary `-`, unary `abs`. `is/2` evaluates RHS, wraps as `("num" v)`, unifies via `pl-solve-eq!`. 11 tests cover each op + nested + ground LHS match/mismatch + bound-var-on-RHS chain.
+- [ ] Arithmetic `is/2` with `+ - * / mod abs`
-- [x] Classic programs in `lib/prolog/tests/programs/`:
+- [ ] Classic programs in `lib/prolog/tests/programs/`:
-  - [x] `append.pl` — list append (with backtracking) — `lib/prolog/tests/programs/append.{pl,sx}`. 6 tests cover: build (`append([], L, X)`, `append([1,2], [3,4], X)`), check ground match/mismatch, full split-backtracking (`append(X, Y, [1,2,3])` → 4 solutions), single-deduce (`append(X, [3], [1,2,3])` → X=[1,2]).
+  - [ ] `append.pl` — list append (with backtracking)
-  - [x] `reverse.pl` — naive reverse — `lib/prolog/tests/programs/reverse.{pl,sx}`. Naive reverse via append: `reverse([H|T], R) :- reverse(T, RT), append(RT, [H], R)`. 6 tests cover empty, singleton, 3-list, 4-atom-list, ground match, ground mismatch.
+  - [ ] `reverse.pl` — naive reverse
-  - [x] `member.pl` — generate all solutions via backtracking — `lib/prolog/tests/programs/member.{pl,sx}`. Classic 2-clause `member(X, [X|_])` + `member(X, [_|T]) :- member(X, T)`. 7 tests cover bound-element hit/miss, empty list, generator (count = list length), first-solution binding, duplicate matches counted twice, anonymous head-cell unification.
+  - [ ] `member.pl` — generate all solutions via backtracking
-  - [x] `nqueens.pl` — 8-queens — `lib/prolog/tests/programs/nqueens.{pl,sx}`. Permute-and-test formulation: `queens(L, Qs) :- permute(L, Qs), safe(Qs)` + `select` + `safe` + `no_attack`. Tested at N=1 (1), N=2 (0), N=3 (0), N=4 (2), N=5 (10) plus first-solution check at N=4 = `[2, 4, 1, 3]`. N=8 omitted — interpreter is too slow (40320 perms); add once compiled clauses or constraint-style placement land. `range/3` skipped pending arithmetic-comparison built-ins (`>/2` etc.).
+  - [ ] `nqueens.pl` — 8-queens
-  - [x] `family.pl` — facts + rules (parent/ancestor) — `lib/prolog/tests/programs/family.{pl,sx}`. 5 parent facts + male/female + derived `father`/`mother`/`ancestor`/`sibling`. 10 tests cover direct facts, fact count, transitive ancestor through 3 generations, descendant counting, gender-restricted father/mother, sibling via shared parent + `\=`.
+  - [ ] `family.pl` — facts + rules (parent/ancestor)
-- [x] `lib/prolog/conformance.sh` + runner, `scoreboard.json` + `scoreboard.md` — bash script feeds load + eval epoch script to sx_server, parses each suite's `{:failed N :passed N :total N :failures (...)}` line, writes JSON (machine) + MD (human) scoreboards. Exit non-zero on any failure. `SX_SERVER` env var overrides binary path. First scoreboard: 183 / 183.
+- [ ] `lib/prolog/conformance.sh` + runner, `scoreboard.json` + `scoreboard.md`
-- [x] Target: all 5 classic programs passing — append (6) + reverse (6) + member (7) + nqueens (6) + family (10) = 35 program tests, all green. Phase 3 architecturally complete bar the conformance harness/scoreboard.
+- [ ] Target: all 5 classic programs passing
 
 ### Phase 4 — operator table + more built-ins (next run)
-- [x] Operator table parsing (prefix/infix/postfix, precedence, assoc) — `pl-op-table` (15 entries: `, ; -> = \= is < > =< >= + - * / mod`); precedence-climbing parser via `pp-parse-primary` + `pp-parse-term-prec` + `pp-parse-op-rhs`. Parens override precedence. Args inside compounds parsed at 999 so `,` stays as separator. xfx/xfy/yfx supported; prefix/postfix deferred (so `-5` still tokenises as bare atom + num as before). Comparison built-ins `</2 >/2 =</2 >=/2` added. New `tests/operators.sx` 19 tests cover assoc/precedence/parens + solver via infix.
+- [ ] Operator table parsing (prefix/infix/postfix, precedence, assoc)
-- [x] `assert/1`, `asserta/1`, `assertz/1`, `retract/1` — `assert` aliases `assertz`. Helpers `pl-rt-to-ast` (deep-walk + replace runtime vars with `_G<id>` parse markers) + `pl-build-clause` (detect `:-` head). `assertz` uses `pl-db-add!`; `asserta` uses new `pl-db-prepend!`. `retract` walks goal, looks up by functor/arity, tries each clause via unification, removes first match by index (`pl-list-without`). 11 tests in `tests/dynamic.sx`. Rule-asserts now work — `:-` added to op table (prec 1200 xfx) with fix to `pl-token-op` accepting `"op"` token type. 15 tests in `tests/assert_rules.sx`.
+- [ ] `assert/1`, `asserta/1`, `assertz/1`, `retract/1`
-- [x] `findall/3`, `bagof/3`, `setof/3` — shared `pl-collect-solutions` runs the goal in a fresh cut-box, deep-copies the template (via `pl-deep-copy` with var-map for shared-var preservation) on each success, returns false to backtrack, then restores trail. `findall` always succeeds with a (possibly empty) list. `bagof` fails on empty. `setof` builds a string-keyed dict via `pl-format-term` for sort+dedupe (via `keys` + `sort`), fails on empty. Existential `^` deferred (operator). 11 tests in `tests/findall.sx`.
+- [ ] `findall/3`, `bagof/3`, `setof/3`
-- [x] `copy_term/2`, `functor/3`, `arg/3`, `=../2` — `copy_term/2` reuses `pl-deep-copy` with a fresh var-map (preserves source aliasing). `functor/3` handles 4 modes: compound→{name, arity}, atom→{atom, 0}, num→{num, 0}, var with ground name+arity→constructed term (`pl-make-fresh-args` for compound case). `arg/3` extracts 1-indexed arg from compound. **`=../2` deferred** — the tokenizer treats `.` as the clause terminator unconditionally, so `=..` lexes as `=` + `.` + `.`; needs special-case lex (or surface syntax via a different name). 14 tests in `tests/term_inspect.sx`.
+- [ ] `copy_term/2`, `functor/3`, `arg/3`, `=../2`
-- [x] String/atom predicates
+- [ ] String/atom predicates
 
 ### Phase 5 — Hyperscript integration
-- [x] `prolog-query` primitive callable from SX/Hyperscript
+- [ ] `prolog-query` primitive callable from SX/Hyperscript
-- [ ] Hyperscript DSL: `when allowed(user, :edit) then …` ← **blocked** (needs `lib/hyperscript/**`, out of scope)
+- [ ] Hyperscript DSL: `when allowed(user, :edit) then …`
 - [ ] Integration suite
 
 ### Phase 6 — ISO conformance
-- [x] Vendor Hirst's conformance tests
+- [ ] Vendor Hirst's conformance tests
-- [x] Drive scoreboard to 200+
+- [ ] Drive scoreboard to 200+
 
 ### Phase 7 — compiler (later, optional)
-- [x] Compile clauses to SX continuations for speed
+- [ ] Compile clauses to SX continuations for speed
-- [x] Keep interpreter as the reference
+- [ ] Keep interpreter as the reference
 
 ## Progress log
 
 _Newest first. Agent appends on every commit._
 
-- 2026-04-25 — `pl-compiled-matches-interp?` cross-validator in `compiler.sx`: loads source into both a plain and a compiled DB, runs the same goal, returns true iff solution counts match. `tests/cross_validate.sx` applies this to 17 goals across append/member/ancestor/cut/arithmetic/if-then-else, locking the interpreter as the reference against which any future compiler change must agree. Total **551** (+17).
-- 2026-04-25 — Clause compiler (`lib/prolog/compiler.sx`): `pl-compile-clause` converts parse-AST clauses to SX closures `(fn (goal trail db cut-box k) bool)`. Pre-collects var names at compile time; `pl-cmp-build-term` reconstructs fresh runtime terms per call. `pl-compile-db!` compiles all clauses in a DB and stores them in `:compiled` table. `pl-solve-user!` in runtime.sx auto-dispatches to compiled lambdas when present, falls back to interpreted. `pl-try-compiled-clauses!` mirrors `pl-try-clauses!` cut semantics. 17 tests in `tests/compiler.sx`. Total **534** (+17).
-- 2026-04-25 — `predsort/3` (insertion-sort with 3-arg comparator predicate, deduplicates `=` pairs), `term_variables/2` (collect unbound vars left-to-right, dedup by id), arithmetic extensions (`floor/1`, `ceiling/1`, `truncate/1`, `round/1`, `sign/1`, `sqrt/1`, `pow/2`, `**/2`, `^/2`, `integer/1`, `float/1`, `float_integer_part/1`, `float_fractional_part/1`). 21 tests in `tests/advanced.sx`. Total **517** (+21).
-- 2026-04-25 — `sub_atom/5` (non-deterministic substring enumeration; CPS loop over all (start,sublen) pairs; trail-undo only on backtrack) + `aggregate_all/3` (6 templates: count/bag/sum/max/min/set; uses `pl-collect-solutions`). 25 tests in `tests/string_agg.sx`. Total **496** (+25).
-- 2026-04-25 — `:-` operator + assert with rules: added `(list ":-" 1200 "xfx")` to `pl-op-table`; fixed `pl-token-op` to accept `"op"` token type (tokenizer emits `:-` as `"op"`, not `"atom"`). `pl-build-clause` already handled `("compound" ":-" ...)`. `assert((head :- body))` now works for facts+rules. 15 tests in `tests/assert_rules.sx`. Total **471** (+15).
-- 2026-04-25 — IO/term predicates: `term_to_atom/2` (bidirectional: format term or parse atom), `term_string/2` (alias), `with_output_to/2` (atom/string sinks — saves/restores `pl-output-buffer`), `writeln/1`, `format/1` (~n/~t/~~), `format/2` (~w/~a/~d pull from arg list). 24 tests in `tests/io_predicates.sx`. Total **456** (+24).
-- 2026-04-25 — Char predicates: `char_type/2` (9 modes: alpha/alnum/digit/digit(N)/space/white/upper(L)/lower(U)/ascii(C)/punct), `upcase_atom/2`, `downcase_atom/2`, `string_upper/2`, `string_lower/2`. 10 helpers using `char-code`/`char-from-code` SX primitives. 27 tests in `tests/char_predicates.sx`. Total **432** (+27).
-- 2026-04-25 — Set/fold predicates: `foldl/4` (CPS fold-left, threads accumulator via `pl-apply-goal`), `list_to_set/2` (dedup preserving first-occurrence), `intersection/3`, `subtract/3`, `union/3` (all via `pl-struct-eq?`). 3 new helpers, 15 tests in `tests/set_predicates.sx`. Total **405** (+15).
-- 2026-04-25 — Meta-call predicates: `forall/2` (negation-of-counterexample), `maplist/2` (goal over list), `maplist/3` (map goal building output list), `include/3` (filter by goal success), `exclude/3` (filter by goal failure). New `pl-apply-goal` helper extends a goal with extra args. 15 tests in `tests/meta_call.sx`. Total **390** (+15).
-- 2026-04-25 — List/utility predicates: `==/2`, `\==/2` (structural equality/inequality via `pl-struct-eq?`), `flatten/2` (deep Prolog-list flatten), `numlist/3` (integer range list), `atomic_list_concat/2` (join with no sep), `atomic_list_concat/3` (join with separator), `sum_list/2`, `max_list/2`, `min_list/2` (arithmetic folds), `delete/3` (remove all struct-equal elements). 7 new helpers, 33 tests in `tests/list_predicates.sx`. Total **375** (+33).
-- 2026-04-25 — Meta/logic predicates: `\+/1` (negation-as-failure, trail-undo on success), `not/1` (alias), `once/1` (commit to first solution via if-then-else), `ignore/1` (always succeed), `ground/1` (all vars bound), `sort/2` (sort + dedup by formatted key), `msort/2` (sort, keep dups), `atom_number/2` (bidirectional), `number_string/2` (bidirectional). 2 helpers (`pl-ground?`, `pl-sort-pairs-dedup`). 25 tests in `tests/meta_predicates.sx`. Total **342** (+25).
-- 2026-04-25 — ISO utility predicates batch: `succ/2` (bidirectional), `plus/3` (3-mode bidirectional), `between/3` (backtracking range generator), `length/2` (bidirectional list length + var-list constructor), `last/2`, `nth0/3`, `nth1/3`, `max/2` + `min/2` in arithmetic eval. 6 new helper functions (`pl-list-length`, `pl-make-list-of-vars`, `pl-between-loop!`, `pl-solve-between!`, `pl-solve-last!`, `pl-solve-nth0!`). 29 tests in `tests/iso_predicates.sx`. Phase 6 complete: scoreboard already at 317, far above 200+ target. Hyperscript DSL blocked (needs `lib/hyperscript/**`). Total **317** (+29).
-- 2026-04-25 — `prolog-query` SX API (`lib/prolog/query.sx`). New public API layer: `pl-load source-str → db`, `pl-query-all db query-str → list of solution dicts`, `pl-query-one db query-str → dict or nil`, `pl-query src query → list` (convenience). Each solution dict maps variable name strings to their formatted term strings. Var names extracted from pre-instantiation parse AST. Trail is marked before solve and reset after to ensure clean state. 16 tests in `tests/query_api.sx` cover fact lookup, no-solution, boolean queries, multi-var, recursive rules, is/2 built-in, query-one, convenience form. Total **288** (+16).
-- 2026-04-25 — String/atom predicates. Type-test predicates: `var/1`, `nonvar/1`, `atom/1`, `number/1`, `integer/1`, `float/1` (always-fail), `compound/1`, `callable/1`, `atomic/1`, `is_list/1`. String/atom operations: `atom_length/2`, `atom_concat/3` (3 modes: both-ground, result+first, result+second), `atom_chars/2` (bidirectional), `atom_codes/2` (bidirectional), `char_code/2` (bidirectional), `number_codes/2`, `number_chars/2`. 7 helper functions in runtime.sx (`pl-list-to-prolog`, `pl-proper-list?`, `pl-prolog-list-to-sx`, `pl-solve-atom-concat!`, `pl-solve-atom-chars!`, `pl-solve-atom-codes!`, `pl-solve-char-code!`). 34 tests in `tests/atoms.sx`. Total **272** (+34).
-- 2026-04-25 — `copy_term/2` + `functor/3` + `arg/3` (term inspection). `copy_term` is a one-line dispatch to existing `pl-deep-copy`. `functor/3` is bidirectional — decomposes a bound compound/atom/num into name+arity OR constructs from ground name+arity (atom+positive-arity → compound with N anonymous fresh args via `pl-make-fresh-args`; arity 0 → atom/num). `arg/3` extracts 1-indexed arg with bounds-fail. New helper `pl-solve-eq2!` for paired-unification with shared trail-undo. 14 tests in `tests/term_inspect.sx`. Total **238** (+14). `=..` deferred — `.` always tokenizes as clause terminator; needs special lexer case.
-- 2026-04-25 — `findall/3` + `bagof/3` + `setof/3`. Shared collector `pl-collect-solutions` runs the goal in a fresh cut-box, deep-copies the template per success (`pl-deep-copy` walks term, allocates fresh runtime vars via shared var-map so co-occurrences keep aliasing), returns false to keep backtracking, then `pl-trail-undo-to!` to clean up. `findall` always builds a list. `bagof` fails on empty. `setof` uses a `pl-format-term`-keyed dict + SX `sort` for dedupe + ordering. New `tests/findall.sx` 11 tests. Total **224** (+11). Existential `^` deferred — needs operator.
-- 2026-04-25 — Dynamic clauses: `assert/1`, `assertz/1`, `asserta/1`, `retract/1`. New helpers `pl-rt-to-ast` (deep-walk runtime term → parse-AST, mapping unbound runtime vars to `_G<id>` markers so `pl-instantiate-fresh` produces fresh vars per call) + `pl-build-clause` + `pl-db-prepend!` + `pl-list-without`. `retract` keeps runtime vars (so the caller's vars get bound), walks head for the functor/arity key, tries each stored clause via `pl-unify!`, removes the first match by index. 11 tests in `tests/dynamic.sx`; conformance script gained dynamic row. Total **213** (+11). Rule-form asserts (`(H :- B)`) deferred until `:-` is in the op table.
-- 2026-04-25 — Phase 4 starts: operator-table parsing. Parser rewrite uses precedence climbing (xfx/xfy/yfx); 15-op table covers control (`, ; ->`), comparison (`= \\= is < > =< >=`), arithmetic (`+ - * / mod`). Parens override. Backwards-compatible: prefix-syntax compounds (`=(X, Y)`, `+(2, 3)`) still parse as before; existing 183 tests untouched. Added comparison built-ins `</2 >/2 =</2 >=/2` to runtime (eval both sides, compare). New `tests/operators.sx` 19 tests; conformance script gained an operators row. Total **202** (+19). Prefix/postfix deferred — `-5` keeps old bare-atom semantics.
-- 2026-04-25 — Conformance harness landed. `lib/prolog/conformance.sh` runs all 9 suites in one sx_server epoch, parses the `{:failed/:passed/:total/:failures}` summary lines, and writes `scoreboard.json` + `scoreboard.md`. `SX_SERVER` env var overrides the binary path; default points at the main-repo build. Phase 3 fully complete: 183 / 183 passing across parse/unify/clausedb/solve/append/reverse/member/nqueens/family.
-- 2026-04-25 — `family.pl` fifth classic program — completes the 5-program target. 5-fact pedigree + male/female + derived father/mother/ancestor/sibling. 10 tests cover fact lookup + count, transitive ancestor through 3 generations, descendant counting (5), gender-restricted derivations, sibling via shared parent guarded by `\=`. Total 183 (+10). All 5 classic programs ticked; Phase 3 needs only conformance harness + scoreboard left.
-- 2026-04-25 — `nqueens.pl` fourth classic program. Permute-and-test variant exercises every Phase-3 feature: lists with `[H|T]` cons sugar, multi-clause backtracking, recursive `permute`/`select`/`safe`/`no_attack`, `is/2` arithmetic on diagonals, `\=/2` for diagonal-conflict check. 6 tests at N ∈ {1,2,3,4,5} with expected counts {1,0,0,2,10} + first-solution `[2,4,1,3]`. N=5 takes ~30s (120 perms × safe-check); N=8 omitted as it would be ~thousands of seconds. Total 173 (+6).
-- 2026-04-25 — `member.pl` third classic program. Standard 2-clause definition; 7 tests cover bound-element hit/miss, empty-list fail, generator-count = list length, first-solution binding (X=11), duplicate elements matched twice on backtrack, anonymous-head unification (`member(a, [X, b, c])` binds X=a). Total 167 (+7).
-- 2026-04-25 — `reverse.pl` second classic program. Naive reverse defined via append. 6 tests (empty/singleton/3-list/4-atom-list/ground match/ground mismatch). Confirms the solver handles non-trivial recursive composition: `reverse([1,2,3], R)` recurses to depth 3 then unwinds via 3 nested `append`s. Total 160 (+6).
-- 2026-04-25 — `append.pl` first classic program. `lib/prolog/tests/programs/append.pl` is the canonical 2-clause source; `append.sx` embeds the source as a string (no file-read primitive in SX yet) and runs 6 tests covering build, check, full split-backtrack (4 solutions), and deduction modes. Helpers `pl-ap-list-to-sx` / `pl-ap-term-to-sx` convert deep-walked Prolog lists (`("compound" "." (h t))` / `("atom" "[]")`) to SX lists for structural assertion. Total 154 (+6).
-- 2026-04-25 — `is/2` arithmetic landed. `pl-eval-arith` recursively evaluates ground RHS expressions (binary `+ - * /`, `mod`; binary+unary `-`; unary `abs`); `is/2` wraps the value as `("num" v)` and unifies via `pl-solve-eq!`, so it works in all three modes — bind unbound LHS, check ground LHS for equality, propagate from earlier var bindings on RHS. 11 tests, total 148 (+11). Without operator support, expressions must be written prefix: `is(X, +(2, *(3, 4)))`.
-- 2026-04-25 — `write/1` + `nl/0` landed using global string buffer (`pl-output-buffer` + `pl-output-clear!` + `pl-output-write!`). `pl-format-term` walks deep + dispatches on atom/num/str/compound/var; `pl-format-args` recursively comma-joins. 7 new tests cover atom/num/compound formatting, conjunction order, var-walk, and `nl`. Built-ins box (`=/2`, `\\=/2`, `true/0`, `fail/0`, `!/0`, `,/2`, `;/2`, `->/2`, `call/1`, `write/1`, `nl/0`) now ticked. Total 137 (+7).
-- 2026-04-25 — `->/2` if-then-else landed (both `;(->(C,T), E)` and standalone `->(C, T)` ≡ `(C -> T ; fail)`). `pl-solve-or!` now special-cases `->` in left arg → `pl-solve-if-then-else!`. Cond runs in a fresh local cut-box (ISO opacity for cut inside cond). Then-branch can backtrack, else-branch can backtrack, but cond commits to first solution. 9 new tests covering both forms, both branches, binding visibility, cond-commit, then-backtrack, else-backtrack. Total 130 (+9).
-- 2026-04-25 — Built-ins `\=/2`, `;/2`, `call/1` landed. `pl-solve-not-eq!` (try unify, always undo, succeed iff unify failed). `pl-solve-or!` (try left, on failure check cut and only try right if not cut). `call/1` opens a fresh inner cut-box (ISO opacity: cut inside `call(G)` commits G, not caller). 11 new tests in `tests/solve.sx` cover atoms+vars for `\=`, both branches + count for `;`, and `call/1` against atoms / compounds / bound goal vars. Total 121 (+11). Box not yet ticked — `->/2`, `write/1`, `nl/0` still pending.
-- 2026-04-25 — Cut (`!/0`) landed. `pl-cut?` predicate; solver functions all take a `cut-box`; `pl-solve-user!` creates a fresh inner-cut-box and snapshots `outer-was-cut`; `pl-try-clauses!` abandons alternatives when inner.cut OR (outer.cut transitioned false→true during this call). 6 new cut tests in `tests/solve.sx` covering bare cut, clause-commit, choice-commit, cut+fail blocks alt clauses, post-cut goal backtracks freely, inner cut isolation. Total 110 (+6).
-- 2026-04-25 — Phase 3 DFS solver landed (CPS, trail-based backtracking; delimited conts deferred). `pl-solve!` + `pl-solve-eq!` + `pl-solve-user!` + `pl-try-clauses!` + `pl-solve-once!` + `pl-solve-count!` in runtime.sx. Built-ins: `true/0`, `fail/0`, `=/2`, `,/2`. New `tests/solve.sx` 18/18 green covers atomic goals, =, conjunction, fact lookup, multi-solution count, recursive ancestor rule, trail-undo verification. Bug fix: `pl-instantiate` had no `("clause" h b)` case → vars in rule head/body were never instantiated, so rule resolution silently failed against runtime-var goals. Added clause case to recurse with shared var-env. Total 104 (+18).
-- 2026-04-24 — Phase 3 clause DB landed: `pl-mk-db` + `pl-head-key` / `pl-clause-key` / `pl-goal-key` + `pl-db-add!` / `pl-db-load!` / `pl-db-lookup` / `pl-db-lookup-goal` in runtime.sx. New `tests/clausedb.sx` 14/14 green. Total 86 (+14). Loader preserves declaration order (append!).
-- 2026-04-24 — Verified phase 1+2 already implemented on loops/prolog: `pl-parse-tests-run!` 25/25, `pl-unify-tests-run!` 47/47 (72 total). Ticked phase 1+2 boxes.
 - _(awaiting phase 1)_
 
 ## Blockers
 
 _Shared-file issues that need someone else to fix. Minimal repro only._
 
-- **Phase 5 Hyperscript DSL** — `lib/hyperscript/**` is out of scope for this loop. Needs `lib/hyperscript/parser.sx` + evaluator to add `when allowed(user, :edit) then …` syntax. Skipping; Phase 5 item 1 (`prolog-query` SX API) is done.
+- _(none yet)_

plans/ruby-on-sx.md

@@ -0,0 +1,124 @@
+# Ruby-on-SX: fibers + blocks + open classes on delimited continuations
+
+The headline showcase is **fibers** — Ruby's `Fiber.new { … Fiber.yield v … }` / `Fiber.resume` are textbook delimited continuations with sugar. MRI implements them by swapping C stacks; on SX they fall out of the existing `perform`/`cek-resume` machinery for free. Plus blocks/yield (lexical escape continuations, same shape as Smalltalk's non-local return), method_missing, and singleton classes.
+
+End-state goal: Ruby 2.7-flavoured subset, Enumerable mixin, fibers + threads-via-fibers (no real OS threads), method_missing-driven DSLs, ~150 hand-written + classic programs.
+
+## Scope decisions (defaults — override by editing before we spawn)
+
+- **Syntax:** Ruby 2.7. No 3.x pattern matching, no rightward assignment, no endless methods. We pick 2.7 because it's the biggest semantic surface that still parses cleanly.
+- **Conformance:** "Reads like Ruby, runs like Ruby." Slice of RubySpec (Core + Library subset), not full RubySpec.
+- **Test corpus:** custom + curated RubySpec slice. Plus classic programs: fiber-based generator, internal DSL with method_missing, mixin-based Enumerable on a custom class.
+- **Out of scope:** real threads, GIL, refinements, `binding_of_caller` from non-Ruby contexts, Encoding object beyond UTF-8/ASCII-8BIT, RubyVM::* introspection beyond bytecode-disassembly placeholder, IO subsystem beyond `puts`/`gets`/`File.read`.
+- **Symbols:** SX symbols. Strings are mutable copies; symbols are interned.
+
+## Ground rules
+
+- **Scope:** only touch `lib/ruby/**` and `plans/ruby-on-sx.md`. Don't edit `spec/`, `hosts/`, `shared/`, or any other `lib/<lang>/**`. Ruby primitives go in `lib/ruby/runtime.sx`.
+- **SX files:** use `sx-tree` MCP tools only.
+- **Commits:** one feature per commit. Keep `## Progress log` updated and tick roadmap boxes.
+
+## Architecture sketch
+
+```
+Ruby source
+    │
+    ▼
+lib/ruby/tokenizer.sx   — keywords, ops, %w[], %i[], heredocs (deferred), regex (deferred)
+    │
+    ▼
+lib/ruby/parser.sx      — AST: classes, modules, methods, blocks, calls
+    │
+    ▼
+lib/ruby/transpile.sx   — AST → SX AST (entry: rb-eval-ast)
+    │
+    ▼
+lib/ruby/runtime.sx     — class table, MOP, dispatch, fibers, primitives
+```
+
+Core mapping:
+- **Object** = SX dict `{:class :ivars :singleton-class?}`. Instance variables live in `ivars` keyed by symbol.
+- **Class** = SX dict `{:name :superclass :methods :class-methods :metaclass :includes :prepends}`. Class table is flat.
+- **Method dispatch** = lookup walks ancestor chain (prepended → class → included modules → superclass → …). Falls back to `method_missing` with a `Symbol`+args.
+- **Block** = lambda + escape continuation. `yield` invokes the block in current context. `return` from within a block invokes the enclosing-method's escape continuation.
+- **Proc** = lambda without strict arity. `Proc.new` + `proc {}`.
+- **Lambda** = lambda with strict arity + `return`-returns-from-lambda semantics.
+- **Fiber** = pair of continuations (resume-k, yield-k) wrapped in a record. `Fiber.new { … }` builds it; `Fiber.resume` invokes the resume-k; `Fiber.yield` invokes the yield-k. Built directly on `perform`/`cek-resume`.
+- **Module** = class without instance allocation. `include` puts it in the chain; `prepend` puts it earlier; `extend` puts it on the singleton.
+- **Singleton class** = lazily allocated per-object class for `def obj.foo` definitions.
+- **Symbol** = interned SX symbol. `:foo` reads as `(quote foo)` flavour.
+
+## Roadmap
+
+### Phase 1 — tokenizer + parser
+- [ ] Tokenizer: keywords (`def end class module if unless while until do return yield begin rescue ensure case when then else elsif`), identifiers (lowercase = local/method, `@` = ivar, `@@` = cvar, `$` = global, uppercase = constant), numbers (int, float, `0x` `0o` `0b`, `_` separators), strings (`"…"` interpolation, `'…'` literal, `%w[a b c]`, `%i[a b c]`), symbols `:foo` `:"…"`, operators (`+ - * / % ** == != < > <= >= <=> === =~ !~ << >> & | ^ ~ ! && || and or not`), `:: . , ; ( ) [ ] { } -> => |`, comments `#`
+- [ ] Parser: program is sequence of statements separated by newlines or `;`; method def `def name(args) … end`; class `class Foo < Bar … end`; module `module M … end`; block `do |a, b| … end` and `{ |a, b| … }`; call sugar (no parens), `obj.method`, `Mod::Const`; arg shapes (positional, default, splat `*args`, double-splat `**opts`, block `&blk`)
+- [ ] If/while/case expressions (return values), `unless`/`until`, postfix modifiers
+- [ ] Begin/rescue/ensure/retry, raise, raise with class+message
+- [ ] Unit tests in `lib/ruby/tests/parse.sx`
+
+### Phase 2 — object model + sequential eval
+- [ ] Class table bootstrap: `BasicObject`, `Object`, `Kernel`, `Module`, `Class`, `Numeric`, `Integer`, `Float`, `String`, `Symbol`, `Array`, `Hash`, `Range`, `NilClass`, `TrueClass`, `FalseClass`, `Proc`, `Method`
+- [ ] `rb-eval-ast`: literals, variables (local, ivar, cvar, gvar, constant), assignment (single and parallel `a, b = 1, 2`, splat receive), method call, message dispatch
+- [ ] Method lookup walks ancestor chain; cache hit-class per `(class, selector)`
+- [ ] `method_missing` fallback constructing args list
+- [ ] `super` and `super(args)` — lookup in defining class's superclass
+- [ ] Singleton class allocation on first `def obj.foo` or `class << obj`
+- [ ] `nil`, `true`, `false` are singletons of their classes; tagged values aren't boxed
+- [ ] Constant lookup (lexical-then-inheritance) with `Module.nesting`
+- [ ] 60+ tests in `lib/ruby/tests/eval.sx`
+
+### Phase 3 — blocks + procs + lambdas
+- [ ] Method invocation captures escape continuation `^k` for `return`; binds it as block's escape
+- [ ] `yield` invokes implicit block
+- [ ] `block_given?`, `&blk` parameter, `&proc` arg unpacking
+- [ ] `Proc.new`, `proc { }`, `lambda { }` (or `->(x) { x }`)
+- [ ] Lambda strict arity + lambda-local `return` semantics
+- [ ] Proc lax arity (`a, b, c` unpacks Array; missing args nil)
+- [ ] `break`, `next`, `redo` — `break` is escape-from-loop-or-block; `next` is escape-from-block-iteration; `redo` re-runs current iteration
+- [ ] 30+ tests in `lib/ruby/tests/blocks.sx`
+
+### Phase 4 — fibers (THE SHOWCASE)
+- [ ] `Fiber.new { |arg| … Fiber.yield v … }` allocates a fiber record with paired continuations
+- [ ] `Fiber.resume(args…)` resumes the fiber, returning the value passed to `Fiber.yield`
+- [ ] `Fiber.yield(v)` from inside the fiber suspends and returns control to the resumer
+- [ ] `Fiber.current` from inside the fiber
+- [ ] `Fiber#alive?`, `Fiber#raise` (deferred)
+- [ ] `Fiber.transfer` — symmetric coroutines (resume from any side)
+- [ ] Classic programs in `lib/ruby/tests/programs/`:
+  - [ ] `generator.rb` — pull-style infinite enumerator built on fibers
+  - [ ] `producer-consumer.rb` — bounded buffer with `Fiber.transfer`
+  - [ ] `tree-walk.rb` — recursive tree walker that yields each node, driven by `Fiber.resume`
+- [ ] `lib/ruby/conformance.sh` + runner, `scoreboard.json` + `scoreboard.md`
+
+### Phase 5 — modules + mixins + metaprogramming
+- [ ] `include M` — appends M's methods after class methods in chain
+- [ ] `prepend M` — prepends M before class methods
+- [ ] `extend M` — adds M to singleton class
+- [ ] `Module#ancestors`, `Module#included_modules`
+- [ ] `define_method`, `class_eval`, `instance_eval`, `module_eval`
+- [ ] `respond_to?`, `respond_to_missing?`, `method_missing`
+- [ ] `Object#send`, `Object#public_send`, `Object#__send__`
+- [ ] `Module#method_added`, `singleton_method_added` hooks
+- [ ] Hooks: `included`, `extended`, `inherited`, `prepended`
+- [ ] Internal-DSL classic program: `lib/ruby/tests/programs/dsl.rb`
+
+### Phase 6 — stdlib drive
+- [ ] `Enumerable` mixin: `each` (abstract), `map`, `select`/`filter`, `reject`, `reduce`/`inject`, `each_with_index`, `each_with_object`, `take`, `drop`, `take_while`, `drop_while`, `find`/`detect`, `find_index`, `any?`, `all?`, `none?`, `one?`, `count`, `min`, `max`, `min_by`, `max_by`, `sort`, `sort_by`, `group_by`, `partition`, `chunk`, `each_cons`, `each_slice`, `flat_map`, `lazy`
+- [ ] `Comparable` mixin: `<=>`, `<`, `<=`, `>`, `>=`, `==`, `between?`, `clamp`
+- [ ] `Array`: indexing, slicing, `push`/`pop`/`shift`/`unshift`, `concat`, `flatten`, `compact`, `uniq`, `sort`, `reverse`, `zip`, `dig`, `pack`/`unpack` (deferred)
+- [ ] `Hash`: `[]`, `[]=`, `delete`, `merge`, `each_pair`, `keys`, `values`, `to_a`, `dig`, `fetch`, default values, default proc
+- [ ] `Range`: `each`, `step`, `cover?`, `include?`, `size`, `min`, `max`
+- [ ] `String`: indexing, slicing, `split`, `gsub` (string-arg version, regex deferred), `sub`, `upcase`, `downcase`, `strip`, `chomp`, `chars`, `bytes`, `to_i`, `to_f`, `to_sym`, `*`, `+`, `<<`, format with `%`
+- [ ] `Integer`: `times`, `upto`, `downto`, `step`, `digits`, `gcd`, `lcm`
+- [ ] Drive corpus to 200+ green
+
+## Progress log
+
+_Newest first._
+
+- _(none yet)_
+
+## Blockers
+
+- _(none yet)_

plans/smalltalk-on-sx.md

@@ -0,0 +1,116 @@
+# Smalltalk-on-SX: blocks with non-local return on delimited continuations
+
+The headline showcase is **blocks** — Smalltalk's closures with non-local return (`^expr` aborts the enclosing *method*, not the block). Every other Smalltalk on top of a host VM (RSqueak on PyPy, GemStone on C, Maxine on Java) reinvents non-local return on whatever stack discipline the host gives them. On SX it's a one-liner: a block holds a captured continuation; `^` just invokes it. Message-passing OO falls out cheaply on top of the existing component / dispatch machinery.
+
+End-state goal: ANSI-ish Smalltalk-80 subset, SUnit working, ~200 hand-written tests + a vendored slice of the Pharo kernel tests, classic corpus (eight queens, quicksort, mandelbrot, Conway's Life).
+
+## Scope decisions (defaults — override by editing before we spawn)
+
+- **Syntax:** Pharo / Squeak chunk format (`!` separators, `Object subclass: #Foo …`). No fileIn/fileOut images — text source only.
+- **Conformance:** ANSI X3J20 *as a target*, not bug-for-bug Squeak. "Reads like Smalltalk, runs like Smalltalk."
+- **Test corpus:** SUnit ported to SX-Smalltalk + custom programs + a curated slice of Pharo `Kernel-Tests` / `Collections-Tests`.
+- **Image:** out of scope. Source-only. No `become:` between sessions, no snapshotting.
+- **Reflection:** `class`, `respondsTo:`, `perform:`, `doesNotUnderstand:` in. `become:` (object-identity swap) **in** — it's a good CEK exercise. Method modification at runtime in.
+- **GUI / Morphic / threads:** out entirely.
+
+## Ground rules
+
+- **Scope:** only touch `lib/smalltalk/**` and `plans/smalltalk-on-sx.md`. Don't edit `spec/`, `hosts/`, `shared/`, or any other `lib/<lang>/**`. Smalltalk primitives go in `lib/smalltalk/runtime.sx`.
+- **SX files:** use `sx-tree` MCP tools only.
+- **Commits:** one feature per commit. Keep `## Progress log` updated and tick roadmap boxes.
+
+## Architecture sketch
+
+```
+Smalltalk source
+    │
+    ▼
+lib/smalltalk/tokenizer.sx  — selectors, keywords, literals, $c, #sym, #(…), $'…'
+    │
+    ▼
+lib/smalltalk/parser.sx     — AST: classes, methods, blocks, cascades, sends
+    │
+    ▼
+lib/smalltalk/transpile.sx  — AST → SX AST (entry: smalltalk-eval-ast)
+    │
+    ▼
+lib/smalltalk/runtime.sx    — class table, MOP, dispatch, primitives
+```
+
+Core mapping:
+- **Class** = SX dict `{:name :superclass :ivars :methods :class-methods :metaclass}`. Class table is a flat dict keyed by class name.
+- **Object** = SX dict `{:class :ivars}` — `ivars` keyed by symbol. Tagged ints / floats / strings / symbols are not boxed; their class is looked up by SX type.
+- **Method** = SX lambda closing over a `self` binding + temps. Body wrapped in a delimited continuation so `^` can escape.
+- **Message send** = `(st-send receiver selector args)` — does class-table lookup, walks superclass chain, falls back to `doesNotUnderstand:` with a `Message` object.
+- **Block** `[:x | … ^v … ]` = lambda + captured `^k` (the method-return continuation). Invoking `^` calls `k`; outer block invocation past method return raises `BlockContext>>cannotReturn:`.
+- **Cascade** `r m1; m2; m3` = `(let ((tmp r)) (st-send tmp 'm1 ()) (st-send tmp 'm2 ()) (st-send tmp 'm3 ()))`.
+- **`ifTrue:ifFalse:` / `whileTrue:`** = ordinary block sends; the runtime intrinsifies them in the JIT path so they compile to native branches (Tier 1 of bytecode expansion already covers this pattern).
+- **`become:`** = swap two object identities everywhere — in SX this is a heap walk, but we restrict to `oneWayBecome:` (cheap: rewrite class field) by default.
+
+## Roadmap
+
+### Phase 1 — tokenizer + parser
+- [ ] Tokenizer: identifiers, keywords (`foo:`), binary selectors (`+`, `==`, `,`, `->`, `~=` etc.), numbers (radix `16r1F`, scaled `1.5s2`), strings `'…''…'`, characters `$c`, symbols `#foo` `#'foo bar'` `#+`, byte arrays `#[1 2 3]`, literal arrays `#(1 #foo 'x')`, comments `"…"`
+- [ ] Parser: chunk format (`! !` separators), class definitions (`Object subclass: #X instanceVariableNames: '…' classVariableNames: '…' …`), method definitions (`extend: #Foo with: 'bar ^self'`), pragmas `<primitive: 1>`, blocks `[:a :b | | t1 t2 | …]`, cascades, message precedence (unary > binary > keyword)
+- [ ] Unit tests in `lib/smalltalk/tests/parse.sx`
+
+### Phase 2 — object model + sequential eval
+- [ ] Class table + bootstrap: `Object`, `Behavior`, `Class`, `Metaclass`, `UndefinedObject`, `Boolean`/`True`/`False`, `Number`/`Integer`/`Float`, `String`, `Symbol`, `Array`, `Block`
+- [ ] `smalltalk-eval-ast`: literals, variable reference, assignment, message send, cascade, sequence, return
+- [ ] Method lookup: walk class → superclass; cache hit-class on `(class, selector)`
+- [ ] `doesNotUnderstand:` fallback constructing `Message` object
+- [ ] `super` send (lookup starts at superclass of *defining* class, not receiver class)
+- [ ] 30+ tests in `lib/smalltalk/tests/eval.sx`
+
+### Phase 3 — blocks + non-local return (THE SHOWCASE)
+- [ ] Method invocation captures a `^k` (the return continuation) and binds it as the block's escape
+- [ ] `^expr` from inside a block invokes that captured `^k`
+- [ ] `BlockContext>>value`, `value:`, `value:value:`, …, `valueWithArguments:`
+- [ ] `whileTrue:` / `whileTrue` / `whileFalse:` / `whileFalse` as ordinary block sends — runtime intrinsifies the loop in the bytecode JIT
+- [ ] `ifTrue:` / `ifFalse:` / `ifTrue:ifFalse:` as block sends, similarly intrinsified
+- [ ] Escape past returned-from method raises `BlockContext>>cannotReturn:`
+- [ ] Classic programs in `lib/smalltalk/tests/programs/`:
+  - [ ] `eight-queens.st`
+  - [ ] `quicksort.st`
+  - [ ] `mandelbrot.st`
+  - [ ] `life.st` (Conway's Life, glider gun)
+  - [ ] `fibonacci.st` (recursive + memoised)
+- [ ] `lib/smalltalk/conformance.sh` + runner, `scoreboard.json` + `scoreboard.md`
+
+### Phase 4 — reflection + MOP
+- [ ] `Object>>class`, `class>>name`, `class>>superclass`, `class>>methodDict`, `class>>selectors`
+- [ ] `Object>>perform:` / `perform:with:` / `perform:withArguments:`
+- [ ] `Object>>respondsTo:`, `Object>>isKindOf:`, `Object>>isMemberOf:`
+- [ ] `Behavior>>compile:` — runtime method addition
+- [ ] `Object>>becomeForward:` (one-way become; rewrites the class field of `aReceiver`)
+- [ ] Exceptions: `Exception`, `Error`, `signal`, `signal:`, `on:do:`, `ensure:`, `ifCurtailed:` — built on top of SX `handler-bind`/`raise`
+
+### Phase 5 — collections + numeric tower
+- [ ] `SequenceableCollection`/`OrderedCollection`/`Array`/`String`/`Symbol`
+- [ ] `HashedCollection`/`Set`/`Dictionary`/`IdentityDictionary`
+- [ ] `Stream` hierarchy: `ReadStream`/`WriteStream`/`ReadWriteStream`
+- [ ] `Number` tower: `SmallInteger`/`LargePositiveInteger`/`Float`/`Fraction`
+- [ ] `String>>format:`, `printOn:` for everything
+
+### Phase 6 — SUnit + corpus to 200+
+- [ ] Port SUnit (TestCase, TestSuite, TestResult) — written in SX-Smalltalk, runs in itself
+- [ ] Vendor a slice of Pharo `Kernel-Tests` and `Collections-Tests`
+- [ ] Drive the scoreboard up: aim for 200+ green tests
+- [ ] Stretch: ANSI Smalltalk validator subset
+
+### Phase 7 — speed (optional)
+- [ ] Method-dictionary inline caching (already in CEK as a primitive; just wire selector cache)
+- [ ] Block intrinsification beyond `whileTrue:` / `ifTrue:`
+- [ ] Compare against GNU Smalltalk on the corpus
+
+## Progress log
+
+_Newest first. Agent appends on every commit._
+
+- _(none yet)_
+
+## Blockers
+
+_Shared-file issues that need someone else to fix. Minimal repro only._
+
+- _(none yet)_

plans/tcl-on-sx.md

@@ -0,0 +1,127 @@
+# Tcl-on-SX: uplevel/upvar = stack-walking delcc, everything-is-a-string
+
+The headline showcase is **uplevel/upvar** — Tcl's superpower for defining your own control structures. `uplevel` evaluates a script in the *caller's* stack frame; `upvar` aliases a variable in the caller. On a normal language host this requires deep VM cooperation; on SX it falls out of the env-chain made first-class via captured continuations. Plus the *Dodekalogue* (12 rules), command-substitution everywhere, and "everything is a string" homoiconicity.
+
+End-state goal: Tcl 8.6-flavoured subset, the Dodekalogue parser, namespaces, `try`/`catch`/`return -code`, `coroutine` (built on fibers), classic programs that show off uplevel-driven DSLs, ~150 hand-written tests.
+
+## Scope decisions (defaults — override by editing before we spawn)
+
+- **Syntax:** Tcl 8.6 surface. The 12-rule Dodekalogue. Brace-quoted scripts deferred-evaluate; double-quoted ones substitute.
+- **Conformance:** "Reads like Tcl, runs like Tcl." Slice of Tcl's own test suite, not full TCT.
+- **Test corpus:** custom + curated `tcl-tests/` slice. Plus classic programs: define-your-own `for-each-line`, expression-language compiler-in-Tcl, fiber-based event loop.
+- **Out of scope:** Tk, sockets beyond a stub, threads (mapped to `coroutine` only), `package require` of binary loadables, `dde`/`registry` Windows shims, full `clock format` locale support.
+- **Channels:** `puts` and `gets` on `stdout`/`stdin`/`stderr`; `open` on regular files; no async I/O beyond what `coroutine` gives.
+
+## Ground rules
+
+- **Scope:** only touch `lib/tcl/**` and `plans/tcl-on-sx.md`. Don't edit `spec/`, `hosts/`, `shared/`, or any other `lib/<lang>/**`. Tcl primitives go in `lib/tcl/runtime.sx`.
+- **SX files:** use `sx-tree` MCP tools only.
+- **Commits:** one feature per commit. Keep `## Progress log` updated and tick roadmap boxes.
+
+## Architecture sketch
+
+```
+Tcl source
+    │
+    ▼
+lib/tcl/tokenizer.sx   — the Dodekalogue: words, [..], ${..}, "..", {..}, ;, \n, \, #
+    │
+    ▼
+lib/tcl/parser.sx      — list-of-words AST (script = list of commands; command = list of words)
+    │
+    ▼
+lib/tcl/transpile.sx   — AST → SX AST (entry: tcl-eval-script)
+    │
+    ▼
+lib/tcl/runtime.sx     — env stack, command table, uplevel/upvar, coroutines, BIFs
+```
+
+Core mapping:
+- **Value** = string. Internally we cache a "shimmer" representation (list, dict, integer, double) for performance, but every value can be re-stringified.
+- **Variable** = entry in current frame's env. Frames form a stack; level-0 is the global frame.
+- **Command** = entry in command table; first word of any list dispatches into it. User-defined via `proc`. Built-ins are SX functions registered in the table.
+- **Frame** = `{:locals (dict) :level n :parent frame}`. Each `proc` call pushes a frame; commands run in current frame.
+- **`uplevel #N script`** = walk frame chain to absolute level N (or relative if no `#`); evaluate script in that frame's env.
+- **`upvar [#N] varname localname`** = bind `localname` in the current frame as an alias to `varname` in the level-N frame (env-chain delegate).
+- **`return -code N`** = control flow as integers: 0=ok, 1=error, 2=return, 3=break, 4=continue. `catch` traps any non-zero; `try` adds named handlers.
+- **`coroutine`** = fiber on top of `perform`/`cek-resume`. `yield`/`yieldto` suspend; calling the coroutine command resumes.
+- **List / dict** = list-shaped string ("element1 element2 …") with a cached parsed form. Modifications dirty the string cache.
+
+## Roadmap
+
+### Phase 1 — tokenizer + parser (the Dodekalogue)
+- [ ] Tokenizer applying the 12 rules:
+  1. Commands separated by `;` or newlines
+  2. Words separated by whitespace within a command
+  3. Double-quoted words: `\` escapes + `[…]` + `${…}` + `$var` substitution
+  4. Brace-quoted words: literal, no substitution; brace count must balance
+  5. Argument expansion: `{*}list`
+  6. Command substitution: `[script]` evaluates script, takes its return value
+  7. Variable substitution: `$name`, `${name}`, `$arr(idx)`, `$arr($i)`
+  8. Backslash substitution: `\n`, `\t`, `\\`, `\xNN`, `\uNNNN`, `\<newline>` continues
+  9. Comments: `#` only at the start of a command
+  10. Order of substitution is left-to-right, single-pass
+  11. Substitutions don't recurse — substituted text is not re-parsed
+  12. The result of any substitution is the value, not a new script
+- [ ] Parser: script = list of commands; command = list of words; word = literal string + list of substitutions
+- [ ] Unit tests in `lib/tcl/tests/parse.sx`
+
+### Phase 2 — sequential eval + core commands
+- [ ] `tcl-eval-script`: walk command list, dispatch each first-word into command table
+- [ ] Core commands: `set`, `unset`, `incr`, `append`, `lappend`, `puts`, `gets`, `expr`, `if`, `while`, `for`, `foreach`, `switch`, `break`, `continue`, `return`, `error`, `eval`, `subst`, `format`, `scan`
+- [ ] `expr` is its own mini-language — operator precedence, function calls (`sin`, `sqrt`, `pow`, `abs`, `int`, `double`), variable substitution, command substitution
+- [ ] String commands: `string length`, `string index`, `string range`, `string compare`, `string match`, `string toupper`, `string tolower`, `string trim`, `string map`, `string repeat`, `string first`, `string last`, `string is`, `string cat`
+- [ ] List commands: `list`, `lindex`, `lrange`, `llength`, `lreverse`, `lsearch`, `lsort`, `lsort -integer/-real/-dictionary`, `lreplace`, `linsert`, `concat`, `split`, `join`
+- [ ] Dict commands: `dict create`, `dict get`, `dict set`, `dict unset`, `dict exists`, `dict keys`, `dict values`, `dict size`, `dict for`, `dict update`, `dict merge`
+- [ ] 60+ tests in `lib/tcl/tests/eval.sx`
+
+### Phase 3 — proc + uplevel + upvar (THE SHOWCASE)
+- [ ] `proc name args body` — register user-defined command; args supports defaults `{name default}` and rest `args`
+- [ ] Frame stack: each proc call pushes a frame with locals dict; pop on return
+- [ ] `uplevel ?level? script` — evaluate `script` in level-N frame's env; default level is 1 (caller). `#0` is global, `#1` is relative-1
+- [ ] `upvar ?level? otherVar localVar ?…?` — alias localVar to a variable in level-N frame; reads/writes go through the alias
+- [ ] `info level`, `info level N`, `info frame`, `info vars`, `info locals`, `info globals`, `info commands`, `info procs`, `info args`, `info body`
+- [ ] `global var ?…?` — alias to global frame (sugar for `upvar #0 var var`)
+- [ ] `variable name ?value?` — namespace-scoped global
+- [ ] Classic programs in `lib/tcl/tests/programs/`:
+  - [ ] `for-each-line.tcl` — define your own loop construct using `uplevel`
+  - [ ] `assert.tcl` — assertion macro that reports caller's line
+  - [ ] `with-temp-var.tcl` — scoped variable rebind via `upvar`
+- [ ] `lib/tcl/conformance.sh` + runner, `scoreboard.json` + `scoreboard.md`
+
+### Phase 4 — control flow + error handling
+- [ ] `return -code (ok|error|return|break|continue|N) -errorinfo … -errorcode … -level N value`
+- [ ] `catch script ?resultVar? ?optionsVar?` — runs script, returns code; sets resultVar to return value/message; optionsVar to the dict
+- [ ] `try script ?on code var body ...? ?trap pattern var body...? ?finally body?`
+- [ ] `throw type message`
+- [ ] `error message ?info? ?code?`
+- [ ] Stack-trace with `errorInfo` / `errorCode`
+- [ ] 30+ tests in `lib/tcl/tests/error.sx`
+
+### Phase 5 — namespaces + ensembles
+- [ ] `namespace eval ns body`, `namespace current`, `namespace which`, `namespace import`, `namespace export`, `namespace forget`, `namespace delete`
+- [ ] Qualified names: `::ns::cmd`, `::ns::var`
+- [ ] Ensembles: `namespace ensemble create -map { sub1 cmd1 sub2 cmd2 }`
+- [ ] `namespace path` for resolution chain
+- [ ] `proc` and `variable` work inside namespaces
+
+### Phase 6 — coroutines + drive corpus
+- [ ] `coroutine name cmd ?args…?` — start a coroutine; future calls to `name` resume it
+- [ ] `yield ?value?` — suspend, return value to resumer
+- [ ] `yieldto cmd ?args…?` — symmetric transfer
+- [ ] `coroutine` semantics built on fibers (same delcc primitive as Ruby fibers)
+- [ ] Classic programs: `event-loop.tcl` — cooperative scheduler with multiple coroutines
+- [ ] System: `clock seconds`, `clock format`, `clock scan` (subset)
+- [ ] File I/O: `open`, `close`, `read`, `gets`, `puts -nonewline`, `flush`, `eof`, `seek`, `tell`
+- [ ] Drive corpus to 150+ green
+- [ ] Idiom corpus — `lib/tcl/tests/idioms.sx` covering classic Welch/Jones idioms
+
+## Progress log
+
+_Newest first._
+
+- _(none yet)_
+
+## Blockers
+
+- _(none yet)_

scripts/sx-loops-down.sh

@@ -30,7 +30,7 @@ fi
 
 if [ "$CLEAN" = "1" ]; then
   cd "$(dirname "$0")/.."
-  for lang in lua prolog forth erlang haskell js hs; do
+  for lang in lua prolog forth erlang haskell js hs smalltalk common-lisp apl ruby tcl; do
     wt="$WORKTREE_BASE/$lang"
     if [ -d "$wt" ]; then
       git worktree remove --force "$wt" 2>/dev/null || rm -rf "$wt"
@@ -39,5 +39,5 @@ if [ "$CLEAN" = "1" ]; then
   done
   git worktree prune
   echo "Worktree branches (loops/<lang>) are preserved. Delete manually if desired:"
-  echo "  git branch -D loops/lua loops/prolog loops/forth loops/erlang loops/haskell loops/js loops/hs"
+  echo "  git branch -D loops/lua loops/prolog loops/forth loops/erlang loops/haskell loops/js loops/hs loops/smalltalk loops/common-lisp loops/apl loops/ruby loops/tcl"
 fi

scripts/sx-loops-up.sh

@@ -1,5 +1,5 @@
 #!/usr/bin/env bash
-# Spawn 7 claude sessions in tmux, one per language loop.
+# Spawn 12 claude sessions in tmux, one per language loop.
 # Each runs in its own git worktree rooted at /root/rose-ash-loops/<lang>,
 # on branch loops/<lang>. No two loops share a working tree, so there's
 # zero risk of file collisions between languages.
@@ -9,7 +9,7 @@
 #
 # After the script prints done:
 #   tmux a -t sx-loops
-#   Ctrl-B + <window-number> to switch (0=lua ... 6=hs)
+#   Ctrl-B + <window-number> to switch (0=lua ... 11=tcl)
 #   Ctrl-B + d to detach (loops keep running, SSH-safe)
 #
 # Stop: ./scripts/sx-loops-down.sh
@@ -38,8 +38,13 @@ declare -A BRIEFING=(
   [haskell]=haskell-loop.md
   [js]=loop.md
   [hs]=hs-loop.md
+  [smalltalk]=smalltalk-loop.md
+  [common-lisp]=common-lisp-loop.md
+  [apl]=apl-loop.md
+  [ruby]=ruby-loop.md
+  [tcl]=tcl-loop.md
 )
-ORDER=(lua prolog forth erlang haskell js hs)
+ORDER=(lua prolog forth erlang haskell js hs smalltalk common-lisp apl ruby tcl)
 
 mkdir -p "$WORKTREE_BASE"
 
@@ -60,13 +65,13 @@ for lang in "${ORDER[@]}"; do
   fi
 done
 
-# Create tmux session with 7 windows, each cwd in its worktree
+# Create tmux session with one window per language, each cwd in its worktree
 tmux new-session -d -s "$SESSION" -n "${ORDER[0]}" -c "$WORKTREE_BASE/${ORDER[0]}"
 for lang in "${ORDER[@]:1}"; do
   tmux new-window -t "$SESSION" -n "$lang" -c "$WORKTREE_BASE/$lang"
 done
 
-echo "Starting 7 claude sessions..."
+echo "Starting ${#ORDER[@]} claude sessions..."
 for lang in "${ORDER[@]}"; do
   tmux send-keys -t "$SESSION:$lang" "claude" C-m
 done
@@ -89,10 +94,10 @@ for lang in "${ORDER[@]}"; do
 done
 
 echo ""
-echo "Done. 7 loops started in tmux session '$SESSION', each in its own worktree."
+echo "Done. ${#ORDER[@]} loops started in tmux session '$SESSION', each in its own worktree."
 echo ""
 echo "  Attach:    tmux a -t $SESSION"
-echo "  Switch:    Ctrl-B <0..6>  (0=lua 1=prolog 2=forth 3=erlang 4=haskell 5=js 6=hs)"
+echo "  Switch:    Ctrl-B <0..11>  (0=lua 1=prolog 2=forth 3=erlang 4=haskell 5=js 6=hs 7=smalltalk 8=common-lisp 9=apl 10=ruby 11=tcl)"
 echo "  List:      Ctrl-B w"
 echo "  Detach:    Ctrl-B d"
 echo "  Stop:      ./scripts/sx-loops-down.sh"

spec/tests/test-hyperscript-behavioral.sx

@@ -88,6 +88,27 @@
                 (raise _e))))
           (handler me-val))))))
 
+;; Evaluate a hyperscript expression, catch the first error raised, and
+;; return its message string. Used by runtimeErrors tests.
+;; Returns nil if no error is raised (test would then fail equality).
+(define eval-hs-error
+  (fn (src)
+    (let ((sx (hs-to-sx (hs-compile src))))
+      (let ((handler (eval-expr-cek
+              (list (quote fn) (list (quote me))
+                (list (quote let) (list (list (quote it) nil) (list (quote event) nil)) sx)))))
+        (guard
+          (_e
+            (true
+              (if
+                (string? _e)
+                _e
+                (if
+                  (and (list? _e) (= (first _e) "hs-return"))
+                  nil
+                  (str _e)))))
+          (begin (handler nil) nil))))))
+
 ;; ── add (19 tests) ──
 (defsuite "hs-upstream-add"
   (deftest "can add a value to a set"
@@ -2153,41 +2174,75 @@
 ;; ── core/runtimeErrors (18 tests) ──
 (defsuite "hs-upstream-core/runtimeErrors"
   (deftest "reports basic function invocation null errors properly"
-    (error "SKIP (untranslated): reports basic function invocation null errors properly"))
+    (assert= (eval-hs-error "x()") "'x' is null")
+    (assert= (eval-hs-error "x.y()") "'x' is null")
+    (assert= (eval-hs-error "x.y.z()") "'x.y' is null")
+  )
   (deftest "reports basic function invocation null errors properly w/ of"
-    (error "SKIP (untranslated): reports basic function invocation null errors properly w/ of"))
+    (assert= (eval-hs-error "z() of y of x") "'z' is null")
+  )
   (deftest "reports basic function invocation null errors properly w/ possessives"
-    (error "SKIP (untranslated): reports basic function invocation null errors properly w/ possessives"))
+    (assert= (eval-hs-error "x's y()") "'x' is null")
+    (assert= (eval-hs-error "x's y's z()") "'x's y' is null")
+  )
   (deftest "reports null errors on add command properly"
-    (error "SKIP (untranslated): reports null errors on add command properly"))
+    (assert= (eval-hs-error "add .foo to #doesntExist") "'#doesntExist' is null")
+    (assert= (eval-hs-error "add @foo to #doesntExist") "'#doesntExist' is null")
+    (assert= (eval-hs-error "add {display:none} to #doesntExist") "'#doesntExist' is null")
+  )
   (deftest "reports null errors on decrement command properly"
-    (error "SKIP (untranslated): reports null errors on decrement command properly"))
+    (assert= (eval-hs-error "decrement #doesntExist's innerHTML") "'#doesntExist' is null")
+  )
   (deftest "reports null errors on default command properly"
-    (error "SKIP (untranslated): reports null errors on default command properly"))
+    (assert= (eval-hs-error "default #doesntExist's innerHTML to 'foo'") "'#doesntExist' is null")
+  )
   (deftest "reports null errors on hide command properly"
-    (error "SKIP (untranslated): reports null errors on hide command properly"))
+    (assert= (eval-hs-error "hide #doesntExist") "'#doesntExist' is null")
+  )
   (deftest "reports null errors on increment command properly"
-    (error "SKIP (untranslated): reports null errors on increment command properly"))
+    (assert= (eval-hs-error "increment #doesntExist's innerHTML") "'#doesntExist' is null")
+  )
   (deftest "reports null errors on measure command properly"
-    (error "SKIP (untranslated): reports null errors on measure command properly"))
+    (assert= (eval-hs-error "measure #doesntExist") "'#doesntExist' is null")
+  )
   (deftest "reports null errors on put command properly"
-    (error "SKIP (untranslated): reports null errors on put command properly"))
+    (assert= (eval-hs-error "put 'foo' into #doesntExist") "'#doesntExist' is null")
+    (assert= (eval-hs-error "put 'foo' into #doesntExist's innerHTML") "'#doesntExist' is null")
+    (assert= (eval-hs-error "put 'foo' into #doesntExist.innerHTML") "'#doesntExist' is null")
+    (assert= (eval-hs-error "put 'foo' before #doesntExist") "'#doesntExist' is null")
+    (assert= (eval-hs-error "put 'foo' after #doesntExist") "'#doesntExist' is null")
+    (assert= (eval-hs-error "put 'foo' at the start of #doesntExist") "'#doesntExist' is null")
+    (assert= (eval-hs-error "put 'foo' at the end of #doesntExist") "'#doesntExist' is null")
+  )
   (deftest "reports null errors on remove command properly"
-    (error "SKIP (untranslated): reports null errors on remove command properly"))
+    (assert= (eval-hs-error "remove .foo from #doesntExist") "'#doesntExist' is null")
+    (assert= (eval-hs-error "remove @foo from #doesntExist") "'#doesntExist' is null")
+    (assert= (eval-hs-error "remove #doesntExist from #doesntExist") "'#doesntExist' is null")
+  )
   (deftest "reports null errors on send command properly"
-    (error "SKIP (untranslated): reports null errors on send command properly"))
+    (assert= (eval-hs-error "send 'foo' to #doesntExist") "'#doesntExist' is null")
+  )
   (deftest "reports null errors on sets properly"
-    (error "SKIP (untranslated): reports null errors on sets properly"))
+    (assert= (eval-hs-error "set x's y to true") "'x' is null")
+    (assert= (eval-hs-error "set x's @y to true") "'x' is null")
+  )
   (deftest "reports null errors on settle command properly"
-    (error "SKIP (untranslated): reports null errors on settle command properly"))
+    (assert= (eval-hs-error "settle #doesntExist") "'#doesntExist' is null")
+  )
   (deftest "reports null errors on show command properly"
-    (error "SKIP (untranslated): reports null errors on show command properly"))
+    (assert= (eval-hs-error "show #doesntExist") "'#doesntExist' is null")
+  )
   (deftest "reports null errors on toggle command properly"
-    (error "SKIP (untranslated): reports null errors on toggle command properly"))
+    (assert= (eval-hs-error "toggle .foo on #doesntExist") "'#doesntExist' is null")
+    (assert= (eval-hs-error "toggle between .foo and .bar on #doesntExist") "'#doesntExist' is null")
+    (assert= (eval-hs-error "toggle @foo on #doesntExist") "'#doesntExist' is null")
+  )
   (deftest "reports null errors on transition command properly"
-    (error "SKIP (untranslated): reports null errors on transition command properly"))
+    (assert= (eval-hs-error "transition #doesntExist's *visibility to 0") "'#doesntExist' is null")
+  )
   (deftest "reports null errors on trigger command properly"
-    (error "SKIP (untranslated): reports null errors on trigger command properly"))
+    (assert= (eval-hs-error "trigger 'foo' on #doesntExist") "'#doesntExist' is null")
+  )
 )
 
 ;; ── core/scoping (20 tests) ──

tests/playwright/generate-sx-tests.py

@@ -2333,6 +2333,25 @@ def generate_eval_only_test(test, idx):
         hs_expr = extract_hs_expr(m.group(2))
         assertions.append(f'    (assert-throws (eval-hs "{hs_expr}"))')
 
+    # Pattern 4: eval-hs-error — expect(await error("expr")).toBe("msg")
+    # These test that running HS raises an error with a specific message string.
+    for m in re.finditer(
+        r'(?:const\s+\w+\s*=\s*)?(?:await\s+)?error\((["\x27`])(.+?)\1\)'
+        r'(?:[^;]|\n)*?(?:expect\([^)]*\)\.toBe\(([^)]+)\)|\.toBe\(([^)]+)\))',
+        body, re.DOTALL
+    ):
+        hs_expr = extract_hs_expr(m.group(2))
+        expected_raw = (m.group(3) or m.group(4) or '').strip()
+        # Strip only the outermost JS string delimiter (double or single quote)
+        # without touching inner quotes inside the string value.
+        if len(expected_raw) >= 2 and expected_raw[0] == expected_raw[-1] and expected_raw[0] in ('"', "'"):
+            inner = expected_raw[1:-1]
+            expected_sx = '"' + inner.replace('\\', '\\\\').replace('"', '\\"') + '"'
+        else:
+            expected_sx = js_val_to_sx(expected_raw)
+        hs_escaped = hs_expr.replace('\\', '\\\\').replace('"', '\\"')
+        assertions.append(f'    (assert= (eval-hs-error "{hs_escaped}") {expected_sx})')
+
     if not assertions:
         return None  # Can't convert this body pattern
 
@@ -2692,6 +2711,27 @@ output.append('                (nth _e 1)')
 output.append('                (raise _e))))')
 output.append('          (handler me-val))))))')
 output.append('')
+output.append(';; Evaluate a hyperscript expression, catch the first error raised, and')
+output.append(';; return its message string. Used by runtimeErrors tests.')
+output.append(';; Returns nil if no error is raised (test would then fail equality).')
+output.append('(define eval-hs-error')
+output.append('  (fn (src)')
+output.append('    (let ((sx (hs-to-sx (hs-compile src))))')
+output.append('      (let ((handler (eval-expr-cek')
+output.append('              (list (quote fn) (list (quote me))')
+output.append('                (list (quote let) (list (list (quote it) nil) (list (quote event) nil)) sx)))))')
+output.append('        (guard')
+output.append('          (_e')
+output.append('            (true')
+output.append('              (if')
+output.append('                (string? _e)')
+output.append('                _e')
+output.append('                (if')
+output.append('                  (and (list? _e) (= (first _e) "hs-return"))')
+output.append('                  nil')
+output.append('                  (str _e)))))')
+output.append('          (begin (handler nil) nil))))))')
+output.append('')
 
 # Group by category
 categories = OrderedDict()