plans: tick keep-interpreter box, update progress log

prolog: cross-validate compiler vs interpreter (+17)
plans: tick compiler box, update progress log
2026-04-25 18:32:52 +00:00 · 2026-04-25 18:32:36 +00:00 · 2026-04-25 18:08:46 +00:00 · 2026-04-25 18:08:27 +00:00 · 2026-04-25 14:13:59 +00:00 · 2026-04-25 14:13:12 +00:00
76 changed files with 8631 additions and 8096 deletions
--- a/lib/haskell/conformance.sh
+++ b/lib/haskell/conformance.sh
@@ -1,140 +0,0 @@
 #!/usr/bin/env bash
 # lib/haskell/conformance.sh — run the 5 classic-program test suites.
 # Writes lib/haskell/scoreboard.json and lib/haskell/scoreboard.md.
 #
 # Usage:
 #   bash lib/haskell/conformance.sh           # run + write scoreboards
 #   bash lib/haskell/conformance.sh --check   # run only, exit 1 on failure
 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 | head -1 | awk '{print $1}')
  if [ -x "$MAIN_ROOT/$SX_SERVER" ]; then
    SX_SERVER="$MAIN_ROOT/$SX_SERVER"
  else
    echo "ERROR: sx_server.exe not found. Run: cd hosts/ocaml && dune build"
    exit 1
  fi
 fi
 PROGRAMS=(fib sieve quicksort nqueens calculator)
 PASS_COUNTS=()
 FAIL_COUNTS=()
 run_suite() {
  local prog="$1"
  local FILE="lib/haskell/tests/program-${prog}.sx"
  local TMPFILE
  TMPFILE=$(mktemp)
  cat > "$TMPFILE" <<EPOCHS
 (epoch 1)
 (load "lib/haskell/tokenizer.sx")
 (load "lib/haskell/layout.sx")
 (load "lib/haskell/parser.sx")
 (load "lib/haskell/desugar.sx")
 (load "lib/haskell/runtime.sx")
 (load "lib/haskell/match.sx")
 (load "lib/haskell/eval.sx")
 (load "lib/haskell/testlib.sx")
 (epoch 2)
 (load "$FILE")
 (epoch 3)
 (eval "(list hk-test-pass hk-test-fail)")
 EPOCHS
  local OUTPUT
  OUTPUT=$(timeout 120 "$SX_SERVER" < "$TMPFILE" 2>&1 || true)
  rm -f "$TMPFILE"
  local LINE
  LINE=$(echo "$OUTPUT" | awk '/^\(ok-len 3 / {getline; print; exit}')
  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 "0 1"
  else
    local P F
    P=$(echo "$LINE" | sed -E 's/^\(([0-9]+) ([0-9]+)\).*/\1/' || echo "0")
    F=$(echo "$LINE" | sed -E 's/^\(([0-9]+) ([0-9]+)\).*/\2/' || echo "1")
    echo "$P $F"
  fi
 }
 for prog in "${PROGRAMS[@]}"; do
  RESULT=$(run_suite "$prog")
  P=$(echo "$RESULT" | cut -d' ' -f1)
  F=$(echo "$RESULT" | cut -d' ' -f2)
  PASS_COUNTS+=("$P")
  FAIL_COUNTS+=("$F")
  T=$((P + F))
  if [ "$F" -eq 0 ]; then
    printf '✓ %-14s  %d/%d\n' "${prog}.hs" "$P" "$T"
  else
    printf '✗ %-14s  %d/%d\n' "${prog}.hs" "$P" "$T"
  fi
 done
 TOTAL_PASS=0
 TOTAL_FAIL=0
 PROG_PASS=0
 for i in "${!PROGRAMS[@]}"; do
  TOTAL_PASS=$((TOTAL_PASS + PASS_COUNTS[i]))
  TOTAL_FAIL=$((TOTAL_FAIL + FAIL_COUNTS[i]))
  [ "${FAIL_COUNTS[$i]}" -eq 0 ] && PROG_PASS=$((PROG_PASS + 1))
 done
 PROG_TOTAL=${#PROGRAMS[@]}
 echo ""
 echo "Classic programs: ${TOTAL_PASS}/$((TOTAL_PASS + TOTAL_FAIL)) tests  |  ${PROG_PASS}/${PROG_TOTAL} programs passing"
 if [[ "${1:-}" == "--check" ]]; then
  [ $TOTAL_FAIL -eq 0 ]
  exit $?
 fi
 DATE=$(date '+%Y-%m-%d')
 # scoreboard.json
 {
  printf '{\n'
  printf '  "date": "%s",\n' "$DATE"
  printf '  "total_pass": %d,\n' "$TOTAL_PASS"
  printf '  "total_fail": %d,\n' "$TOTAL_FAIL"
  printf '  "programs": {\n'
  last=$((${#PROGRAMS[@]} - 1))
  for i in "${!PROGRAMS[@]}"; do
    prog="${PROGRAMS[$i]}"
    if [ $i -lt $last ]; then
      printf '    "%s": {"pass": %d, "fail": %d},\n' "$prog" "${PASS_COUNTS[$i]}" "${FAIL_COUNTS[$i]}"
    else
      printf '    "%s": {"pass": %d, "fail": %d}\n'  "$prog" "${PASS_COUNTS[$i]}" "${FAIL_COUNTS[$i]}"
    fi
  done
  printf '  }\n'
  printf '}\n'
 } > lib/haskell/scoreboard.json
 # scoreboard.md
 {
  printf '# Haskell-on-SX Scoreboard\n\n'
  printf 'Updated %s · Phase 3 (laziness + classic programs)\n\n' "$DATE"
  printf '| Program | Tests | Status |\n'
  printf '|---------|-------|--------|\n'
  for i in "${!PROGRAMS[@]}"; do
    prog="${PROGRAMS[$i]}"
    P=${PASS_COUNTS[$i]}
    F=${FAIL_COUNTS[$i]}
    T=$((P + F))
    [ "$F" -eq 0 ] && STATUS="✓" || STATUS="✗"
    printf '| %s | %d/%d | %s |\n' "${prog}.hs" "$P" "$T" "$STATUS"
  done
  printf '| **Total** | **%d/%d** | **%d/%d programs** |\n' \
    "$TOTAL_PASS" "$((TOTAL_PASS + TOTAL_FAIL))" "$PROG_PASS" "$PROG_TOTAL"
 } > lib/haskell/scoreboard.md
 echo "Wrote lib/haskell/scoreboard.json and lib/haskell/scoreboard.md"
 [ $TOTAL_FAIL -eq 0 ]
--- a/lib/haskell/desugar.sx
+++ b/lib/haskell/desugar.sx
@@ -1,249 +0,0 @@
 ;; Desugar the Haskell surface AST into a smaller core AST.
 ;;
 ;; Eliminates the three surface-only shapes produced by the parser:
 ;;   :where BODY DECLS     →  :let DECLS BODY
 ;;   :guarded GUARDS       →  :if C1 E1 (:if C2 E2 … (:app error …))
 ;;   :list-comp EXPR QUALS →  concatMap-based expression (§3.11)
 ;;
 ;; Everything else (:app, :op, :lambda, :let, :case, :do, :tuple,
 ;; :list, :range, :if, :neg, :sect-left / :sect-right, plus all
 ;; leaf forms and pattern / type nodes) is passed through after
 ;; recursing into children.
 (define
  hk-guards-to-if
  (fn
    (guards)
    (cond
      ((empty? guards)
        (list
          :app
          (list :var "error")
          (list :string "Non-exhaustive guards")))
      (:else
        (let
          ((g (first guards)))
          (list
            :if
            (hk-desugar (nth g 1))
            (hk-desugar (nth g 2))
            (hk-guards-to-if (rest guards))))))))
 ;; do-notation desugaring (Haskell 98 §3.14):
 ;;   do { e }              =  e
 ;;   do { e ; ss }         =  e >> do { ss }
 ;;   do { p <- e ; ss }    =  e >>= \p -> do { ss }
 ;;   do { let decls ; ss } =  let decls in do { ss }
 (define
  hk-desugar-do
  (fn
    (stmts)
    (cond
      ((empty? stmts) (raise "empty do block"))
      ((empty? (rest stmts))
        (let ((s (first stmts)))
          (cond
            ((= (first s) "do-expr") (hk-desugar (nth s 1)))
            (:else
              (raise "do block must end with an expression")))))
      (:else
        (let
          ((s (first stmts)) (rest-stmts (rest stmts)))
          (let
            ((rest-do (hk-desugar-do rest-stmts)))
            (cond
              ((= (first s) "do-expr")
                (list
                  :app
                  (list
                    :app
                    (list :var ">>")
                    (hk-desugar (nth s 1)))
                  rest-do))
              ((= (first s) "do-bind")
                (list
                  :app
                  (list
                    :app
                    (list :var ">>=")
                    (hk-desugar (nth s 2)))
                  (list :lambda (list (nth s 1)) rest-do)))
              ((= (first s) "do-let")
                (list
                  :let
                  (map hk-desugar (nth s 1))
                  rest-do))
              (:else (raise "unknown do-stmt tag")))))))))
 ;; List-comprehension desugaring (Haskell 98 §3.11):
 ;;   [e |             ]  =  [e]
 ;;   [e | b,     Q    ]  =  if b then [e | Q] else []
 ;;   [e | p <- l, Q    ]  =  concatMap (\p -> [e | Q]) l
 ;;   [e | let ds, Q    ]  =  let ds in [e | Q]
 (define
  hk-lc-desugar
  (fn
    (e quals)
    (cond
      ((empty? quals) (list :list (list e)))
      (:else
        (let
          ((q (first quals)))
          (let
            ((qtag (first q)))
            (cond
              ((= qtag "q-guard")
                (list
                  :if
                  (hk-desugar (nth q 1))
                  (hk-lc-desugar e (rest quals))
                  (list :list (list))))
              ((= qtag "q-gen")
                (list
                  :app
                  (list
                    :app
                    (list :var "concatMap")
                    (list
                      :lambda
                      (list (nth q 1))
                      (hk-lc-desugar e (rest quals))))
                  (hk-desugar (nth q 2))))
              ((= qtag "q-let")
                (list
                  :let
                  (map hk-desugar (nth q 1))
                  (hk-lc-desugar e (rest quals))))
              (:else
                (raise
                  (str
                    "hk-lc-desugar: unknown qualifier tag "
                    qtag))))))))))
 (define
  hk-desugar
  (fn
    (node)
    (cond
      ((not (list? node)) node)
      ((empty? node) node)
      (:else
        (let
          ((tag (first node)))
          (cond
            ;; Transformations
            ((= tag "where")
              (list
                :let
                (map hk-desugar (nth node 2))
                (hk-desugar (nth node 1))))
            ((= tag "guarded") (hk-guards-to-if (nth node 1)))
            ((= tag "list-comp")
              (hk-lc-desugar
                (hk-desugar (nth node 1))
                (nth node 2)))
            ;; Expression nodes
            ((= tag "app")
              (list
                :app
                (hk-desugar (nth node 1))
                (hk-desugar (nth node 2))))
            ((= tag "op")
              (list
                :op
                (nth node 1)
                (hk-desugar (nth node 2))
                (hk-desugar (nth node 3))))
            ((= tag "neg") (list :neg (hk-desugar (nth node 1))))
            ((= tag "if")
              (list
                :if
                (hk-desugar (nth node 1))
                (hk-desugar (nth node 2))
                (hk-desugar (nth node 3))))
            ((= tag "tuple")
              (list :tuple (map hk-desugar (nth node 1))))
            ((= tag "list")
              (list :list (map hk-desugar (nth node 1))))
            ((= tag "range")
              (list
                :range
                (hk-desugar (nth node 1))
                (hk-desugar (nth node 2))))
            ((= tag "range-step")
              (list
                :range-step
                (hk-desugar (nth node 1))
                (hk-desugar (nth node 2))
                (hk-desugar (nth node 3))))
            ((= tag "lambda")
              (list
                :lambda
                (nth node 1)
                (hk-desugar (nth node 2))))
            ((= tag "let")
              (list
                :let
                (map hk-desugar (nth node 1))
                (hk-desugar (nth node 2))))
            ((= tag "case")
              (list
                :case
                (hk-desugar (nth node 1))
                (map hk-desugar (nth node 2))))
            ((= tag "alt")
              (list :alt (nth node 1) (hk-desugar (nth node 2))))
            ((= tag "do") (hk-desugar-do (nth node 1)))
            ((= tag "sect-left")
              (list
                :sect-left
                (nth node 1)
                (hk-desugar (nth node 2))))
            ((= tag "sect-right")
              (list
                :sect-right
                (nth node 1)
                (hk-desugar (nth node 2))))
            ;; Top-level
            ((= tag "program")
              (list :program (map hk-desugar (nth node 1))))
            ((= tag "module")
              (list
                :module
                (nth node 1)
                (nth node 2)
                (nth node 3)
                (map hk-desugar (nth node 4))))
            ;; Decls carrying a body
            ((= tag "fun-clause")
              (list
                :fun-clause
                (nth node 1)
                (nth node 2)
                (hk-desugar (nth node 3))))
            ((= tag "pat-bind")
              (list
                :pat-bind
                (nth node 1)
                (hk-desugar (nth node 2))))
            ((= tag "bind")
              (list
                :bind
                (nth node 1)
                (hk-desugar (nth node 2))))
            ;; Everything else: leaf literals, vars, cons, patterns,
            ;; types, imports, type-sigs, data / newtype / fixity, …
            (:else node)))))))
 ;; Convenience — tokenize + layout + parse + desugar.
 (define
  hk-core
  (fn (src) (hk-desugar (hk-parse-top src))))
 (define
  hk-core-expr
  (fn (src) (hk-desugar (hk-parse src))))
--- a/lib/haskell/eval.sx
+++ b/lib/haskell/eval.sx
@@ -1,792 +0,0 @@
 ;; Haskell strict evaluator (Phase 2).
 ;;
 ;; Consumes the post-desugar core AST and produces SX values. Strict
 ;; throughout — laziness and thunks are Phase 3.
 ;;
 ;; Value representation:
 ;;   numbers / strings / chars      → raw SX values
 ;;   constructor values             → tagged lists (con-name first)
 ;;   functions: closure / multifun  → {:type "fn" :kind … …}
 ;;   constructor partials           → {:type "con-partial" …}
 ;;   built-ins                      → {:type "builtin" …}
 ;;
 ;; Multi-clause top-level definitions are bundled into a single
 ;; multifun keyed by name; arguments are gathered through currying
 ;; until arity is reached, then each clause's pattern list is matched
 ;; in order. Recursive let bindings work because the binding env is
 ;; built mutably so closures captured during evaluation see the
 ;; eventual full env.
 (define
  hk-dict-copy
  (fn
    (d)
    (let ((nd (dict)))
      (for-each
        (fn (k) (dict-set! nd k (get d k)))
        (keys d))
      nd)))
 ;; ── Thunks (Phase 3 — laziness) ─────────────────────────────
 ;; A thunk wraps an unevaluated AST plus the env in which it was
 ;; created. The first call to `hk-force` evaluates the body, replaces
 ;; the body with the cached value, and flips `forced`. Subsequent
 ;; forces return the cached value directly.
 (define
  hk-mk-thunk
  (fn
    (body env)
    {:type "thunk" :body body :env env :forced false :value nil}))
 (define
  hk-is-thunk?
  (fn (v) (and (dict? v) (= (get v "type") "thunk"))))
 (define
  hk-force
  (fn
    (v)
    (cond
      ((hk-is-thunk? v)
        (cond
          ((get v "forced") (get v "value"))
          (:else
            (let
              ((res (hk-force (hk-eval (get v "body") (get v "env")))))
              (dict-set! v "forced" true)
              (dict-set! v "value" res)
              res))))
      (:else v))))
 ;; Recursive force — used at the test/output boundary so test
 ;; expectations can compare against fully-evaluated structures.
 (define
  hk-deep-force
  (fn
    (v)
    (let ((fv (hk-force v)))
      (cond
        ((not (list? fv)) fv)
        ((empty? fv) fv)
        (:else (map hk-deep-force fv))))))
 ;; ── Function value constructors ──────────────────────────────
 (define
  hk-mk-closure
  (fn
    (params body env)
    {:type "fn" :kind "closure" :params params :body body :env env}))
 (define
  hk-mk-multifun
  (fn
    (arity clauses env)
    {:type "fn" :kind "multi" :arity arity :clauses clauses :env env :collected (list)}))
 (define
  hk-mk-builtin
  (fn
    (name fn arity)
    {:type "builtin" :name name :fn fn :arity arity :lazy false :collected (list)}))
 ;; A lazy built-in receives its collected args as raw thunks (or
 ;; values, if those happened to be eager) — the implementation is
 ;; responsible for forcing exactly what it needs. Used for `seq`
 ;; and `deepseq`, which are non-strict in their second argument.
 (define
  hk-mk-lazy-builtin
  (fn
    (name fn arity)
    {:type "builtin" :name name :fn fn :arity arity :lazy true :collected (list)}))
 ;; ── Apply a function value to one argument ──────────────────
 (define
  hk-apply
  (fn
    (f arg)
    (let ((f (hk-force f)))
      (cond
        ((not (dict? f))
          (raise (str "apply: not a function value: " f)))
        ((= (get f "type") "fn")
          (cond
            ((= (get f "kind") "closure") (hk-apply-closure f arg))
            ((= (get f "kind") "multi") (hk-apply-multi f arg))
            (:else (raise "apply: unknown fn kind"))))
        ((= (get f "type") "con-partial") (hk-apply-con-partial f arg))
        ((= (get f "type") "builtin") (hk-apply-builtin f arg))
        (:else (raise "apply: not a function dict"))))))
 (define
  hk-apply-closure
  (fn
    (cl arg)
    (let
      ((params (get cl "params"))
        (body (get cl "body"))
        (env (get cl "env")))
      (cond
        ((empty? params) (raise "apply-closure: no params"))
        (:else
          (let
            ((p1 (first params)) (rest-p (rest params)))
            (let
              ((env-after (hk-match p1 arg env)))
              (cond
                ((nil? env-after)
                  (raise "pattern match failure in lambda"))
                ((empty? rest-p) (hk-eval body env-after))
                (:else
                  (hk-mk-closure rest-p body env-after))))))))))
 (define
  hk-apply-multi
  (fn
    (mf arg)
    (let
      ((arity (get mf "arity"))
        (clauses (get mf "clauses"))
        (env (get mf "env"))
        (collected (append (get mf "collected") (list arg))))
      (cond
        ((< (len collected) arity)
          (assoc mf "collected" collected))
        (:else (hk-dispatch-multi clauses collected env))))))
 (define
  hk-dispatch-multi
  (fn
    (clauses args env)
    (cond
      ((empty? clauses)
        (raise "non-exhaustive patterns in function definition"))
      (:else
        (let
          ((c (first clauses)))
          (let
            ((pats (first c)) (body (first (rest c))))
            (let
              ((env-after (hk-match-args pats args env)))
              (cond
                ((nil? env-after)
                  (hk-dispatch-multi (rest clauses) args env))
                (:else (hk-eval body env-after))))))))))
 (define
  hk-match-args
  (fn
    (pats args env)
    (cond
      ((empty? pats) env)
      (:else
        (let
          ((res (hk-match (first pats) (first args) env)))
          (cond
            ((nil? res) nil)
            (:else
              (hk-match-args (rest pats) (rest args) res))))))))
 (define
  hk-apply-con-partial
  (fn
    (cp arg)
    (let
      ((name (get cp "name"))
        (arity (get cp "arity"))
        (args (append (get cp "args") (list arg))))
      (cond
        ((= (len args) arity) (hk-mk-con name args))
        (:else (assoc cp "args" args))))))
 (define
  hk-apply-builtin
  (fn
    (b arg)
    (let
      ((arity (get b "arity"))
        (collected (append (get b "collected") (list arg))))
      (cond
        ((< (len collected) arity)
          (assoc b "collected" collected))
        (:else
          ;; Strict built-ins force every collected arg before
          ;; calling. Lazy ones (`seq`, `deepseq`) receive the raw
          ;; thunks so they can choose what to force.
          (cond
            ((get b "lazy") (apply (get b "fn") collected))
            (:else
              (apply
                (get b "fn")
                (map hk-force collected)))))))))
 ;; ── Bool helpers (Bool values are tagged conses) ────────────
 (define
  hk-truthy?
  (fn
    (v)
    (and (list? v) (not (empty? v)) (= (first v) "True"))))
 (define hk-true (hk-mk-con "True" (list)))
 (define hk-false (hk-mk-con "False" (list)))
 (define hk-of-bool (fn (b) (if b hk-true hk-false)))
 ;; ── Core eval ───────────────────────────────────────────────
 (define
  hk-eval
  (fn
    (node env)
    (cond
      ((not (list? node)) (raise (str "eval: not a list: " node)))
      ((empty? node) (raise "eval: empty list node"))
      (:else
        (let
          ((tag (first node)))
          (cond
            ((= tag "int") (nth node 1))
            ((= tag "float") (nth node 1))
            ((= tag "string") (nth node 1))
            ((= tag "char") (nth node 1))
            ((= tag "var") (hk-eval-var (nth node 1) env))
            ((= tag "con") (hk-eval-con-ref (nth node 1)))
            ((= tag "neg")
              (- 0 (hk-force (hk-eval (nth node 1) env))))
            ((= tag "if") (hk-eval-if node env))
            ((= tag "let") (hk-eval-let (nth node 1) (nth node 2) env))
            ((= tag "lambda")
              (hk-mk-closure (nth node 1) (nth node 2) env))
            ((= tag "app")
              (hk-apply
                (hk-eval (nth node 1) env)
                (hk-mk-thunk (nth node 2) env)))
            ((= tag "op")
              (hk-eval-op
                (nth node 1)
                (nth node 2)
                (nth node 3)
                env))
            ((= tag "case")
              (hk-eval-case (nth node 1) (nth node 2) env))
            ((= tag "tuple")
              (hk-mk-tuple
                (map (fn (e) (hk-eval e env)) (nth node 1))))
            ((= tag "list")
              (hk-mk-list
                (map (fn (e) (hk-eval e env)) (nth node 1))))
            ((= tag "range")
              (let
                ((from (hk-force (hk-eval (nth node 1) env)))
                  (to (hk-force (hk-eval (nth node 2) env))))
                (hk-build-range from to 1)))
            ((= tag "range-step")
              (let
                ((from (hk-force (hk-eval (nth node 1) env)))
                  (nxt (hk-force (hk-eval (nth node 2) env)))
                  (to (hk-force (hk-eval (nth node 3) env))))
                (hk-build-range from to (- nxt from))))
            ((= tag "range-from")
              ;; [from..] = iterate (+ 1) from — uses the Prelude.
              (hk-eval
                (list
                  :app
                  (list
                    :app
                    (list :var "iterate")
                    (list
                      :sect-right
                      "+"
                      (list :int 1)))
                  (nth node 1))
                env))
            ((= tag "sect-left")
              (hk-eval-sect-left (nth node 1) (nth node 2) env))
            ((= tag "sect-right")
              (hk-eval-sect-right (nth node 1) (nth node 2) env))
            (:else
              (raise (str "eval: unknown node tag '" tag "'")))))))))
 (define
  hk-eval-var
  (fn
    (name env)
    (cond
      ((has-key? env name) (get env name))
      ((hk-is-con? name) (hk-eval-con-ref name))
      (:else (raise (str "unbound variable: " name))))))
 (define
  hk-eval-con-ref
  (fn
    (name)
    (let ((arity (hk-con-arity name)))
      (cond
        ((nil? arity) (raise (str "unknown constructor: " name)))
        ((= arity 0) (hk-mk-con name (list)))
        (:else
          {:type "con-partial" :name name :arity arity :args (list)})))))
 (define
  hk-eval-if
  (fn
    (node env)
    (let ((cv (hk-force (hk-eval (nth node 1) env))))
      (cond
        ((hk-truthy? cv) (hk-eval (nth node 2) env))
        ((and (list? cv) (= (first cv) "False"))
          (hk-eval (nth node 3) env))
        ((= cv true) (hk-eval (nth node 2) env))
        ((= cv false) (hk-eval (nth node 3) env))
        (:else (raise "if: condition is not Bool"))))))
 (define
  hk-extend-env-with-match!
  (fn
    (env match-env)
    (for-each
      (fn (k) (dict-set! env k (get match-env k)))
      (keys match-env))))
 (define
  hk-eval-let-bind!
  (fn
    (b env)
    (let ((tag (first b)))
      (cond
        ((= tag "fun-clause")
          (let
            ((name (nth b 1))
              (pats (nth b 2))
              (body (nth b 3)))
            (cond
              ((empty? pats)
                (dict-set! env name (hk-eval body env)))
              (:else
                (dict-set! env name (hk-mk-closure pats body env))))))
        ((or (= tag "bind") (= tag "pat-bind"))
          (let ((pat (nth b 1)) (body (nth b 2)))
            (let ((val (hk-eval body env)))
              (let ((res (hk-match pat val env)))
                (cond
                  ((nil? res)
                    (raise "let: pattern bind failure"))
                  (:else
                    (hk-extend-env-with-match! env res)))))))
        (:else nil)))))
 (define
  hk-eval-let
  (fn
    (binds body env)
    ;; Reuse hk-bind-decls! so multi-clause fun bindings in where/let
    ;; are grouped into multifuns, enabling patterns like:
    ;;   let { go 0 = [[]]; go k = [...] } in go n
    (let ((new-env (hk-dict-copy env)))
      (hk-bind-decls! new-env binds)
      (hk-eval body new-env))))
 (define
  hk-eval-case
  (fn
    (scrut alts env)
    (let ((sv (hk-force (hk-eval scrut env))))
      (hk-try-alts alts sv env))))
 (define
  hk-try-alts
  (fn
    (alts val env)
    (cond
      ((empty? alts) (raise "case: non-exhaustive patterns"))
      (:else
        (let
          ((alt (first alts)))
          (let
            ((pat (nth alt 1)) (body (nth alt 2)))
            (let
              ((res (hk-match pat val env)))
              (cond
                ((nil? res) (hk-try-alts (rest alts) val env))
                (:else (hk-eval body res))))))))))
 (define
  hk-eval-op
  (fn
    (op left right env)
    (cond
      ;; Cons is non-strict in both args: build a cons cell whose
      ;; head and tail are deferred. This is what makes `repeat x =
      ;; x : repeat x` and `fibs = 0 : 1 : zipWith (+) fibs (tail
      ;; fibs)` terminate.
      ((= op ":")
        (hk-mk-cons
          (hk-mk-thunk left env)
          (hk-mk-thunk right env)))
      (:else
        (let
          ((lv (hk-force (hk-eval left env)))
            (rv (hk-force (hk-eval right env))))
          (hk-binop op lv rv))))))
 (define
  hk-list-append
  (fn
    (a b)
    (cond
      ((and (list? a) (= (first a) "[]")) b)
      ((and (list? a) (= (first a) ":"))
        (hk-mk-cons (nth a 1) (hk-list-append (nth a 2) b)))
      (:else (raise "++: not a list")))))
 ;; Eager finite-range spine — handles [from..to] and [from,next..to].
 ;; Step direction is governed by the sign of `step`; when step > 0 we
 ;; stop at to; when step < 0 we stop at to going down.
 (define
  hk-build-range
  (fn
    (from to step)
    (cond
      ((and (> step 0) (> from to)) (hk-mk-nil))
      ((and (< step 0) (< from to)) (hk-mk-nil))
      ((= step 0) (hk-mk-nil))
      (:else
        (hk-mk-cons from (hk-build-range (+ from step) to step))))))
 (define
  hk-binop
  (fn
    (op lv rv)
    (cond
      ((= op "+") (+ lv rv))
      ((= op "-") (- lv rv))
      ((= op "*") (* lv rv))
      ((= op "/") (/ lv rv))
      ((= op "==") (hk-of-bool (= lv rv)))
      ((= op "/=") (hk-of-bool (not (= lv rv))))
      ((= op "<") (hk-of-bool (< lv rv)))
      ((= op "<=") (hk-of-bool (<= lv rv)))
      ((= op ">") (hk-of-bool (> lv rv)))
      ((= op ">=") (hk-of-bool (>= lv rv)))
      ((= op "&&") (hk-of-bool (and (hk-truthy? lv) (hk-truthy? rv))))
      ((= op "||") (hk-of-bool (or (hk-truthy? lv) (hk-truthy? rv))))
      ((= op ":") (hk-mk-cons lv rv))
      ((= op "++") (hk-list-append lv rv))
      ((= op "mod") (mod lv rv))
      ((= op "div") (floor (/ lv rv)))
      ((= op "rem") (mod lv rv))
      ((= op "quot") (truncate (/ lv rv)))
      (:else (raise (str "unknown operator: " op))))))
 (define
  hk-eval-sect-left
  (fn
    (op e env)
    ;; (e op) = \x -> e op x — bind e once, defer the operator call.
    (let ((ev (hk-eval e env)))
      (let ((cenv (hk-dict-copy env)))
        (dict-set! cenv "__hk-sect-l" ev)
        (hk-mk-closure
          (list (list :p-var "__hk-sect-x"))
          (list
            :op
            op
            (list :var "__hk-sect-l")
            (list :var "__hk-sect-x"))
          cenv)))))
 (define
  hk-eval-sect-right
  (fn
    (op e env)
    (let ((ev (hk-eval e env)))
      (let ((cenv (hk-dict-copy env)))
        (dict-set! cenv "__hk-sect-r" ev)
        (hk-mk-closure
          (list (list :p-var "__hk-sect-x"))
          (list
            :op
            op
            (list :var "__hk-sect-x")
            (list :var "__hk-sect-r"))
          cenv)))))
 ;; ── Top-level program evaluation ────────────────────────────
 ;; Operator-as-value built-ins — let `(+)`, `(*)`, etc. work as
 ;; first-class functions for `zipWith (+)` and friends. Strict in
 ;; both args (built-ins are forced via hk-apply-builtin).
 (define
  hk-make-binop-builtin
  (fn
    (name op-name)
    (hk-mk-builtin
      name
      (fn (a b) (hk-binop op-name a b))
      2)))
 ;; Inline Prelude source — loaded into the initial env so simple
 ;; programs can use `head`, `take`, `repeat`, etc. without each
 ;; user file redefining them. The Prelude itself uses lazy `:` for
 ;; the recursive list-building functions.
 (define
  hk-prelude-src
  "head (x:_) = x
 tail (_:xs) = xs
 fst (a, _) = a
 snd (_, b) = b
 take 0 _ = []
 take _ [] = []
 take n (x:xs) = x : take (n - 1) xs
 drop 0 xs = xs
 drop _ [] = []
 drop n (_:xs) = drop (n - 1) xs
 repeat x = x : repeat x
 iterate f x = x : iterate f (f x)
 length [] = 0
 length (_:xs) = 1 + length xs
 map _ [] = []
 map f (x:xs) = f x : map f xs
 filter _ [] = []
 filter p (x:xs) = if p x then x : filter p xs else filter p xs
 zipWith _ [] _ = []
 zipWith _ _ [] = []
 zipWith f (x:xs) (y:ys) = f x y : zipWith f xs ys
 fibs = 0 : 1 : zipWith plus fibs (tail fibs)
 plus a b = a + b
 concat [] = []
 concat (xs:xss) = xs ++ concat xss
 concatMap f [] = []
 concatMap f (x:xs) = f x ++ concatMap f xs
 abs x = if x < 0 then 0 - x else x
 negate x = 0 - x
 ")
 (define
  hk-load-into!
  (fn
    (env src)
    (let ((ast (hk-core src)))
      (hk-register-program! ast)
      (let
        ((decls
            (cond
              ((= (first ast) "program") (nth ast 1))
              ((= (first ast) "module") (nth ast 4))
              (:else (list)))))
        (hk-bind-decls! env decls)))))
 (define
  hk-init-env
  (fn
    ()
    (let ((env (dict)))
      (dict-set! env "otherwise" hk-true)
      (dict-set!
        env
        "error"
        (hk-mk-builtin
          "error"
          (fn (msg) (raise (str "*** Exception: " msg)))
          1))
      (dict-set!
        env
        "not"
        (hk-mk-builtin
          "not"
          (fn (b) (hk-of-bool (not (hk-truthy? b))))
          1))
      (dict-set!
        env
        "id"
        (hk-mk-builtin "id" (fn (x) x) 1))
      ;; `seq a b` — strict in `a`, lazy in `b`. Forces `a` to WHNF
      ;; and returns `b` unchanged (still a thunk if it was one).
      (dict-set!
        env
        "seq"
        (hk-mk-lazy-builtin
          "seq"
          (fn (a b) (do (hk-force a) b))
          2))
      ;; `deepseq a b` — like seq but forces `a` to normal form.
      (dict-set!
        env
        "deepseq"
        (hk-mk-lazy-builtin
          "deepseq"
          (fn (a b) (do (hk-deep-force a) b))
          2))
      ;; ── Stub IO monad ─────────────────────────────────────
      ;; IO actions are tagged values `("IO" payload)`; `>>=` and
      ;; `>>` chain them. Lazy in the action arguments so do-blocks
      ;; can be deeply structured without forcing the whole chain
      ;; up front.
      (dict-set!
        env
        "return"
        (hk-mk-lazy-builtin
          "return"
          (fn (x) (list "IO" x))
          1))
      (dict-set!
        env
        ">>="
        (hk-mk-lazy-builtin
          ">>="
          (fn (m f)
            (let ((io-val (hk-force m)))
              (cond
                ((and
                    (list? io-val)
                    (= (first io-val) "IO"))
                  (hk-apply (hk-force f) (nth io-val 1)))
                (:else
                  (raise "(>>=): left side is not an IO action")))))
          2))
      (dict-set!
        env
        ">>"
        (hk-mk-lazy-builtin
          ">>"
          (fn (m n)
            (let ((io-val (hk-force m)))
              (cond
                ((and
                    (list? io-val)
                    (= (first io-val) "IO"))
                  (hk-force n))
                (:else
                  (raise "(>>): left side is not an IO action")))))
          2))
      ;; Operators as first-class values
      (dict-set! env "+" (hk-make-binop-builtin "+" "+"))
      (dict-set! env "-" (hk-make-binop-builtin "-" "-"))
      (dict-set! env "*" (hk-make-binop-builtin "*" "*"))
      (dict-set! env "/" (hk-make-binop-builtin "/" "/"))
      (dict-set! env "==" (hk-make-binop-builtin "==" "=="))
      (dict-set! env "/=" (hk-make-binop-builtin "/=" "/="))
      (dict-set! env "<" (hk-make-binop-builtin "<" "<"))
      (dict-set! env "<=" (hk-make-binop-builtin "<=" "<="))
      (dict-set! env ">" (hk-make-binop-builtin ">" ">"))
      (dict-set! env ">=" (hk-make-binop-builtin ">=" ">="))
      (dict-set! env "&&" (hk-make-binop-builtin "&&" "&&"))
      (dict-set! env "||" (hk-make-binop-builtin "||" "||"))
      (dict-set! env "++" (hk-make-binop-builtin "++" "++"))
      (dict-set! env "mod" (hk-make-binop-builtin "mod" "mod"))
      (dict-set! env "div" (hk-make-binop-builtin "div" "div"))
      (dict-set! env "rem" (hk-make-binop-builtin "rem" "rem"))
      (dict-set! env "quot" (hk-make-binop-builtin "quot" "quot"))
      (hk-load-into! env hk-prelude-src)
      env)))
 (define
  hk-bind-decls!
  (fn
    (env decls)
    (let
      ((groups (dict))
        (group-order (list))
        (pat-binds (list)))
      ;; Pass 1: collect fun-clause groups by name; track first-seen
      ;; order so pass 3 can evaluate 0-arity bodies in source order
      ;; (forward references to other 0-arity definitions still need
      ;; the earlier name to be bound first).
      (for-each
        (fn (d)
          (cond
            ((= (first d) "fun-clause")
              (let
                ((name (nth d 1)))
                (when (not (has-key? groups name))
                  (append! group-order name))
                (dict-set!
                  groups
                  name
                  (append
                    (if
                      (has-key? groups name)
                      (get groups name)
                      (list))
                    (list (list (nth d 2) (nth d 3)))))
                (when
                  (not (has-key? env name))
                  (dict-set! env name nil))))
            ((or (= (first d) "bind") (= (first d) "pat-bind"))
              (append! pat-binds d))
            (:else nil)))
        decls)
      ;; Pass 2: install multifuns (arity > 0) — order doesn't matter
      ;; because they're closures; collect 0-arity names in source
      ;; order for pass 3.
      (let ((zero-arity (list)))
        (for-each
          (fn (name)
            (let ((clauses (get groups name)))
              (let ((arity (len (first (first clauses)))))
                (cond
                  ((> arity 0)
                    (dict-set!
                      env
                      name
                      (hk-mk-multifun arity clauses env)))
                  (:else (append! zero-arity name))))))
          group-order)
        ;; Pass 3: evaluate 0-arity bodies and pat-binds in source
        ;; order — forward references to a later 0-arity name will
        ;; still see its placeholder (nil) and fail noisily, but the
        ;; common case of a top-down program works.
        (for-each
          (fn (name)
            (let ((clauses (get groups name)))
              (dict-set!
                env
                name
                (hk-eval (first (rest (first clauses))) env))))
          zero-arity)
        (for-each
          (fn (d)
            (let ((pat (nth d 1)) (body (nth d 2)))
              (let ((val (hk-eval body env)))
                (let ((res (hk-match pat val env)))
                  (cond
                    ((nil? res)
                      (raise "top-level pattern bind failure"))
                    (:else (hk-extend-env-with-match! env res)))))))
          pat-binds))
      env)))
 (define
  hk-eval-program
  (fn
    (ast)
    (cond
      ((nil? ast) (raise "eval-program: nil ast"))
      ((not (list? ast)) (raise "eval-program: not a list"))
      (:else
        (do
          (hk-register-program! ast)
          (let ((env (hk-init-env)))
            (let
              ((decls
                  (cond
                    ((= (first ast) "program") (nth ast 1))
                    ((= (first ast) "module") (nth ast 4))
                    (:else (raise "eval-program: bad shape")))))
              (hk-bind-decls! env decls))))))))
 ;; ── Source-level convenience ────────────────────────────────
 (define
  hk-run
  (fn
    (src)
    (let ((env (hk-eval-program (hk-core src))))
      (cond
        ((has-key? env "main") (get env "main"))
        (:else env)))))
 ;; Eagerly build the Prelude env once at load time; each call to
 ;; hk-eval-expr-source copies it instead of re-parsing the whole Prelude.
 (define hk-env0 (hk-init-env))
 (define
  hk-eval-expr-source
  (fn
    (src)
    (hk-deep-force (hk-eval (hk-core-expr src) (hk-dict-copy hk-env0)))))
--- a/lib/haskell/layout.sx
+++ b/lib/haskell/layout.sx
@@ -1,329 +0,0 @@
 ;; Haskell 98 layout algorithm (§10.3).
 ;;
 ;; Consumes the raw token stream produced by hk-tokenize and inserts
 ;; virtual braces / semicolons (types vlbrace / vrbrace / vsemi) based
 ;; on indentation. Newline tokens are consumed and stripped.
 ;;
 ;;   (hk-layout (hk-tokenize src))  →  tokens-with-virtual-layout
 ;; ── Pre-pass ──────────────────────────────────────────────────────
 ;;
 ;; Walks the raw token list and emits an augmented stream containing
 ;; two fresh pseudo-tokens:
 ;;
 ;;   {:type "layout-open"   :col N :keyword K}
 ;;     At stream start (K = "<module>") unless the first real token is
 ;;     `module` or `{`. Also immediately after every `let` / `where` /
 ;;     `do` / `of` whose following token is NOT `{`. N is the column
 ;;     of the token that follows.
 ;;
 ;;   {:type "layout-indent" :col N}
 ;;     Before any token whose line is strictly greater than the line
 ;;     of the previously emitted real token, EXCEPT when that token
 ;;     is already preceded by a layout-open (Haskell 98 §10.3 note 3).
 ;;
 ;; Raw newline tokens are dropped.
 (define
  hk-layout-keyword?
  (fn
    (tok)
    (and
      (= (get tok "type") "reserved")
      (or
        (= (get tok "value") "let")
        (= (get tok "value") "where")
        (= (get tok "value") "do")
        (= (get tok "value") "of")))))
 (define
  hk-layout-pre
  (fn
    (tokens)
    (let
      ((result (list))
        (n (len tokens))
        (i 0)
        (prev-line -1)
        (first-real-emitted false)
        (suppress-next-indent false))
      (define
        hk-next-real-idx
        (fn
          (start)
          (let
            ((j start))
            (define
              hk-nri-loop
              (fn
                ()
                (when
                  (and
                    (< j n)
                    (= (get (nth tokens j) "type") "newline"))
                  (do (set! j (+ j 1)) (hk-nri-loop)))))
            (hk-nri-loop)
            j)))
      (define
        hk-pre-step
        (fn
          ()
          (when
            (< i n)
            (let
              ((tok (nth tokens i)) (ty (get tok "type")))
              (cond
                ((= ty "newline") (do (set! i (+ i 1)) (hk-pre-step)))
                (:else
                  (do
                    (when
                      (not first-real-emitted)
                      (do
                        (set! first-real-emitted true)
                        (when
                          (not
                            (or
                              (and
                                (= ty "reserved")
                                (= (get tok "value") "module"))
                              (= ty "lbrace")))
                          (do
                            (append!
                              result
                              {:type "layout-open"
                                :col (get tok "col")
                                :keyword "<module>"
                                :line (get tok "line")})
                            (set! suppress-next-indent true)))))
                    (when
                      (and
                        (>= prev-line 0)
                        (> (get tok "line") prev-line)
                        (not suppress-next-indent))
                      (append!
                        result
                        {:type "layout-indent"
                          :col (get tok "col")
                          :line (get tok "line")}))
                    (set! suppress-next-indent false)
                    (set! prev-line (get tok "line"))
                    (append! result tok)
                    (when
                      (hk-layout-keyword? tok)
                      (let
                        ((j (hk-next-real-idx (+ i 1))))
                        (cond
                          ((>= j n)
                            (do
                              (append!
                                result
                                {:type "layout-open"
                                  :col 0
                                  :keyword (get tok "value")
                                  :line (get tok "line")})
                              (set! suppress-next-indent true)))
                          ((= (get (nth tokens j) "type") "lbrace") nil)
                          (:else
                            (do
                              (append!
                                result
                                {:type "layout-open"
                                  :col (get (nth tokens j) "col")
                                  :keyword (get tok "value")
                                  :line (get tok "line")})
                              (set! suppress-next-indent true))))))
                    (set! i (+ i 1))
                    (hk-pre-step))))))))
      (hk-pre-step)
      result)))
 ;; ── Main pass: L algorithm ────────────────────────────────────────
 ;;
 ;; Stack is a list; the head is the top of stack. Each entry is
 ;; either the keyword :explicit (pushed by an explicit `{`) or a dict
 ;; {:col N :keyword K} pushed by a layout-open marker.
 ;;
 ;; Rules (following Haskell 98 §10.3):
 ;;
 ;;   layout-open(n)  vs stack:
 ;;     empty or explicit top                 → push n; emit {
 ;;     n > top-col                           → push n; emit {
 ;;     otherwise                             → emit { }; retry as indent(n)
 ;;
 ;;   layout-indent(n) vs stack:
 ;;     empty or explicit top                 → drop
 ;;     n == top-col                          → emit ;
 ;;     n <  top-col                          → emit }; pop; recurse
 ;;     n >  top-col                          → drop
 ;;
 ;;   lbrace                                  → push :explicit; emit {
 ;;   rbrace                                  → pop if :explicit; emit }
 ;;   `in` with implicit let on top           → emit }; pop; emit in
 ;;   any other token                         → emit
 ;;
 ;; EOF: emit } for every remaining implicit context.
 (define
  hk-layout-L
  (fn
    (pre-toks)
    (let
      ((result (list))
        (stack (list))
        (n (len pre-toks))
        (i 0))
      (define hk-emit (fn (t) (append! result t)))
      (define
        hk-indent-at
        (fn
          (col line)
          (cond
            ((or (empty? stack) (= (first stack) :explicit)) nil)
            (:else
              (let
                ((top-col (get (first stack) "col")))
                (cond
                  ((= col top-col)
                    (hk-emit
                      {:type "vsemi" :value ";" :line line :col col}))
                  ((< col top-col)
                    (do
                      (hk-emit
                        {:type "vrbrace" :value "}" :line line :col col})
                      (set! stack (rest stack))
                      (hk-indent-at col line)))
                  (:else nil)))))))
      (define
        hk-open-at
        (fn
          (col keyword line)
          (cond
            ((and
                (> col 0)
                (or
                  (empty? stack)
                  (= (first stack) :explicit)
                  (> col (get (first stack) "col"))))
              (do
                (hk-emit
                  {:type "vlbrace" :value "{" :line line :col col})
                (set! stack (cons {:col col :keyword keyword} stack))))
            (:else
              (do
                (hk-emit
                  {:type "vlbrace" :value "{" :line line :col col})
                (hk-emit
                  {:type "vrbrace" :value "}" :line line :col col})
                (hk-indent-at col line))))))
      (define
        hk-close-eof
        (fn
          ()
          (when
            (and
              (not (empty? stack))
              (not (= (first stack) :explicit)))
            (do
              (hk-emit {:type "vrbrace" :value "}" :line 0 :col 0})
              (set! stack (rest stack))
              (hk-close-eof)))))
      ;; Peek past further layout-indent / layout-open markers to find
      ;; the next real token's value when its type is `reserved`.
      ;; Returns nil if no such token.
      (define
        hk-peek-next-reserved
        (fn
          (start)
          (let ((j (+ start 1)) (found nil) (done false))
            (define
              hk-pnr-loop
              (fn
                ()
                (when
                  (and (not done) (< j n))
                  (let
                    ((t (nth pre-toks j)) (ty (get t "type")))
                    (cond
                      ((or
                          (= ty "layout-indent")
                          (= ty "layout-open"))
                        (do (set! j (+ j 1)) (hk-pnr-loop)))
                      ((= ty "reserved")
                        (do (set! found (get t "value")) (set! done true)))
                      (:else (set! done true)))))))
            (hk-pnr-loop)
            found)))
      (define
        hk-layout-step
        (fn
          ()
          (when
            (< i n)
            (let
              ((tok (nth pre-toks i)) (ty (get tok "type")))
              (cond
                ((= ty "eof")
                  (do
                    (hk-close-eof)
                    (hk-emit tok)
                    (set! i (+ i 1))
                    (hk-layout-step)))
                ((= ty "layout-open")
                  (do
                    (hk-open-at
                      (get tok "col")
                      (get tok "keyword")
                      (get tok "line"))
                    (set! i (+ i 1))
                    (hk-layout-step)))
                ((= ty "layout-indent")
                  (cond
                    ((= (hk-peek-next-reserved i) "in")
                      (do (set! i (+ i 1)) (hk-layout-step)))
                    (:else
                      (do
                        (hk-indent-at (get tok "col") (get tok "line"))
                        (set! i (+ i 1))
                        (hk-layout-step)))))
                ((= ty "lbrace")
                  (do
                    (set! stack (cons :explicit stack))
                    (hk-emit tok)
                    (set! i (+ i 1))
                    (hk-layout-step)))
                ((= ty "rbrace")
                  (do
                    (when
                      (and
                        (not (empty? stack))
                        (= (first stack) :explicit))
                      (set! stack (rest stack)))
                    (hk-emit tok)
                    (set! i (+ i 1))
                    (hk-layout-step)))
                ((and
                    (= ty "reserved")
                    (= (get tok "value") "in")
                    (not (empty? stack))
                    (not (= (first stack) :explicit))
                    (= (get (first stack) "keyword") "let"))
                  (do
                    (hk-emit
                      {:type "vrbrace"
                        :value "}"
                        :line (get tok "line")
                        :col (get tok "col")})
                    (set! stack (rest stack))
                    (hk-emit tok)
                    (set! i (+ i 1))
                    (hk-layout-step)))
                (:else
                  (do
                    (hk-emit tok)
                    (set! i (+ i 1))
                    (hk-layout-step))))))))
      (hk-layout-step)
      (hk-close-eof)
      result)))
 (define hk-layout (fn (tokens) (hk-layout-L (hk-layout-pre tokens))))
--- a/lib/haskell/match.sx
+++ b/lib/haskell/match.sx
@@ -1,201 +0,0 @@
 ;; Value-level pattern matching.
 ;;
 ;; Constructor values are tagged lists whose first element is the
 ;; constructor name (a string). Tuples use the special tag "Tuple".
 ;; Lists use the spine of `:` cons and `[]` nil.
 ;;
 ;;   Just 5         →  ("Just" 5)
 ;;   Nothing        →  ("Nothing")
 ;;   (1, 2)         →  ("Tuple" 1 2)
 ;;   [1, 2]         →  (":" 1 (":" 2 ("[]")))
 ;;   ()             →  ("()")
 ;;
 ;; Primitive values (numbers, strings, chars) are stored raw.
 ;;
 ;; The matcher takes a pattern AST node, a value, and an environment
 ;; dict; it returns an extended dict on success, or `nil` on failure.
 ;; ── Value builders ──────────────────────────────────────────
 (define
  hk-mk-con
  (fn
    (cname args)
    (let ((result (list cname)))
      (for-each (fn (a) (append! result a)) args)
      result)))
 (define
  hk-mk-tuple
  (fn
    (items)
    (let ((result (list "Tuple")))
      (for-each (fn (x) (append! result x)) items)
      result)))
 (define hk-mk-nil (fn () (list "[]")))
 (define hk-mk-cons (fn (h t) (list ":" h t)))
 (define
  hk-mk-list
  (fn
    (items)
    (cond
      ((empty? items) (hk-mk-nil))
      (:else
        (hk-mk-cons (first items) (hk-mk-list (rest items)))))))
 ;; ── Predicates / accessors on constructor values ───────────
 (define
  hk-is-con-val?
  (fn
    (v)
    (and
      (list? v)
      (not (empty? v))
      (string? (first v)))))
 (define hk-val-con-name (fn (v) (first v)))
 (define hk-val-con-args (fn (v) (rest v)))
 ;; ── The matcher ────────────────────────────────────────────
 ;;
 ;; Pattern match forces the scrutinee to WHNF before inspecting it
 ;; — except for `p-wild`, `p-var`, and `p-lazy`, which never need
 ;; to look at the value. Args of constructor / tuple / list values
 ;; remain thunked (they're forced only when their own pattern needs
 ;; to inspect them, recursively).
 (define
  hk-match
  (fn
    (pat val env)
    (cond
      ((not (list? pat)) nil)
      ((empty? pat) nil)
      (:else
        (let
          ((tag (first pat)))
          (cond
            ((= tag "p-wild") env)
            ((= tag "p-var") (assoc env (nth pat 1) val))
            ((= tag "p-lazy") (hk-match (nth pat 1) val env))
            ((= tag "p-as")
              (let
                ((res (hk-match (nth pat 2) val env)))
                (cond
                  ((nil? res) nil)
                  (:else (assoc res (nth pat 1) val)))))
            (:else
              (let ((fv (hk-force val)))
                (cond
                  ((= tag "p-int")
                    (if
                      (and (number? fv) (= fv (nth pat 1)))
                      env
                      nil))
                  ((= tag "p-float")
                    (if
                      (and (number? fv) (= fv (nth pat 1)))
                      env
                      nil))
                  ((= tag "p-string")
                    (if
                      (and (string? fv) (= fv (nth pat 1)))
                      env
                      nil))
                  ((= tag "p-char")
                    (if
                      (and (string? fv) (= fv (nth pat 1)))
                      env
                      nil))
                  ((= tag "p-con")
                    (let
                      ((pat-name (nth pat 1)) (pat-args (nth pat 2)))
                      (cond
                        ((not (hk-is-con-val? fv)) nil)
                        ((not (= (hk-val-con-name fv) pat-name)) nil)
                        (:else
                          (let
                            ((val-args (hk-val-con-args fv)))
                            (cond
                              ((not (= (len pat-args) (len val-args)))
                                nil)
                              (:else
                                (hk-match-all
                                  pat-args
                                  val-args
                                  env))))))))
                  ((= tag "p-tuple")
                    (let
                      ((items (nth pat 1)))
                      (cond
                        ((not (hk-is-con-val? fv)) nil)
                        ((not (= (hk-val-con-name fv) "Tuple")) nil)
                        ((not (= (len (hk-val-con-args fv)) (len items)))
                          nil)
                        (:else
                          (hk-match-all
                            items
                            (hk-val-con-args fv)
                            env)))))
                  ((= tag "p-list")
                    (hk-match-list-pat (nth pat 1) fv env))
                  (:else nil))))))))))
 (define
  hk-match-all
  (fn
    (pats vals env)
    (cond
      ((empty? pats) env)
      (:else
        (let
          ((res (hk-match (first pats) (first vals) env)))
          (cond
            ((nil? res) nil)
            (:else
              (hk-match-all (rest pats) (rest vals) res))))))))
 (define
  hk-match-list-pat
  (fn
    (items val env)
    (let ((fv (hk-force val)))
      (cond
        ((empty? items)
          (if
            (and
              (hk-is-con-val? fv)
              (= (hk-val-con-name fv) "[]"))
            env
            nil))
        (:else
          (cond
            ((not (hk-is-con-val? fv)) nil)
            ((not (= (hk-val-con-name fv) ":")) nil)
            (:else
              (let
                ((args (hk-val-con-args fv)))
                (let
                  ((h (first args)) (t (first (rest args))))
                  (let
                    ((res (hk-match (first items) h env)))
                    (cond
                      ((nil? res) nil)
                      (:else
                        (hk-match-list-pat
                          (rest items)
                          t
                          res)))))))))))))
 ;; ── Convenience: parse a pattern from source for tests ─────
 ;; (Uses the parser's case-alt entry — `case _ of pat -> 0` —
 ;; to extract a pattern AST.)
 (define
  hk-parse-pat-source
  (fn
    (src)
    (let
      ((expr (hk-parse (str "case 0 of " src " -> 0"))))
      (nth (nth (nth expr 2) 0) 1))))
--- a/lib/haskell/parser.sx
+++ b/lib/haskell/parser.sx
--- a/lib/haskell/runtime.sx
+++ b/lib/haskell/runtime.sx
@@ -1,130 +0,0 @@
 ;; Haskell runtime: constructor registry.
 ;;
 ;; A mutable dict keyed by constructor name (e.g. "Just", "[]") with
 ;; entries of shape  {:arity N :type TYPE-NAME-STRING}.
 ;; Populated by ingesting `data` / `newtype` decls from parsed ASTs.
 ;; Pre-registers a small set of constructors tied to Haskell syntactic
 ;; forms (Bool, list, unit) — every nontrivial program depends on
 ;; these, and the parser/desugar pipeline emits them as (:var "True")
 ;; etc. without a corresponding `data` decl.
 (define hk-constructors (dict))
 (define
  hk-register-con!
  (fn
    (cname arity type-name)
    (dict-set!
      hk-constructors
      cname
      {:arity arity :type type-name})))
 (define hk-is-con? (fn (name) (has-key? hk-constructors name)))
 (define
  hk-con-arity
  (fn
    (name)
    (if
      (has-key? hk-constructors name)
      (get (get hk-constructors name) "arity")
      nil)))
 (define
  hk-con-type
  (fn
    (name)
    (if
      (has-key? hk-constructors name)
      (get (get hk-constructors name) "type")
      nil)))
 (define hk-con-names (fn () (keys hk-constructors)))
 ;; ── Registration from AST ────────────────────────────────────
 ;; (:data NAME TVARS ((:con-def CNAME FIELDS) …))
 (define
  hk-register-data!
  (fn
    (data-node)
    (let
      ((type-name (nth data-node 1))
        (cons-list (nth data-node 3)))
      (for-each
        (fn
          (cd)
          (hk-register-con!
            (nth cd 1)
            (len (nth cd 2))
            type-name))
        cons-list))))
 ;; (:newtype NAME TVARS CNAME FIELD)
 (define
  hk-register-newtype!
  (fn
    (nt-node)
    (hk-register-con!
      (nth nt-node 3)
      1
      (nth nt-node 1))))
 ;; Walk a decls list, registering every `data` / `newtype` decl.
 (define
  hk-register-decls!
  (fn
    (decls)
    (for-each
      (fn
        (d)
        (cond
          ((and
              (list? d)
              (not (empty? d))
              (= (first d) "data"))
            (hk-register-data! d))
          ((and
              (list? d)
              (not (empty? d))
              (= (first d) "newtype"))
            (hk-register-newtype! d))
          (:else nil)))
      decls)))
 (define
  hk-register-program!
  (fn
    (ast)
    (cond
      ((nil? ast) nil)
      ((not (list? ast)) nil)
      ((empty? ast) nil)
      ((= (first ast) "program")
        (hk-register-decls! (nth ast 1)))
      ((= (first ast) "module")
        (hk-register-decls! (nth ast 4)))
      (:else nil))))
 ;; Convenience: source → AST → desugar → register.
 (define
  hk-load-source!
  (fn (src) (hk-register-program! (hk-core src))))
 ;; ── Built-in constructors pre-registered ─────────────────────
 ;; Bool — used implicitly by `if`, comparison operators.
 (hk-register-con! "True" 0 "Bool")
 (hk-register-con! "False" 0 "Bool")
 ;; List — used by list literals, range syntax, and cons operator.
 (hk-register-con! "[]" 0 "List")
 (hk-register-con! ":" 2 "List")
 ;; Unit — produced by empty parens `()`.
 (hk-register-con! "()" 0 "Unit")
 ;; Standard Prelude types — pre-registered so expression-level
 ;; programs can use them without a `data` decl.
 (hk-register-con! "Nothing" 0 "Maybe")
 (hk-register-con! "Just"    1 "Maybe")
 (hk-register-con! "Left"    1 "Either")
 (hk-register-con! "Right"   1 "Either")
 (hk-register-con! "LT" 0 "Ordering")
 (hk-register-con! "EQ" 0 "Ordering")
 (hk-register-con! "GT" 0 "Ordering")
--- a/lib/haskell/scoreboard.json
+++ b/lib/haskell/scoreboard.json
@@ -1,12 +0,0 @@
 {
  "date": "2026-04-25",
  "total_pass": 16,
  "total_fail": 0,
  "programs": {
    "fib": {"pass": 2, "fail": 0},
    "sieve": {"pass": 2, "fail": 0},
    "quicksort": {"pass": 5, "fail": 0},
    "nqueens": {"pass": 2, "fail": 0},
    "calculator": {"pass": 5, "fail": 0}
  }
 }
--- a/lib/haskell/scoreboard.md
+++ b/lib/haskell/scoreboard.md
@@ -1,12 +0,0 @@
 # Haskell-on-SX Scoreboard
 Updated 2026-04-25 · Phase 3 (laziness + classic programs)
 | Program | Tests | Status |
 |---------|-------|--------|
 | fib.hs | 2/2 | ✓ |
 | sieve.hs | 2/2 | ✓ |
 | quicksort.hs | 5/5 | ✓ |
 | nqueens.hs | 2/2 | ✓ |
 | calculator.hs | 5/5 | ✓ |
 | **Total** | **16/16** | **5/5 programs** |
--- a/lib/haskell/test.sh
+++ b/lib/haskell/test.sh
@@ -46,13 +46,6 @@ for FILE in "${FILES[@]}"; do
  cat > "$TMPFILE" <<EPOCHS
 (epoch 1)
 (load "lib/haskell/tokenizer.sx")
 (load "lib/haskell/layout.sx")
 (load "lib/haskell/parser.sx")
 (load "lib/haskell/desugar.sx")
 (load "lib/haskell/runtime.sx")
 (load "lib/haskell/match.sx")
 (load "lib/haskell/eval.sx")
 (load "lib/haskell/testlib.sx")
 (epoch 2)
 (load "$FILE")
 (epoch 3)
@@ -88,13 +81,6 @@ EPOCHS
    cat > "$TMPFILE2" <<EPOCHS
 (epoch 1)
 (load "lib/haskell/tokenizer.sx")
 (load "lib/haskell/layout.sx")
 (load "lib/haskell/parser.sx")
 (load "lib/haskell/desugar.sx")
 (load "lib/haskell/runtime.sx")
 (load "lib/haskell/match.sx")
 (load "lib/haskell/eval.sx")
 (load "lib/haskell/testlib.sx")
 (epoch 2)
 (load "$FILE")
 (epoch 3)
--- a/lib/haskell/testlib.sx
+++ b/lib/haskell/testlib.sx
@@ -1,58 +0,0 @@
 ;; Shared test harness for Haskell-on-SX tests.
 ;; Each test file expects hk-test / hk-deep=? / counters to already be bound.
 (define
  hk-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) (hk-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
              hk-de-loop
              (fn
                ()
                (when
                  (and ok (< i (len a)))
                  (do
                    (when
                      (not (hk-deep=? (nth a i) (nth b i)))
                      (set! ok false))
                    (set! i (+ i 1))
                    (hk-de-loop)))))
            (hk-de-loop)
            ok)))
      (:else false))))
 (define hk-test-pass 0)
 (define hk-test-fail 0)
 (define hk-test-fails (list))
 (define
  hk-test
  (fn
    (name actual expected)
    (if
      (hk-deep=? actual expected)
      (set! hk-test-pass (+ hk-test-pass 1))
      (do
        (set! hk-test-fail (+ hk-test-fail 1))
        (append!
          hk-test-fails
          {:actual actual :expected expected :name name})))))
--- a/lib/haskell/tests/desugar.sx
+++ b/lib/haskell/tests/desugar.sx
@@ -1,305 +0,0 @@
 ;; Desugar tests — surface AST → core AST.
 ;;   :guarded   →  nested :if
 ;;   :where     →  :let
 ;;   :list-comp →  concatMap-based tree
 (define
  hk-prog
  (fn (&rest decls) (list :program decls)))
 ;; ── Guards → if ──
 (hk-test
  "two-way guarded rhs"
  (hk-desugar (hk-parse-top "abs x | x < 0 = - x\n      | otherwise = x"))
  (hk-prog
    (list
      :fun-clause
      "abs"
      (list (list :p-var "x"))
      (list
        :if
        (list :op "<" (list :var "x") (list :int 0))
        (list :neg (list :var "x"))
        (list
          :if
          (list :var "otherwise")
          (list :var "x")
          (list
            :app
            (list :var "error")
            (list :string "Non-exhaustive guards")))))))
 (hk-test
  "three-way guarded rhs"
  (hk-desugar
    (hk-parse-top "sign n | n > 0 = 1\n       | n < 0 = -1\n       | otherwise = 0"))
  (hk-prog
    (list
      :fun-clause
      "sign"
      (list (list :p-var "n"))
      (list
        :if
        (list :op ">" (list :var "n") (list :int 0))
        (list :int 1)
        (list
          :if
          (list :op "<" (list :var "n") (list :int 0))
          (list :neg (list :int 1))
          (list
            :if
            (list :var "otherwise")
            (list :int 0)
            (list
              :app
              (list :var "error")
              (list :string "Non-exhaustive guards"))))))))
 (hk-test
  "case-alt guards desugared too"
  (hk-desugar
    (hk-parse "case x of\n  Just y | y > 0 -> y\n         | otherwise -> 0\n  Nothing -> -1"))
  (list
    :case
    (list :var "x")
    (list
      (list
        :alt
        (list :p-con "Just" (list (list :p-var "y")))
        (list
          :if
          (list :op ">" (list :var "y") (list :int 0))
          (list :var "y")
          (list
            :if
            (list :var "otherwise")
            (list :int 0)
            (list
              :app
              (list :var "error")
              (list :string "Non-exhaustive guards")))))
      (list
        :alt
        (list :p-con "Nothing" (list))
        (list :neg (list :int 1))))))
 ;; ── Where → let ──
 (hk-test
  "where with single binding"
  (hk-desugar (hk-parse-top "f x = y\n  where y = x + 1"))
  (hk-prog
    (list
      :fun-clause
      "f"
      (list (list :p-var "x"))
      (list
        :let
        (list
          (list
            :fun-clause
            "y"
            (list)
            (list :op "+" (list :var "x") (list :int 1))))
        (list :var "y")))))
 (hk-test
  "where with two bindings"
  (hk-desugar
    (hk-parse-top "f x = y + z\n  where y = x + 1\n        z = x - 1"))
  (hk-prog
    (list
      :fun-clause
      "f"
      (list (list :p-var "x"))
      (list
        :let
        (list
          (list
            :fun-clause
            "y"
            (list)
            (list :op "+" (list :var "x") (list :int 1)))
          (list
            :fun-clause
            "z"
            (list)
            (list :op "-" (list :var "x") (list :int 1))))
        (list :op "+" (list :var "y") (list :var "z"))))))
 (hk-test
  "guards + where — guarded body inside let"
  (hk-desugar
    (hk-parse-top "f x | x > 0 = y\n    | otherwise = 0\n  where y = 99"))
  (hk-prog
    (list
      :fun-clause
      "f"
      (list (list :p-var "x"))
      (list
        :let
        (list (list :fun-clause "y" (list) (list :int 99)))
        (list
          :if
          (list :op ">" (list :var "x") (list :int 0))
          (list :var "y")
          (list
            :if
            (list :var "otherwise")
            (list :int 0)
            (list
              :app
              (list :var "error")
              (list :string "Non-exhaustive guards"))))))))
 ;; ── List comprehensions → concatMap / if / let ──
 (hk-test
  "list-comp: single generator"
  (hk-core-expr "[x | x <- xs]")
  (list
    :app
    (list
      :app
      (list :var "concatMap")
      (list
        :lambda
        (list (list :p-var "x"))
        (list :list (list (list :var "x")))))
    (list :var "xs")))
 (hk-test
  "list-comp: generator then guard"
  (hk-core-expr "[x * 2 | x <- xs, x > 0]")
  (list
    :app
    (list
      :app
      (list :var "concatMap")
      (list
        :lambda
        (list (list :p-var "x"))
        (list
          :if
          (list :op ">" (list :var "x") (list :int 0))
          (list
            :list
            (list (list :op "*" (list :var "x") (list :int 2))))
          (list :list (list)))))
    (list :var "xs")))
 (hk-test
  "list-comp: generator then let"
  (hk-core-expr "[y | x <- xs, let y = x + 1]")
  (list
    :app
    (list
      :app
      (list :var "concatMap")
      (list
        :lambda
        (list (list :p-var "x"))
        (list
          :let
          (list
            (list
              :bind
              (list :p-var "y")
              (list :op "+" (list :var "x") (list :int 1))))
          (list :list (list (list :var "y"))))))
    (list :var "xs")))
 (hk-test
  "list-comp: two generators (nested concatMap)"
  (hk-core-expr "[(x, y) | x <- xs, y <- ys]")
  (list
    :app
    (list
      :app
      (list :var "concatMap")
      (list
        :lambda
        (list (list :p-var "x"))
        (list
          :app
          (list
            :app
            (list :var "concatMap")
            (list
              :lambda
              (list (list :p-var "y"))
              (list
                :list
                (list
                  (list
                    :tuple
                    (list (list :var "x") (list :var "y")))))))
          (list :var "ys"))))
    (list :var "xs")))
 ;; ── Pass-through cases ──
 (hk-test
  "plain int literal unchanged"
  (hk-core-expr "42")
  (list :int 42))
 (hk-test
  "lambda + if passes through"
  (hk-core-expr "\\x -> if x > 0 then x else - x")
  (list
    :lambda
    (list (list :p-var "x"))
    (list
      :if
      (list :op ">" (list :var "x") (list :int 0))
      (list :var "x")
      (list :neg (list :var "x")))))
 (hk-test
  "simple fun-clause (no guards/where) passes through"
  (hk-desugar (hk-parse-top "id x = x"))
  (hk-prog
    (list
      :fun-clause
      "id"
      (list (list :p-var "x"))
      (list :var "x"))))
 (hk-test
  "data decl passes through"
  (hk-desugar (hk-parse-top "data Maybe a = Nothing | Just a"))
  (hk-prog
    (list
      :data
      "Maybe"
      (list "a")
      (list
        (list :con-def "Nothing" (list))
        (list :con-def "Just" (list (list :t-var "a")))))))
 (hk-test
  "module header passes through, body desugared"
  (hk-desugar
    (hk-parse-top "module M where\nf x | x > 0 = 1\n    | otherwise = 0"))
  (list
    :module
    "M"
    nil
    (list)
    (list
      (list
        :fun-clause
        "f"
        (list (list :p-var "x"))
        (list
          :if
          (list :op ">" (list :var "x") (list :int 0))
          (list :int 1)
          (list
            :if
            (list :var "otherwise")
            (list :int 0)
            (list
              :app
              (list :var "error")
              (list :string "Non-exhaustive guards"))))))))
 {:fails hk-test-fails :pass hk-test-pass :fail hk-test-fail}
--- a/lib/haskell/tests/do-io.sx
+++ b/lib/haskell/tests/do-io.sx
@@ -1,117 +0,0 @@
 ;; do-notation + stub IO monad. Desugaring is per Haskell 98 §3.14:
 ;;   do { e ; ss }      = e >> do { ss }
 ;;   do { p <- e ; ss } = e >>= \p -> do { ss }
 ;;   do { let ds ; ss } = let ds in do { ss }
 ;;   do { e }           = e
 ;; The IO type is just `("IO" payload)` for now — no real side
 ;; effects yet. `return`, `>>=`, `>>` are built-ins.
 (define
  hk-prog-val
  (fn
    (src name)
    (hk-deep-force (get (hk-eval-program (hk-core src)) name))))
 ;; ── Single-statement do ──
 (hk-test
  "do with a single expression"
  (hk-eval-expr-source "do { return 5 }")
  (list "IO" 5))
 (hk-test
  "return wraps any expression"
  (hk-eval-expr-source "return (1 + 2 * 3)")
  (list "IO" 7))
 ;; ── Bind threads results ──
 (hk-test
  "single bind"
  (hk-eval-expr-source
    "do { x <- return 5 ; return (x + 1) }")
  (list "IO" 6))
 (hk-test
  "two binds"
  (hk-eval-expr-source
    "do\n  x <- return 5\n  y <- return 7\n  return (x + y)")
  (list "IO" 12))
 (hk-test
  "three binds — accumulating"
  (hk-eval-expr-source
    "do\n  a <- return 1\n  b <- return 2\n  c <- return 3\n  return (a + b + c)")
  (list "IO" 6))
 ;; ── Mixing >> and >>= ──
 (hk-test
  ">> sequencing — last wins"
  (hk-eval-expr-source
    "do\n  return 1\n  return 2\n  return 3")
  (list "IO" 3))
 (hk-test
  ">> then >>= — last bind wins"
  (hk-eval-expr-source
    "do\n  return 99\n  x <- return 5\n  return x")
  (list "IO" 5))
 ;; ── do-let ──
 (hk-test
  "do-let single binding"
  (hk-eval-expr-source
    "do\n  let x = 3\n  return (x * 2)")
  (list "IO" 6))
 (hk-test
  "do-let multi-bind, used after"
  (hk-eval-expr-source
    "do\n  let x = 4\n      y = 5\n  return (x * y)")
  (list "IO" 20))
 (hk-test
  "do-let interleaved with bind"
  (hk-eval-expr-source
    "do\n  x <- return 10\n  let y = x + 1\n  return (x * y)")
  (list "IO" 110))
 ;; ── Bind + pattern ──
 (hk-test
  "bind to constructor pattern"
  (hk-eval-expr-source
    "do\n  Just x <- return (Just 7)\n  return (x + 100)")
  (list "IO" 107))
 (hk-test
  "bind to tuple pattern"
  (hk-eval-expr-source
    "do\n  (a, b) <- return (3, 4)\n  return (a * b)")
  (list "IO" 12))
 ;; ── User-defined IO functions ──
 (hk-test
  "do inside top-level fun"
  (hk-prog-val
    "addM x y = do\n  a <- return x\n  b <- return y\n  return (a + b)\nresult = addM 5 6"
    "result")
  (list "IO" 11))
 (hk-test
  "nested do"
  (hk-eval-expr-source
    "do\n  x <- do { y <- return 3 ; return (y + 1) }\n  return (x * 2)")
  (list "IO" 8))
 ;; ── (>>=) and (>>) used directly as functions ──
 (hk-test
  ">>= used directly"
  (hk-eval-expr-source
    "(return 4) >>= (\\x -> return (x + 100))")
  (list "IO" 104))
 (hk-test
  ">> used directly"
  (hk-eval-expr-source
    "(return 1) >> (return 2)")
  (list "IO" 2))
 {:fails hk-test-fails :pass hk-test-pass :fail hk-test-fail}
--- a/lib/haskell/tests/eval.sx
+++ b/lib/haskell/tests/eval.sx
@@ -1,278 +0,0 @@
 ;; Strict evaluator tests. Each test parses, desugars, and evaluates
 ;; either an expression (hk-eval-expr-source) or a full program
 ;; (hk-eval-program → look up a named value).
 (define
  hk-prog-val
  (fn
    (src name)
    (hk-deep-force (get (hk-eval-program (hk-core src)) name))))
 ;; ── Literals ──
 (hk-test "int literal" (hk-eval-expr-source "42") 42)
 (hk-test "float literal" (hk-eval-expr-source "3.14") 3.14)
 (hk-test "string literal" (hk-eval-expr-source "\"hi\"") "hi")
 (hk-test "char literal" (hk-eval-expr-source "'a'") "a")
 (hk-test "negative literal" (hk-eval-expr-source "- 5") -5)
 ;; ── Arithmetic ──
 (hk-test "addition" (hk-eval-expr-source "1 + 2") 3)
 (hk-test
  "precedence"
  (hk-eval-expr-source "1 + 2 * 3")
  7)
 (hk-test
  "parens override precedence"
  (hk-eval-expr-source "(1 + 2) * 3")
  9)
 (hk-test
  "subtraction left-assoc"
  (hk-eval-expr-source "10 - 3 - 2")
  5)
 ;; ── Comparison + Bool ──
 (hk-test
  "less than is True"
  (hk-eval-expr-source "3 < 5")
  (list "True"))
 (hk-test
  "equality is False"
  (hk-eval-expr-source "1 == 2")
  (list "False"))
 (hk-test
  "&& shortcuts"
  (hk-eval-expr-source "(1 == 1) && (2 == 2)")
  (list "True"))
 ;; ── if / otherwise ──
 (hk-test
  "if True"
  (hk-eval-expr-source "if True then 1 else 2")
  1)
 (hk-test
  "if comparison branch"
  (hk-eval-expr-source "if 5 > 3 then \"yes\" else \"no\"")
  "yes")
 (hk-test "otherwise is True" (hk-eval-expr-source "otherwise") (list "True"))
 ;; ── let ──
 (hk-test
  "let single binding"
  (hk-eval-expr-source "let x = 5 in x + 1")
  6)
 (hk-test
  "let two bindings"
  (hk-eval-expr-source "let x = 1; y = 2 in x + y")
  3)
 (hk-test
  "let recursive: factorial 5"
  (hk-eval-expr-source
    "let f n = if n == 0 then 1 else n * f (n - 1) in f 5")
  120)
 ;; ── Lambdas ──
 (hk-test
  "lambda apply"
  (hk-eval-expr-source "(\\x -> x + 1) 5")
  6)
 (hk-test
  "lambda multi-arg"
  (hk-eval-expr-source "(\\x y -> x * y) 3 4")
  12)
 (hk-test
  "lambda with constructor pattern"
  (hk-eval-expr-source "(\\(Just x) -> x + 1) (Just 7)")
  8)
 ;; ── Constructors ──
 (hk-test
  "0-arity constructor"
  (hk-eval-expr-source "Nothing")
  (list "Nothing"))
 (hk-test
  "1-arity constructor applied"
  (hk-eval-expr-source "Just 5")
  (list "Just" 5))
 (hk-test
  "True / False as bools"
  (hk-eval-expr-source "True")
  (list "True"))
 ;; ── case ──
 (hk-test
  "case Just"
  (hk-eval-expr-source
    "case Just 7 of Just x -> x ; Nothing -> 0")
  7)
 (hk-test
  "case Nothing"
  (hk-eval-expr-source
    "case Nothing of Just x -> x ; Nothing -> 99")
  99)
 (hk-test
  "case literal pattern"
  (hk-eval-expr-source
    "case 0 of 0 -> \"zero\" ; n -> \"other\"")
  "zero")
 (hk-test
  "case tuple"
  (hk-eval-expr-source
    "case (1, 2) of (a, b) -> a + b")
  3)
 (hk-test
  "case wildcard fallback"
  (hk-eval-expr-source
    "case 5 of 0 -> \"z\" ; _ -> \"nz\"")
  "nz")
 ;; ── List literals + cons ──
 (hk-test
  "list literal as cons spine"
  (hk-eval-expr-source "[1, 2, 3]")
  (list ":" 1 (list ":" 2 (list ":" 3 (list "[]")))))
 (hk-test
  "empty list literal"
  (hk-eval-expr-source "[]")
  (list "[]"))
 (hk-test
  "cons via :"
  (hk-eval-expr-source "1 : []")
  (list ":" 1 (list "[]")))
 (hk-test
  "++ concatenates lists"
  (hk-eval-expr-source "[1, 2] ++ [3]")
  (list ":" 1 (list ":" 2 (list ":" 3 (list "[]")))))
 ;; ── Tuples ──
 (hk-test
  "2-tuple"
  (hk-eval-expr-source "(1, 2)")
  (list "Tuple" 1 2))
 (hk-test
  "3-tuple"
  (hk-eval-expr-source "(\"a\", 5, True)")
  (list "Tuple" "a" 5 (list "True")))
 ;; ── Sections ──
 (hk-test
  "right section (+ 1) applied"
  (hk-eval-expr-source "(+ 1) 5")
  6)
 (hk-test
  "left section (10 -) applied"
  (hk-eval-expr-source "(10 -) 4")
  6)
 ;; ── Multi-clause top-level functions ──
 (hk-test
  "multi-clause: factorial"
  (hk-prog-val
    "fact 0 = 1\nfact n = n * fact (n - 1)\nresult = fact 6"
    "result")
  720)
 (hk-test
  "multi-clause: list length via cons pattern"
  (hk-prog-val
    "len [] = 0\nlen (x:xs) = 1 + len xs\nresult = len [10, 20, 30, 40]"
    "result")
  4)
 (hk-test
  "multi-clause: Maybe handler"
  (hk-prog-val
    "fromMaybe d Nothing = d\nfromMaybe _ (Just x) = x\nresult = fromMaybe 0 (Just 9)"
    "result")
  9)
 (hk-test
  "multi-clause: Maybe with default"
  (hk-prog-val
    "fromMaybe d Nothing = d\nfromMaybe _ (Just x) = x\nresult = fromMaybe 0 Nothing"
    "result")
  0)
 ;; ── User-defined data and matching ──
 (hk-test
  "custom data with pattern match"
  (hk-prog-val
    "data Color = Red | Green | Blue\nname Red = \"red\"\nname Green = \"green\"\nname Blue = \"blue\"\nresult = name Green"
    "result")
  "green")
 (hk-test
  "custom binary tree height"
  (hk-prog-val
    "data Tree = Leaf | Node Tree Tree\nh Leaf = 0\nh (Node l r) = 1 + max (h l) (h r)\nmax a b = if a > b then a else b\nresult = h (Node (Node Leaf Leaf) Leaf)"
    "result")
  2)
 ;; ── Currying ──
 (hk-test
  "partial application"
  (hk-prog-val
    "add x y = x + y\nadd5 = add 5\nresult = add5 7"
    "result")
  12)
 ;; ── Higher-order ──
 (hk-test
  "higher-order: function as arg"
  (hk-prog-val
    "twice f x = f (f x)\ninc x = x + 1\nresult = twice inc 10"
    "result")
  12)
 ;; ── Error built-in ──
 (hk-test
  "error short-circuits via if"
  (hk-eval-expr-source
    "if True then 1 else error \"unreachable\"")
  1)
 ;; ── Laziness: app args evaluate only when forced ──
 (hk-test
  "second arg never forced"
  (hk-eval-expr-source
    "(\\x y -> x) 1 (error \"never\")")
  1)
 (hk-test
  "first arg never forced"
  (hk-eval-expr-source
    "(\\x y -> y) (error \"never\") 99")
  99)
 (hk-test
  "constructor argument is lazy under wildcard pattern"
  (hk-eval-expr-source
    "case Just (error \"deeply\") of Just _ -> 7 ; Nothing -> 0")
  7)
 (hk-test
  "lazy: const drops its second argument"
  (hk-prog-val
    "const x y = x\nresult = const 5 (error \"boom\")"
    "result")
  5)
 (hk-test
  "lazy: head ignores tail"
  (hk-prog-val
    "myHead (x:_) = x\nresult = myHead (1 : (error \"tail\") : [])"
    "result")
  1)
 (hk-test
  "lazy: Just on undefined evaluates only on force"
  (hk-prog-val
    "wrapped = Just (error \"oh no\")\nresult = case wrapped of Just _ -> True ; Nothing -> False"
    "result")
  (list "True"))
 ;; ── not / id built-ins ──
 (hk-test "not True" (hk-eval-expr-source "not True") (list "False"))
 (hk-test "not False" (hk-eval-expr-source "not False") (list "True"))
 (hk-test "id" (hk-eval-expr-source "id 42") 42)
 {:fails hk-test-fails :pass hk-test-pass :fail hk-test-fail}
--- a/lib/haskell/tests/infinite.sx
+++ b/lib/haskell/tests/infinite.sx
@@ -1,137 +0,0 @@
 ;; Infinite structures + Prelude tests. The lazy `:` operator builds
 ;; cons cells with thunked head/tail so recursive list-defining
 ;; functions terminate when only a finite prefix is consumed.
 (define
  hk-prog-val
  (fn
    (src name)
    (hk-deep-force (get (hk-eval-program (hk-core src)) name))))
 (define hk-as-list
  (fn (xs)
    (cond
      ((and (list? xs) (= (first xs) "[]")) (list))
      ((and (list? xs) (= (first xs) ":"))
        (cons (nth xs 1) (hk-as-list (nth xs 2))))
      (:else xs))))
 (define
  hk-eval-list
  (fn (src) (hk-as-list (hk-eval-expr-source src))))
 ;; ── Prelude basics ──
 (hk-test "head of literal" (hk-eval-expr-source "head [1, 2, 3]") 1)
 (hk-test
  "tail of literal"
  (hk-eval-list "tail [1, 2, 3]")
  (list 2 3))
 (hk-test "length" (hk-eval-expr-source "length [10, 20, 30, 40]") 4)
 (hk-test "length empty" (hk-eval-expr-source "length []") 0)
 (hk-test
  "map with section"
  (hk-eval-list "map (+ 1) [1, 2, 3]")
  (list 2 3 4))
 (hk-test
  "filter"
  (hk-eval-list "filter (\\x -> x > 2) [1, 2, 3, 4, 5]")
  (list 3 4 5))
 (hk-test
  "drop"
  (hk-eval-list "drop 2 [10, 20, 30, 40]")
  (list 30 40))
 (hk-test "fst" (hk-eval-expr-source "fst (7, 9)") 7)
 (hk-test "snd" (hk-eval-expr-source "snd (7, 9)") 9)
 (hk-test
  "zipWith"
  (hk-eval-list "zipWith plus [1, 2, 3] [10, 20, 30]")
  (list 11 22 33))
 ;; ── Infinite structures ──
 (hk-test
  "take from repeat"
  (hk-eval-list "take 5 (repeat 7)")
  (list 7 7 7 7 7))
 (hk-test
  "take 0 from repeat returns empty"
  (hk-eval-list "take 0 (repeat 7)")
  (list))
 (hk-test
  "take from iterate"
  (hk-eval-list "take 5 (iterate (\\x -> x + 1) 0)")
  (list 0 1 2 3 4))
 (hk-test
  "iterate with multiplication"
  (hk-eval-list "take 4 (iterate (\\x -> x * 2) 1)")
  (list 1 2 4 8))
 (hk-test
  "head of repeat"
  (hk-eval-expr-source "head (repeat 99)")
  99)
 ;; ── Fibonacci stream ──
 (hk-test
  "first 10 Fibonacci numbers"
  (hk-eval-list "take 10 fibs")
  (list 0 1 1 2 3 5 8 13 21 34))
 (hk-test
  "fib at position 8"
  (hk-eval-expr-source "head (drop 8 fibs)")
  21)
 ;; ── Building infinite structures in user code ──
 (hk-test
  "user-defined infinite ones"
  (hk-prog-val
    "ones = 1 : ones\nresult = take 6 ones"
    "result")
  (list ":" 1 (list ":" 1 (list ":" 1 (list ":" 1 (list ":" 1 (list ":" 1 (list "[]"))))))))
 (hk-test
  "user-defined nats"
  (hk-prog-val
    "nats = naturalsFrom 1\nnaturalsFrom n = n : naturalsFrom (n + 1)\nresult = take 5 nats"
    "result")
  (list ":" 1 (list ":" 2 (list ":" 3 (list ":" 4 (list ":" 5 (list "[]")))))))
 ;; ── Range syntax ──
 (hk-test
  "finite range [1..5]"
  (hk-eval-list "[1..5]")
  (list 1 2 3 4 5))
 (hk-test
  "empty range when from > to"
  (hk-eval-list "[10..3]")
  (list))
 (hk-test
  "stepped range"
  (hk-eval-list "[1, 3..10]")
  (list 1 3 5 7 9))
 (hk-test
  "open range — head"
  (hk-eval-expr-source "head [1..]")
  1)
 (hk-test
  "open range — drop then head"
  (hk-eval-expr-source "head (drop 99 [1..])")
  100)
 (hk-test
  "open range — take 5"
  (hk-eval-list "take 5 [10..]")
  (list 10 11 12 13 14))
 ;; ── Composing Prelude functions ──
 (hk-test
  "map then filter"
  (hk-eval-list
    "filter (\\x -> x > 5) (map (\\x -> x * 2) [1, 2, 3, 4])")
  (list 6 8))
 (hk-test
  "sum-via-foldless"
  (hk-prog-val
    "mySum [] = 0\nmySum (x:xs) = x + mySum xs\nresult = mySum (take 5 (iterate (\\x -> x + 1) 1))"
    "result")
  15)
 {:fails hk-test-fails :pass hk-test-pass :fail hk-test-fail}
--- a/lib/haskell/tests/layout.sx
+++ b/lib/haskell/tests/layout.sx
@@ -1,245 +0,0 @@
 ;; Haskell layout-rule tests. hk-tokenizer + hk-layout produce a
 ;; virtual-brace-annotated stream; these tests cover the algorithm
 ;; from Haskell 98 §10.3 plus the pragmatic let/in single-line rule.
 ;; Convenience — tokenize, run layout, strip eof, keep :type/:value.
 (define
  hk-lay
  (fn
    (src)
    (map
      (fn (tok) {:value (get tok "value") :type (get tok "type")})
      (filter
        (fn (tok) (not (= (get tok "type") "eof")))
        (hk-layout (hk-tokenize src))))))
 ;; ── 1. Basics ──
 (hk-test
  "empty input produces empty module { }"
  (hk-lay "")
  (list
    {:value "{" :type "vlbrace"}
    {:value "}" :type "vrbrace"}))
 (hk-test
  "single token → module open+close"
  (hk-lay "foo")
  (list
    {:value "{" :type "vlbrace"}
    {:value "foo" :type "varid"}
    {:value "}" :type "vrbrace"}))
 (hk-test
  "two top-level decls get vsemi between"
  (hk-lay "foo = 1\nbar = 2")
  (list
    {:value "{" :type "vlbrace"}
    {:value "foo" :type "varid"}
    {:value "=" :type "reservedop"}
    {:value 1 :type "integer"}
    {:value ";" :type "vsemi"}
    {:value "bar" :type "varid"}
    {:value "=" :type "reservedop"}
    {:value 2 :type "integer"}
    {:value "}" :type "vrbrace"}))
 ;; ── 2. Layout keywords — do / let / where / of ──
 (hk-test
  "do block with two stmts"
  (hk-lay "f = do\n  x\n  y")
  (list
    {:value "{" :type "vlbrace"}
    {:value "f" :type "varid"}
    {:value "=" :type "reservedop"}
    {:value "do" :type "reserved"}
    {:value "{" :type "vlbrace"}
    {:value "x" :type "varid"}
    {:value ";" :type "vsemi"}
    {:value "y" :type "varid"}
    {:value "}" :type "vrbrace"}
    {:value "}" :type "vrbrace"}))
 (hk-test
  "single-line let ... in"
  (hk-lay "let x = 1 in x")
  (list
    {:value "{" :type "vlbrace"}
    {:value "let" :type "reserved"}
    {:value "{" :type "vlbrace"}
    {:value "x" :type "varid"}
    {:value "=" :type "reservedop"}
    {:value 1 :type "integer"}
    {:value "}" :type "vrbrace"}
    {:value "in" :type "reserved"}
    {:value "x" :type "varid"}
    {:value "}" :type "vrbrace"}))
 (hk-test
  "where block with two bindings"
  (hk-lay "f = g\n  where\n    g = 1\n    h = 2")
  (list
    {:value "{" :type "vlbrace"}
    {:value "f" :type "varid"}
    {:value "=" :type "reservedop"}
    {:value "g" :type "varid"}
    {:value "where" :type "reserved"}
    {:value "{" :type "vlbrace"}
    {:value "g" :type "varid"}
    {:value "=" :type "reservedop"}
    {:value 1 :type "integer"}
    {:value ";" :type "vsemi"}
    {:value "h" :type "varid"}
    {:value "=" :type "reservedop"}
    {:value 2 :type "integer"}
    {:value "}" :type "vrbrace"}
    {:value "}" :type "vrbrace"}))
 (hk-test
  "case … of with arms"
  (hk-lay "f x = case x of\n  Just y -> y\n  Nothing -> 0")
  (list
    {:value "{" :type "vlbrace"}
    {:value "f" :type "varid"}
    {:value "x" :type "varid"}
    {:value "=" :type "reservedop"}
    {:value "case" :type "reserved"}
    {:value "x" :type "varid"}
    {:value "of" :type "reserved"}
    {:value "{" :type "vlbrace"}
    {:value "Just" :type "conid"}
    {:value "y" :type "varid"}
    {:value "->" :type "reservedop"}
    {:value "y" :type "varid"}
    {:value ";" :type "vsemi"}
    {:value "Nothing" :type "conid"}
    {:value "->" :type "reservedop"}
    {:value 0 :type "integer"}
    {:value "}" :type "vrbrace"}
    {:value "}" :type "vrbrace"}))
 ;; ── 3. Explicit braces disable layout ──
 (hk-test
  "explicit braces — no implicit vlbrace/vsemi/vrbrace inside"
  (hk-lay "do { x ; y }")
  (list
    {:value "{" :type "vlbrace"}
    {:value "do" :type "reserved"}
    {:value "{" :type "lbrace"}
    {:value "x" :type "varid"}
    {:value ";" :type "semi"}
    {:value "y" :type "varid"}
    {:value "}" :type "rbrace"}
    {:value "}" :type "vrbrace"}))
 ;; ── 4. Dedent closes nested blocks ──
 (hk-test
  "dedent back to module level closes do block"
  (hk-lay "f = do\n  x\n  y\ng = 2")
  (list
    {:value "{" :type "vlbrace"}
    {:value "f" :type "varid"}
    {:value "=" :type "reservedop"}
    {:value "do" :type "reserved"}
    {:value "{" :type "vlbrace"}
    {:value "x" :type "varid"}
    {:value ";" :type "vsemi"}
    {:value "y" :type "varid"}
    {:value "}" :type "vrbrace"}
    {:value ";" :type "vsemi"}
    {:value "g" :type "varid"}
    {:value "=" :type "reservedop"}
    {:value 2 :type "integer"}
    {:value "}" :type "vrbrace"}))
 (hk-test
  "dedent closes inner let, emits vsemi at outer do level"
  (hk-lay "main = do\n  let x = 1\n  print x")
  (list
    {:value "{" :type "vlbrace"}
    {:value "main" :type "varid"}
    {:value "=" :type "reservedop"}
    {:value "do" :type "reserved"}
    {:value "{" :type "vlbrace"}
    {:value "let" :type "reserved"}
    {:value "{" :type "vlbrace"}
    {:value "x" :type "varid"}
    {:value "=" :type "reservedop"}
    {:value 1 :type "integer"}
    {:value "}" :type "vrbrace"}
    {:value ";" :type "vsemi"}
    {:value "print" :type "varid"}
    {:value "x" :type "varid"}
    {:value "}" :type "vrbrace"}
    {:value "}" :type "vrbrace"}))
 ;; ── 5. Module header skips outer implicit open ──
 (hk-test
  "module M where — only where opens a block"
  (hk-lay "module M where\n  f = 1")
  (list
    {:value "module" :type "reserved"}
    {:value "M" :type "conid"}
    {:value "where" :type "reserved"}
    {:value "{" :type "vlbrace"}
    {:value "f" :type "varid"}
    {:value "=" :type "reservedop"}
    {:value 1 :type "integer"}
    {:value "}" :type "vrbrace"}))
 ;; ── 6. Newlines are stripped ──
 (hk-test
  "newline tokens do not appear in output"
  (let
    ((toks (hk-layout (hk-tokenize "foo\nbar"))))
    (every?
      (fn (t) (not (= (get t "type") "newline")))
      toks))
  true)
 ;; ── 7. Continuation — deeper indent does NOT emit vsemi ──
 (hk-test
  "line continuation (deeper indent) just merges"
  (hk-lay "foo = 1 +\n   2")
  (list
    {:value "{" :type "vlbrace"}
    {:value "foo" :type "varid"}
    {:value "=" :type "reservedop"}
    {:value 1 :type "integer"}
    {:value "+" :type "varsym"}
    {:value 2 :type "integer"}
    {:value "}" :type "vrbrace"}))
 ;; ── 8. Stack closing at EOF ──
 (hk-test
  "EOF inside nested do closes all implicit blocks"
  (let
    ((toks (hk-lay "main = do\n  do\n    x")))
    (let
      ((n (len toks)))
      (list
        (get (nth toks (- n 1)) "type")
        (get (nth toks (- n 2)) "type")
        (get (nth toks (- n 3)) "type"))))
  (list "vrbrace" "vrbrace" "vrbrace"))
 ;; ── 9. Qualified-newline: x at deeper col than stack top does nothing ──
 (hk-test
  "mixed where + do"
  (hk-lay "f = do\n    x\n  where\n    x = 1")
  (list
    {:value "{" :type "vlbrace"}
    {:value "f" :type "varid"}
    {:value "=" :type "reservedop"}
    {:value "do" :type "reserved"}
    {:value "{" :type "vlbrace"}
    {:value "x" :type "varid"}
    {:value "}" :type "vrbrace"}
    {:value "where" :type "reserved"}
    {:value "{" :type "vlbrace"}
    {:value "x" :type "varid"}
    {:value "=" :type "reservedop"}
    {:value 1 :type "integer"}
    {:value "}" :type "vrbrace"}
    {:value "}" :type "vrbrace"}))
 {:fails hk-test-fails :pass hk-test-pass :fail hk-test-fail}
--- a/lib/haskell/tests/match.sx
+++ b/lib/haskell/tests/match.sx
@@ -1,256 +0,0 @@
 ;; Pattern-matcher tests. The matcher takes (pat val env) and returns
 ;; an extended env dict on success, or `nil` on failure. Constructor
 ;; values are tagged lists (con-name first); tuples use the "Tuple"
 ;; tag; lists use chained `:` cons with `[]` nil.
 ;; ── Atomic patterns ──
 (hk-test
  "wildcard always matches"
  (hk-match (list :p-wild) 42 (dict))
  (dict))
 (hk-test
  "var binds value"
  (hk-match (list :p-var "x") 42 (dict))
  {:x 42})
 (hk-test
  "var preserves prior env"
  (hk-match (list :p-var "y") 7 {:x 1})
  {:x 1 :y 7})
 (hk-test
  "int literal matches equal"
  (hk-match (list :p-int 5) 5 (dict))
  (dict))
 (hk-test
  "int literal fails on mismatch"
  (hk-match (list :p-int 5) 6 (dict))
  nil)
 (hk-test
  "negative int literal matches"
  (hk-match (list :p-int -3) -3 (dict))
  (dict))
 (hk-test
  "string literal matches"
  (hk-match (list :p-string "hi") "hi" (dict))
  (dict))
 (hk-test
  "string literal fails"
  (hk-match (list :p-string "hi") "bye" (dict))
  nil)
 (hk-test
  "char literal matches"
  (hk-match (list :p-char "a") "a" (dict))
  (dict))
 ;; ── Constructor patterns ──
 (hk-test
  "0-arity con matches"
  (hk-match
    (list :p-con "Nothing" (list))
    (hk-mk-con "Nothing" (list))
    (dict))
  (dict))
 (hk-test
  "1-arity con matches and binds"
  (hk-match
    (list :p-con "Just" (list (list :p-var "y")))
    (hk-mk-con "Just" (list 9))
    (dict))
  {:y 9})
 (hk-test
  "con name mismatch fails"
  (hk-match
    (list :p-con "Just" (list (list :p-var "y")))
    (hk-mk-con "Nothing" (list))
    (dict))
  nil)
 (hk-test
  "con arity mismatch fails"
  (hk-match
    (list :p-con "Pair" (list (list :p-var "a") (list :p-var "b")))
    (hk-mk-con "Pair" (list 1))
    (dict))
  nil)
 (hk-test
  "nested con: Just (Just x)"
  (hk-match
    (list
      :p-con
      "Just"
      (list
        (list
          :p-con
          "Just"
          (list (list :p-var "x")))))
    (hk-mk-con "Just" (list (hk-mk-con "Just" (list 42))))
    (dict))
  {:x 42})
 ;; ── Tuple patterns ──
 (hk-test
  "2-tuple matches and binds"
  (hk-match
    (list
      :p-tuple
      (list (list :p-var "a") (list :p-var "b")))
    (hk-mk-tuple (list 10 20))
    (dict))
  {:a 10 :b 20})
 (hk-test
  "tuple arity mismatch fails"
  (hk-match
    (list
      :p-tuple
      (list (list :p-var "a") (list :p-var "b")))
    (hk-mk-tuple (list 10 20 30))
    (dict))
  nil)
 ;; ── List patterns ──
 (hk-test
  "[] pattern matches empty list"
  (hk-match (list :p-list (list)) (hk-mk-nil) (dict))
  (dict))
 (hk-test
  "[] pattern fails on non-empty"
  (hk-match (list :p-list (list)) (hk-mk-list (list 1)) (dict))
  nil)
 (hk-test
  "[a] pattern matches singleton"
  (hk-match
    (list :p-list (list (list :p-var "a")))
    (hk-mk-list (list 7))
    (dict))
  {:a 7})
 (hk-test
  "[a, b] pattern matches pair-list and binds"
  (hk-match
    (list
      :p-list
      (list (list :p-var "a") (list :p-var "b")))
    (hk-mk-list (list 1 2))
    (dict))
  {:a 1 :b 2})
 (hk-test
  "[a, b] fails on too-long list"
  (hk-match
    (list
      :p-list
      (list (list :p-var "a") (list :p-var "b")))
    (hk-mk-list (list 1 2 3))
    (dict))
  nil)
 ;; Cons-style infix pattern (which the parser produces as :p-con ":")
 (hk-test
  "cons (h:t) on non-empty list"
  (hk-match
    (list
      :p-con
      ":"
      (list (list :p-var "h") (list :p-var "t")))
    (hk-mk-list (list 1 2 3))
    (dict))
  {:h 1 :t (list ":" 2 (list ":" 3 (list "[]")))})
 (hk-test
  "cons fails on empty list"
  (hk-match
    (list
      :p-con
      ":"
      (list (list :p-var "h") (list :p-var "t")))
    (hk-mk-nil)
    (dict))
  nil)
 ;; ── as patterns ──
 (hk-test
  "as binds whole + sub-pattern"
  (hk-match
    (list
      :p-as
      "all"
      (list :p-con "Just" (list (list :p-var "x"))))
    (hk-mk-con "Just" (list 99))
    (dict))
  {:all (list "Just" 99) :x 99})
 (hk-test
  "as on wildcard binds whole"
  (hk-match
    (list :p-as "v" (list :p-wild))
    "anything"
    (dict))
  {:v "anything"})
 (hk-test
  "as fails when sub-pattern fails"
  (hk-match
    (list
      :p-as
      "n"
      (list :p-con "Just" (list (list :p-var "x"))))
    (hk-mk-con "Nothing" (list))
    (dict))
  nil)
 ;; ── lazy ~ pattern (eager equivalent for now) ──
 (hk-test
  "lazy pattern eager-matches its inner"
  (hk-match
    (list :p-lazy (list :p-var "y"))
    42
    (dict))
  {:y 42})
 ;; ── Source-driven: parse a real Haskell pattern, match a value ──
 (hk-test
  "parsed pattern: Just x against Just 5"
  (hk-match
    (hk-parse-pat-source "Just x")
    (hk-mk-con "Just" (list 5))
    (dict))
  {:x 5})
 (hk-test
  "parsed pattern: x : xs against [10, 20, 30]"
  (hk-match
    (hk-parse-pat-source "x : xs")
    (hk-mk-list (list 10 20 30))
    (dict))
  {:x 10 :xs (list ":" 20 (list ":" 30 (list "[]")))})
 (hk-test
  "parsed pattern: (a, b) against (1, 2)"
  (hk-match
    (hk-parse-pat-source "(a, b)")
    (hk-mk-tuple (list 1 2))
    (dict))
  {:a 1 :b 2})
 (hk-test
  "parsed pattern: n@(Just x) against Just 7"
  (hk-match
    (hk-parse-pat-source "n@(Just x)")
    (hk-mk-con "Just" (list 7))
    (dict))
  {:n (list "Just" 7) :x 7})
 {:fails hk-test-fails :pass hk-test-pass :fail hk-test-fail}
--- a/lib/haskell/tests/parse.sx
+++ b/lib/haskell/tests/parse.sx
@@ -3,8 +3,60 @@
 ;; Lightweight runner: each test checks actual vs expected with
 ;; structural (deep) equality and accumulates pass/fail counters.
 ;; Final value of this file is a summary dict with :pass :fail :fails.
-;; The hk-test / hk-deep=? helpers live in lib/haskell/testlib.sx
+
-;; and are preloaded by lib/haskell/test.sh.
+(define
  hk-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) (hk-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
              hk-de-loop
              (fn
                ()
                (when
                  (and ok (< i (len a)))
                  (do
                    (when
                      (not (hk-deep=? (nth a i) (nth b i)))
                      (set! ok false))
                    (set! i (+ i 1))
                    (hk-de-loop)))))
            (hk-de-loop)
            ok)))
      (:else false))))
 (define hk-test-pass 0)
 (define hk-test-fail 0)
 (define hk-test-fails (list))
 (define
  hk-test
  (fn
    (name actual expected)
    (if
      (hk-deep=? actual expected)
      (set! hk-test-pass (+ hk-test-pass 1))
      (do
        (set! hk-test-fail (+ hk-test-fail 1))
        (append! hk-test-fails {:actual actual :expected expected :name name})))))
 ;; Convenience: tokenize and drop newline + eof tokens so tests focus
 ;; on meaningful content. Returns list of {:type :value} pairs.
--- a/lib/haskell/tests/parser-case-do.sx
+++ b/lib/haskell/tests/parser-case-do.sx
@@ -1,278 +0,0 @@
 ;; case-of and do-notation parser tests.
 ;; Covers the minimal patterns needed to make these meaningful: var,
 ;; wildcard, literal, constructor (with and without args), tuple, list.
 ;; ── Patterns (in case arms) ──
 (hk-test
  "wildcard pat"
  (hk-parse "case x of _ -> 0")
  (list
    :case
    (list :var "x")
    (list (list :alt (list :p-wild) (list :int 0)))))
 (hk-test
  "var pat"
  (hk-parse "case x of y -> y")
  (list
    :case
    (list :var "x")
    (list
      (list :alt (list :p-var "y") (list :var "y")))))
 (hk-test
  "0-arity constructor pat"
  (hk-parse "case x of\n  Nothing -> 0\n  Just y -> y")
  (list
    :case
    (list :var "x")
    (list
      (list :alt (list :p-con "Nothing" (list)) (list :int 0))
      (list
        :alt
        (list :p-con "Just" (list (list :p-var "y")))
        (list :var "y")))))
 (hk-test
  "int literal pat"
  (hk-parse "case n of\n  0 -> 1\n  _ -> n")
  (list
    :case
    (list :var "n")
    (list
      (list :alt (list :p-int 0) (list :int 1))
      (list :alt (list :p-wild) (list :var "n")))))
 (hk-test
  "string literal pat"
  (hk-parse "case s of\n  \"hi\" -> 1\n  _ -> 0")
  (list
    :case
    (list :var "s")
    (list
      (list :alt (list :p-string "hi") (list :int 1))
      (list :alt (list :p-wild) (list :int 0)))))
 (hk-test
  "tuple pat"
  (hk-parse "case p of (a, b) -> a")
  (list
    :case
    (list :var "p")
    (list
      (list
        :alt
        (list
          :p-tuple
          (list (list :p-var "a") (list :p-var "b")))
        (list :var "a")))))
 (hk-test
  "list pat"
  (hk-parse "case xs of\n  [] -> 0\n  [a] -> a")
  (list
    :case
    (list :var "xs")
    (list
      (list :alt (list :p-list (list)) (list :int 0))
      (list
        :alt
        (list :p-list (list (list :p-var "a")))
        (list :var "a")))))
 (hk-test
  "nested constructor pat"
  (hk-parse "case x of\n  Just (a, b) -> a\n  _ -> 0")
  (list
    :case
    (list :var "x")
    (list
      (list
        :alt
        (list
          :p-con
          "Just"
          (list
            (list
              :p-tuple
              (list (list :p-var "a") (list :p-var "b")))))
        (list :var "a"))
      (list :alt (list :p-wild) (list :int 0)))))
 (hk-test
  "constructor with multiple var args"
  (hk-parse "case t of Pair a b -> a")
  (list
    :case
    (list :var "t")
    (list
      (list
        :alt
        (list
          :p-con
          "Pair"
          (list (list :p-var "a") (list :p-var "b")))
        (list :var "a")))))
 ;; ── case-of shapes ──
 (hk-test
  "case with explicit braces"
  (hk-parse "case x of { Just y -> y ; Nothing -> 0 }")
  (list
    :case
    (list :var "x")
    (list
      (list
        :alt
        (list :p-con "Just" (list (list :p-var "y")))
        (list :var "y"))
      (list :alt (list :p-con "Nothing" (list)) (list :int 0)))))
 (hk-test
  "case scrutinee is a full expression"
  (hk-parse "case f x + 1 of\n  y -> y")
  (list
    :case
    (list
      :op
      "+"
      (list :app (list :var "f") (list :var "x"))
      (list :int 1))
    (list (list :alt (list :p-var "y") (list :var "y")))))
 (hk-test
  "case arm body is full expression"
  (hk-parse "case x of\n  Just y -> y + 1")
  (list
    :case
    (list :var "x")
    (list
      (list
        :alt
        (list :p-con "Just" (list (list :p-var "y")))
        (list :op "+" (list :var "y") (list :int 1))))))
 ;; ── do blocks ──
 (hk-test
  "do with two expressions"
  (hk-parse "do\n  putStrLn \"hi\"\n  return 0")
  (list
    :do
    (list
      (list
        :do-expr
        (list :app (list :var "putStrLn") (list :string "hi")))
      (list
        :do-expr
        (list :app (list :var "return") (list :int 0))))))
 (hk-test
  "do with bind"
  (hk-parse "do\n  x <- getLine\n  putStrLn x")
  (list
    :do
    (list
      (list :do-bind (list :p-var "x") (list :var "getLine"))
      (list
        :do-expr
        (list :app (list :var "putStrLn") (list :var "x"))))))
 (hk-test
  "do with let"
  (hk-parse "do\n  let y = 5\n  print y")
  (list
    :do
    (list
      (list
        :do-let
        (list (list :bind (list :p-var "y") (list :int 5))))
      (list
        :do-expr
        (list :app (list :var "print") (list :var "y"))))))
 (hk-test
  "do with multiple let bindings"
  (hk-parse "do\n  let x = 1\n      y = 2\n  print (x + y)")
  (list
    :do
    (list
      (list
        :do-let
        (list
          (list :bind (list :p-var "x") (list :int 1))
          (list :bind (list :p-var "y") (list :int 2))))
      (list
        :do-expr
        (list
          :app
          (list :var "print")
          (list :op "+" (list :var "x") (list :var "y")))))))
 (hk-test
  "do with bind using constructor pat"
  (hk-parse "do\n  Just x <- getMaybe\n  return x")
  (list
    :do
    (list
      (list
        :do-bind
        (list :p-con "Just" (list (list :p-var "x")))
        (list :var "getMaybe"))
      (list
        :do-expr
        (list :app (list :var "return") (list :var "x"))))))
 (hk-test
  "do with explicit braces"
  (hk-parse "do { x <- a ; y <- b ; return (x + y) }")
  (list
    :do
    (list
      (list :do-bind (list :p-var "x") (list :var "a"))
      (list :do-bind (list :p-var "y") (list :var "b"))
      (list
        :do-expr
        (list
          :app
          (list :var "return")
          (list :op "+" (list :var "x") (list :var "y")))))))
 ;; ── Mixing case/do inside expressions ──
 (hk-test
  "case inside let"
  (hk-parse "let f = \\x -> case x of\n                 Just y -> y\n                 _ -> 0\nin f 5")
  (list
    :let
    (list
      (list
        :bind
        (list :p-var "f")
        (list
          :lambda
          (list (list :p-var "x"))
          (list
            :case
            (list :var "x")
            (list
              (list
                :alt
                (list :p-con "Just" (list (list :p-var "y")))
                (list :var "y"))
              (list :alt (list :p-wild) (list :int 0)))))))
    (list :app (list :var "f") (list :int 5))))
 (hk-test
  "lambda containing do"
  (hk-parse "\\x -> do\n  y <- x\n  return y")
  (list
    :lambda
    (list (list :p-var "x"))
    (list
      :do
      (list
        (list :do-bind (list :p-var "y") (list :var "x"))
        (list
          :do-expr
          (list :app (list :var "return") (list :var "y")))))))
 {:fails hk-test-fails :pass hk-test-pass :fail hk-test-fail}
--- a/lib/haskell/tests/parser-decls.sx
+++ b/lib/haskell/tests/parser-decls.sx
@@ -1,273 +0,0 @@
 ;; Top-level declarations: function clauses, type signatures, data,
 ;; type, newtype, fixity. Driven by hk-parse-top which produces
 ;; a (:program DECLS) node.
 (define
  hk-prog
  (fn
    (&rest decls)
    (list :program decls)))
 ;; ── Function clauses & pattern bindings ──
 (hk-test
  "simple fun-clause"
  (hk-parse-top "f x = x + 1")
  (hk-prog
    (list
      :fun-clause
      "f"
      (list (list :p-var "x"))
      (list :op "+" (list :var "x") (list :int 1)))))
 (hk-test
  "nullary decl"
  (hk-parse-top "answer = 42")
  (hk-prog
    (list :fun-clause "answer" (list) (list :int 42))))
 (hk-test
  "multi-clause fn (separate defs for each pattern)"
  (hk-parse-top "fact 0 = 1\nfact n = n")
  (hk-prog
    (list :fun-clause "fact" (list (list :p-int 0)) (list :int 1))
    (list
      :fun-clause
      "fact"
      (list (list :p-var "n"))
      (list :var "n"))))
 (hk-test
  "constructor pattern in fn args"
  (hk-parse-top "fromJust (Just x) = x")
  (hk-prog
    (list
      :fun-clause
      "fromJust"
      (list (list :p-con "Just" (list (list :p-var "x"))))
      (list :var "x"))))
 (hk-test
  "pattern binding at top level"
  (hk-parse-top "(a, b) = pair")
  (hk-prog
    (list
      :pat-bind
      (list
        :p-tuple
        (list (list :p-var "a") (list :p-var "b")))
      (list :var "pair"))))
 ;; ── Type signatures ──
 (hk-test
  "single-name sig"
  (hk-parse-top "f :: Int -> Int")
  (hk-prog
    (list
      :type-sig
      (list "f")
      (list :t-fun (list :t-con "Int") (list :t-con "Int")))))
 (hk-test
  "multi-name sig"
  (hk-parse-top "f, g, h :: Int -> Bool")
  (hk-prog
    (list
      :type-sig
      (list "f" "g" "h")
      (list :t-fun (list :t-con "Int") (list :t-con "Bool")))))
 (hk-test
  "sig with type application"
  (hk-parse-top "f :: Maybe a -> a")
  (hk-prog
    (list
      :type-sig
      (list "f")
      (list
        :t-fun
        (list :t-app (list :t-con "Maybe") (list :t-var "a"))
        (list :t-var "a")))))
 (hk-test
  "sig with list type"
  (hk-parse-top "len :: [a] -> Int")
  (hk-prog
    (list
      :type-sig
      (list "len")
      (list
        :t-fun
        (list :t-list (list :t-var "a"))
        (list :t-con "Int")))))
 (hk-test
  "sig with tuple and right-assoc ->"
  (hk-parse-top "pair :: a -> b -> (a, b)")
  (hk-prog
    (list
      :type-sig
      (list "pair")
      (list
        :t-fun
        (list :t-var "a")
        (list
          :t-fun
          (list :t-var "b")
          (list
            :t-tuple
            (list (list :t-var "a") (list :t-var "b"))))))))
 (hk-test
  "sig + implementation together"
  (hk-parse-top "id :: a -> a\nid x = x")
  (hk-prog
    (list
      :type-sig
      (list "id")
      (list :t-fun (list :t-var "a") (list :t-var "a")))
    (list
      :fun-clause
      "id"
      (list (list :p-var "x"))
      (list :var "x"))))
 ;; ── data declarations ──
 (hk-test
  "data Maybe"
  (hk-parse-top "data Maybe a = Nothing | Just a")
  (hk-prog
    (list
      :data
      "Maybe"
      (list "a")
      (list
        (list :con-def "Nothing" (list))
        (list :con-def "Just" (list (list :t-var "a")))))))
 (hk-test
  "data Either"
  (hk-parse-top "data Either a b = Left a | Right b")
  (hk-prog
    (list
      :data
      "Either"
      (list "a" "b")
      (list
        (list :con-def "Left" (list (list :t-var "a")))
        (list :con-def "Right" (list (list :t-var "b")))))))
 (hk-test
  "data with no type parameters"
  (hk-parse-top "data Bool = True | False")
  (hk-prog
    (list
      :data
      "Bool"
      (list)
      (list
        (list :con-def "True" (list))
        (list :con-def "False" (list))))))
 (hk-test
  "recursive data type"
  (hk-parse-top "data Tree a = Leaf | Node (Tree a) a (Tree a)")
  (hk-prog
    (list
      :data
      "Tree"
      (list "a")
      (list
        (list :con-def "Leaf" (list))
        (list
          :con-def
          "Node"
          (list
            (list :t-app (list :t-con "Tree") (list :t-var "a"))
            (list :t-var "a")
            (list :t-app (list :t-con "Tree") (list :t-var "a"))))))))
 ;; ── type synonyms ──
 (hk-test
  "simple type synonym"
  (hk-parse-top "type Name = String")
  (hk-prog
    (list :type-syn "Name" (list) (list :t-con "String"))))
 (hk-test
  "parameterised type synonym"
  (hk-parse-top "type Pair a = (a, a)")
  (hk-prog
    (list
      :type-syn
      "Pair"
      (list "a")
      (list
        :t-tuple
        (list (list :t-var "a") (list :t-var "a"))))))
 ;; ── newtype ──
 (hk-test
  "newtype"
  (hk-parse-top "newtype Age = Age Int")
  (hk-prog (list :newtype "Age" (list) "Age" (list :t-con "Int"))))
 (hk-test
  "parameterised newtype"
  (hk-parse-top "newtype Wrap a = Wrap a")
  (hk-prog
    (list :newtype "Wrap" (list "a") "Wrap" (list :t-var "a"))))
 ;; ── fixity declarations ──
 (hk-test
  "infixl with precedence"
  (hk-parse-top "infixl 5 +:, -:")
  (hk-prog (list :fixity "l" 5 (list "+:" "-:"))))
 (hk-test
  "infixr"
  (hk-parse-top "infixr 9 .")
  (hk-prog (list :fixity "r" 9 (list "."))))
 (hk-test
  "infix (non-assoc) default prec"
  (hk-parse-top "infix ==")
  (hk-prog (list :fixity "n" 9 (list "=="))))
 (hk-test
  "fixity with backtick operator name"
  (hk-parse-top "infixl 7 `div`")
  (hk-prog (list :fixity "l" 7 (list "div"))))
 ;; ── Several decls combined ──
 (hk-test
  "mixed: data + sig + fn + type"
  (hk-parse-top "data Maybe a = Nothing | Just a\ntype Entry = Maybe Int\nf :: Entry -> Int\nf (Just x) = x\nf Nothing = 0")
  (hk-prog
    (list
      :data
      "Maybe"
      (list "a")
      (list
        (list :con-def "Nothing" (list))
        (list :con-def "Just" (list (list :t-var "a")))))
    (list
      :type-syn
      "Entry"
      (list)
      (list :t-app (list :t-con "Maybe") (list :t-con "Int")))
    (list
      :type-sig
      (list "f")
      (list :t-fun (list :t-con "Entry") (list :t-con "Int")))
    (list
      :fun-clause
      "f"
      (list (list :p-con "Just" (list (list :p-var "x"))))
      (list :var "x"))
    (list
      :fun-clause
      "f"
      (list (list :p-con "Nothing" (list)))
      (list :int 0))))
 {:fails hk-test-fails :pass hk-test-pass :fail hk-test-fail}
--- a/lib/haskell/tests/parser-expr.sx
+++ b/lib/haskell/tests/parser-expr.sx
@@ -1,258 +0,0 @@
 ;; Haskell expression parser tests.
 ;; hk-parse tokenises, runs layout, then parses. Output is an AST
 ;; whose head is a keyword tag (evaluates to its string name).
 ;; ── 1. Literals ──
 (hk-test "integer" (hk-parse "42") (list :int 42))
 (hk-test "float" (hk-parse "3.14") (list :float 3.14))
 (hk-test "string" (hk-parse "\"hi\"") (list :string "hi"))
 (hk-test "char" (hk-parse "'a'") (list :char "a"))
 ;; ── 2. Variables and constructors ──
 (hk-test "varid" (hk-parse "foo") (list :var "foo"))
 (hk-test "conid" (hk-parse "Nothing") (list :con "Nothing"))
 (hk-test "qvarid" (hk-parse "Data.Map.lookup") (list :var "Data.Map.lookup"))
 (hk-test "qconid" (hk-parse "Data.Map") (list :con "Data.Map"))
 ;; ── 3. Parens / unit / tuple ──
 (hk-test "parens strip" (hk-parse "(42)") (list :int 42))
 (hk-test "unit" (hk-parse "()") (list :con "()"))
 (hk-test
  "2-tuple"
  (hk-parse "(1, 2)")
  (list :tuple (list (list :int 1) (list :int 2))))
 (hk-test
  "3-tuple"
  (hk-parse "(x, y, z)")
  (list
    :tuple
    (list (list :var "x") (list :var "y") (list :var "z"))))
 ;; ── 4. Lists ──
 (hk-test "empty list" (hk-parse "[]") (list :list (list)))
 (hk-test
  "singleton list"
  (hk-parse "[1]")
  (list :list (list (list :int 1))))
 (hk-test
  "list of ints"
  (hk-parse "[1, 2, 3]")
  (list
    :list
    (list (list :int 1) (list :int 2) (list :int 3))))
 (hk-test
  "range"
  (hk-parse "[1..10]")
  (list :range (list :int 1) (list :int 10)))
 (hk-test
  "range with step"
  (hk-parse "[1, 3..10]")
  (list
    :range-step
    (list :int 1)
    (list :int 3)
    (list :int 10)))
 ;; ── 5. Application ──
 (hk-test
  "one-arg app"
  (hk-parse "f x")
  (list :app (list :var "f") (list :var "x")))
 (hk-test
  "multi-arg app is left-assoc"
  (hk-parse "f x y z")
  (list
    :app
    (list
      :app
      (list :app (list :var "f") (list :var "x"))
      (list :var "y"))
    (list :var "z")))
 (hk-test
  "app with con"
  (hk-parse "Just 5")
  (list :app (list :con "Just") (list :int 5)))
 ;; ── 6. Infix operators ──
 (hk-test
  "simple +"
  (hk-parse "1 + 2")
  (list :op "+" (list :int 1) (list :int 2)))
 (hk-test
  "precedence: * binds tighter than +"
  (hk-parse "1 + 2 * 3")
  (list
    :op
    "+"
    (list :int 1)
    (list :op "*" (list :int 2) (list :int 3))))
 (hk-test
  "- is left-assoc"
  (hk-parse "10 - 3 - 2")
  (list
    :op
    "-"
    (list :op "-" (list :int 10) (list :int 3))
    (list :int 2)))
 (hk-test
  ": is right-assoc"
  (hk-parse "a : b : c")
  (list
    :op
    ":"
    (list :var "a")
    (list :op ":" (list :var "b") (list :var "c"))))
 (hk-test
  "app binds tighter than op"
  (hk-parse "f x + g y")
  (list
    :op
    "+"
    (list :app (list :var "f") (list :var "x"))
    (list :app (list :var "g") (list :var "y"))))
 (hk-test
  "$ is lowest precedence, right-assoc"
  (hk-parse "f $ g x")
  (list
    :op
    "$"
    (list :var "f")
    (list :app (list :var "g") (list :var "x"))))
 ;; ── 7. Backticks (varid-as-operator) ──
 (hk-test
  "backtick operator"
  (hk-parse "x `mod` 3")
  (list :op "mod" (list :var "x") (list :int 3)))
 ;; ── 8. Unary negation ──
 (hk-test
  "unary -"
  (hk-parse "- 5")
  (list :neg (list :int 5)))
 (hk-test
  "unary - on application"
  (hk-parse "- f x")
  (list :neg (list :app (list :var "f") (list :var "x"))))
 (hk-test
  "- n + m → (- n) + m"
  (hk-parse "- 1 + 2")
  (list
    :op
    "+"
    (list :neg (list :int 1))
    (list :int 2)))
 ;; ── 9. Lambda ──
 (hk-test
  "lambda single param"
  (hk-parse "\\x -> x")
  (list :lambda (list (list :p-var "x")) (list :var "x")))
 (hk-test
  "lambda multi-param"
  (hk-parse "\\x y -> x + y")
  (list
    :lambda
    (list (list :p-var "x") (list :p-var "y"))
    (list :op "+" (list :var "x") (list :var "y"))))
 (hk-test
  "lambda body is full expression"
  (hk-parse "\\f -> f 1 + f 2")
  (list
    :lambda
    (list (list :p-var "f"))
    (list
      :op
      "+"
      (list :app (list :var "f") (list :int 1))
      (list :app (list :var "f") (list :int 2)))))
 ;; ── 10. if-then-else ──
 (hk-test
  "if basic"
  (hk-parse "if x then 1 else 2")
  (list :if (list :var "x") (list :int 1) (list :int 2)))
 (hk-test
  "if with infix cond"
  (hk-parse "if x == 0 then y else z")
  (list
    :if
    (list :op "==" (list :var "x") (list :int 0))
    (list :var "y")
    (list :var "z")))
 ;; ── 11. let-in ──
 (hk-test
  "let single binding"
  (hk-parse "let x = 1 in x")
  (list
    :let
    (list (list :bind (list :p-var "x") (list :int 1)))
    (list :var "x")))
 (hk-test
  "let two bindings (multi-line)"
  (hk-parse "let x = 1\n    y = 2\nin x + y")
  (list
    :let
    (list
      (list :bind (list :p-var "x") (list :int 1))
      (list :bind (list :p-var "y") (list :int 2)))
    (list :op "+" (list :var "x") (list :var "y"))))
 (hk-test
  "let with explicit braces"
  (hk-parse "let { x = 1 ; y = 2 } in x + y")
  (list
    :let
    (list
      (list :bind (list :p-var "x") (list :int 1))
      (list :bind (list :p-var "y") (list :int 2)))
    (list :op "+" (list :var "x") (list :var "y"))))
 ;; ── 12. Mixed / nesting ──
 (hk-test
  "nested application"
  (hk-parse "f (g x) y")
  (list
    :app
    (list
      :app
      (list :var "f")
      (list :app (list :var "g") (list :var "x")))
    (list :var "y")))
 (hk-test
  "lambda applied"
  (hk-parse "(\\x -> x + 1) 5")
  (list
    :app
    (list
      :lambda
      (list (list :p-var "x"))
      (list :op "+" (list :var "x") (list :int 1)))
    (list :int 5)))
 (hk-test
  "lambda + if"
  (hk-parse "\\n -> if n == 0 then 1 else n")
  (list
    :lambda
    (list (list :p-var "n"))
    (list
      :if
      (list :op "==" (list :var "n") (list :int 0))
      (list :int 1)
      (list :var "n"))))
 ;; ── 13. Precedence corners ──
 (hk-test
  ". is right-assoc (prec 9)"
  (hk-parse "f . g . h")
  (list
    :op
    "."
    (list :var "f")
    (list :op "." (list :var "g") (list :var "h"))))
 (hk-test
  "== is non-associative (single use)"
  (hk-parse "x == y")
  (list :op "==" (list :var "x") (list :var "y")))
 {:fails hk-test-fails :pass hk-test-pass :fail hk-test-fail}
--- a/lib/haskell/tests/parser-guards-where.sx
+++ b/lib/haskell/tests/parser-guards-where.sx
@@ -1,261 +0,0 @@
 ;; Guards and where-clauses — on fun-clauses, case alts, and
 ;; let-bindings (which now also accept funclause-style LHS like
 ;; `let f x = e` or `let f x | g = e | g = e`).
 (define
  hk-prog
  (fn (&rest decls) (list :program decls)))
 ;; ── Guarded fun-clauses ──
 (hk-test
  "simple guards (two branches)"
  (hk-parse-top "abs x | x < 0 = - x\n      | otherwise = x")
  (hk-prog
    (list
      :fun-clause
      "abs"
      (list (list :p-var "x"))
      (list
        :guarded
        (list
          (list
            :guard
            (list :op "<" (list :var "x") (list :int 0))
            (list :neg (list :var "x")))
          (list :guard (list :var "otherwise") (list :var "x")))))))
 (hk-test
  "three-way guard"
  (hk-parse-top "sign n | n > 0 = 1\n       | n < 0 = -1\n       | otherwise = 0")
  (hk-prog
    (list
      :fun-clause
      "sign"
      (list (list :p-var "n"))
      (list
        :guarded
        (list
          (list
            :guard
            (list :op ">" (list :var "n") (list :int 0))
            (list :int 1))
          (list
            :guard
            (list :op "<" (list :var "n") (list :int 0))
            (list :neg (list :int 1)))
          (list
            :guard
            (list :var "otherwise")
            (list :int 0)))))))
 (hk-test
  "mixed: one eq clause plus one guarded clause"
  (hk-parse-top "sign 0 = 0\nsign n | n > 0 = 1\n       | otherwise = -1")
  (hk-prog
    (list
      :fun-clause
      "sign"
      (list (list :p-int 0))
      (list :int 0))
    (list
      :fun-clause
      "sign"
      (list (list :p-var "n"))
      (list
        :guarded
        (list
          (list
            :guard
            (list :op ">" (list :var "n") (list :int 0))
            (list :int 1))
          (list
            :guard
            (list :var "otherwise")
            (list :neg (list :int 1))))))))
 ;; ── where on fun-clauses ──
 (hk-test
  "where with one binding"
  (hk-parse-top "f x = y + y\n  where y = x + 1")
  (hk-prog
    (list
      :fun-clause
      "f"
      (list (list :p-var "x"))
      (list
        :where
        (list :op "+" (list :var "y") (list :var "y"))
        (list
          (list
            :fun-clause
            "y"
            (list)
            (list :op "+" (list :var "x") (list :int 1))))))))
 (hk-test
  "where with multiple bindings"
  (hk-parse-top "f x = y * z\n  where y = x + 1\n        z = x - 1")
  (hk-prog
    (list
      :fun-clause
      "f"
      (list (list :p-var "x"))
      (list
        :where
        (list :op "*" (list :var "y") (list :var "z"))
        (list
          (list
            :fun-clause
            "y"
            (list)
            (list :op "+" (list :var "x") (list :int 1)))
          (list
            :fun-clause
            "z"
            (list)
            (list :op "-" (list :var "x") (list :int 1))))))))
 (hk-test
  "guards + where"
  (hk-parse-top "f x | x > 0 = y\n    | otherwise = 0\n  where y = 99")
  (hk-prog
    (list
      :fun-clause
      "f"
      (list (list :p-var "x"))
      (list
        :where
        (list
          :guarded
          (list
            (list
              :guard
              (list :op ">" (list :var "x") (list :int 0))
              (list :var "y"))
            (list
              :guard
              (list :var "otherwise")
              (list :int 0))))
        (list
          (list :fun-clause "y" (list) (list :int 99)))))))
 ;; ── Guards in case alts ──
 (hk-test
  "case alt with guards"
  (hk-parse "case x of\n  Just y | y > 0 -> y\n         | otherwise -> 0\n  Nothing -> 0")
  (list
    :case
    (list :var "x")
    (list
      (list
        :alt
        (list :p-con "Just" (list (list :p-var "y")))
        (list
          :guarded
          (list
            (list
              :guard
              (list :op ">" (list :var "y") (list :int 0))
              (list :var "y"))
            (list
              :guard
              (list :var "otherwise")
              (list :int 0)))))
      (list :alt (list :p-con "Nothing" (list)) (list :int 0)))))
 (hk-test
  "case alt with where"
  (hk-parse "case x of\n  Just y -> y + z where z = 5\n  Nothing -> 0")
  (list
    :case
    (list :var "x")
    (list
      (list
        :alt
        (list :p-con "Just" (list (list :p-var "y")))
        (list
          :where
          (list :op "+" (list :var "y") (list :var "z"))
          (list
            (list :fun-clause "z" (list) (list :int 5)))))
      (list :alt (list :p-con "Nothing" (list)) (list :int 0)))))
 ;; ── let-bindings: funclause form, guards, where ──
 (hk-test
  "let with funclause shorthand"
  (hk-parse "let f x = x + 1 in f 5")
  (list
    :let
    (list
      (list
        :fun-clause
        "f"
        (list (list :p-var "x"))
        (list :op "+" (list :var "x") (list :int 1))))
    (list :app (list :var "f") (list :int 5))))
 (hk-test
  "let with guards"
  (hk-parse "let f x | x > 0 = x\n        | otherwise = 0\nin f 3")
  (list
    :let
    (list
      (list
        :fun-clause
        "f"
        (list (list :p-var "x"))
        (list
          :guarded
          (list
            (list
              :guard
              (list :op ">" (list :var "x") (list :int 0))
              (list :var "x"))
            (list
              :guard
              (list :var "otherwise")
              (list :int 0))))))
    (list :app (list :var "f") (list :int 3))))
 (hk-test
  "let funclause + where"
  (hk-parse "let f x = y where y = x + 1\nin f 7")
  (list
    :let
    (list
      (list
        :fun-clause
        "f"
        (list (list :p-var "x"))
        (list
          :where
          (list :var "y")
          (list
            (list
              :fun-clause
              "y"
              (list)
              (list :op "+" (list :var "x") (list :int 1)))))))
    (list :app (list :var "f") (list :int 7))))
 ;; ── Nested: where inside where (via recursive hk-parse-decl) ──
 (hk-test
  "where block can contain a type signature"
  (hk-parse-top "f x = y\n  where y :: Int\n        y = x")
  (hk-prog
    (list
      :fun-clause
      "f"
      (list (list :p-var "x"))
      (list
        :where
        (list :var "y")
        (list
          (list :type-sig (list "y") (list :t-con "Int"))
          (list
            :fun-clause
            "y"
            (list)
            (list :var "x")))))))
 {:fails hk-test-fails :pass hk-test-pass :fail hk-test-fail}
--- a/lib/haskell/tests/parser-module.sx
+++ b/lib/haskell/tests/parser-module.sx
@@ -1,202 +0,0 @@
 ;; Module header + imports. The parser switches from (:program DECLS)
 ;; to (:module NAME EXPORTS IMPORTS DECLS) as soon as a module header
 ;; or any `import` decl appears.
 ;; ── Module header ──
 (hk-test
  "simple module, no exports"
  (hk-parse-top "module M where\n  f = 1")
  (list
    :module
    "M"
    nil
    (list)
    (list (list :fun-clause "f" (list) (list :int 1)))))
 (hk-test
  "module with dotted name"
  (hk-parse-top "module Data.Map where\nf = 1")
  (list
    :module
    "Data.Map"
    nil
    (list)
    (list (list :fun-clause "f" (list) (list :int 1)))))
 (hk-test
  "module with empty export list"
  (hk-parse-top "module M () where\nf = 1")
  (list
    :module
    "M"
    (list)
    (list)
    (list (list :fun-clause "f" (list) (list :int 1)))))
 (hk-test
  "module with exports (var, tycon-all, tycon-with)"
  (hk-parse-top "module M (f, g, Maybe(..), List(Cons, Nil)) where\nf = 1\ng = 2")
  (list
    :module
    "M"
    (list
      (list :ent-var "f")
      (list :ent-var "g")
      (list :ent-all "Maybe")
      (list :ent-with "List" (list "Cons" "Nil")))
    (list)
    (list
      (list :fun-clause "f" (list) (list :int 1))
      (list :fun-clause "g" (list) (list :int 2)))))
 (hk-test
  "module export list including another module"
  (hk-parse-top "module M (module Foo, f) where\nf = 1")
  (list
    :module
    "M"
    (list (list :ent-module "Foo") (list :ent-var "f"))
    (list)
    (list (list :fun-clause "f" (list) (list :int 1)))))
 (hk-test
  "module export with operator"
  (hk-parse-top "module M ((+:), f) where\nf = 1")
  (list
    :module
    "M"
    (list (list :ent-var "+:") (list :ent-var "f"))
    (list)
    (list (list :fun-clause "f" (list) (list :int 1)))))
 (hk-test
  "empty module body"
  (hk-parse-top "module M where")
  (list :module "M" nil (list) (list)))
 ;; ── Imports ──
 (hk-test
  "plain import"
  (hk-parse-top "import Foo")
  (list
    :module
    nil
    nil
    (list (list :import false "Foo" nil nil))
    (list)))
 (hk-test
  "qualified import"
  (hk-parse-top "import qualified Data.Map")
  (list
    :module
    nil
    nil
    (list (list :import true "Data.Map" nil nil))
    (list)))
 (hk-test
  "import with alias"
  (hk-parse-top "import Data.Map as M")
  (list
    :module
    nil
    nil
    (list (list :import false "Data.Map" "M" nil))
    (list)))
 (hk-test
  "import with explicit list"
  (hk-parse-top "import Foo (bar, Baz(..), Quux(X, Y))")
  (list
    :module
    nil
    nil
    (list
      (list
        :import
        false
        "Foo"
        nil
        (list
          :spec-items
          (list
            (list :ent-var "bar")
            (list :ent-all "Baz")
            (list :ent-with "Quux" (list "X" "Y"))))))
    (list)))
 (hk-test
  "import hiding"
  (hk-parse-top "import Foo hiding (x, y)")
  (list
    :module
    nil
    nil
    (list
      (list
        :import
        false
        "Foo"
        nil
        (list
          :spec-hiding
          (list (list :ent-var "x") (list :ent-var "y")))))
    (list)))
 (hk-test
  "qualified + alias + hiding"
  (hk-parse-top "import qualified Data.List as L hiding (sort)")
  (list
    :module
    nil
    nil
    (list
      (list
        :import
        true
        "Data.List"
        "L"
        (list :spec-hiding (list (list :ent-var "sort")))))
    (list)))
 ;; ── Combinations ──
 (hk-test
  "module with multiple imports and a decl"
  (hk-parse-top "module M where\nimport Foo\nimport qualified Bar as B\nf = 1")
  (list
    :module
    "M"
    nil
    (list
      (list :import false "Foo" nil nil)
      (list :import true "Bar" "B" nil))
    (list (list :fun-clause "f" (list) (list :int 1)))))
 (hk-test
  "headerless file with imports"
  (hk-parse-top "import Foo\nimport Bar (baz)\nf = 1")
  (list
    :module
    nil
    nil
    (list
      (list :import false "Foo" nil nil)
      (list
        :import
        false
        "Bar"
        nil
        (list :spec-items (list (list :ent-var "baz")))))
    (list (list :fun-clause "f" (list) (list :int 1)))))
 (hk-test
  "plain program (no header, no imports) still uses :program"
  (hk-parse-top "f = 1\ng = 2")
  (list
    :program
    (list
      (list :fun-clause "f" (list) (list :int 1))
      (list :fun-clause "g" (list) (list :int 2)))))
 {:fails hk-test-fails :pass hk-test-pass :fail hk-test-fail}
--- a/lib/haskell/tests/parser-patterns.sx
+++ b/lib/haskell/tests/parser-patterns.sx
@@ -1,234 +0,0 @@
 ;; Full-pattern parser tests: as-patterns, lazy ~, negative literals,
 ;; infix constructor patterns (`:`, any consym), lambda pattern args,
 ;; and let pattern-bindings.
 ;; ── as-patterns ──
 (hk-test
  "as pattern, wraps constructor"
  (hk-parse "case x of n@(Just y) -> n")
  (list
    :case
    (list :var "x")
    (list
      (list
        :alt
        (list
          :p-as
          "n"
          (list :p-con "Just" (list (list :p-var "y"))))
        (list :var "n")))))
 (hk-test
  "as pattern, wraps wildcard"
  (hk-parse "case x of all@_ -> all")
  (list
    :case
    (list :var "x")
    (list
      (list
        :alt
        (list :p-as "all" (list :p-wild))
        (list :var "all")))))
 (hk-test
  "as in lambda"
  (hk-parse "\\xs@(a : rest) -> xs")
  (list
    :lambda
    (list
      (list
        :p-as
        "xs"
        (list
          :p-con
          ":"
          (list (list :p-var "a") (list :p-var "rest")))))
    (list :var "xs")))
 ;; ── lazy patterns ──
 (hk-test
  "lazy var"
  (hk-parse "case x of ~y -> y")
  (list
    :case
    (list :var "x")
    (list
      (list :alt (list :p-lazy (list :p-var "y")) (list :var "y")))))
 (hk-test
  "lazy constructor"
  (hk-parse "\\(~(Just x)) -> x")
  (list
    :lambda
    (list
      (list
        :p-lazy
        (list :p-con "Just" (list (list :p-var "x")))))
    (list :var "x")))
 ;; ── negative literal patterns ──
 (hk-test
  "negative int pattern"
  (hk-parse "case n of\n  -1 -> 0\n  _ -> n")
  (list
    :case
    (list :var "n")
    (list
      (list :alt (list :p-int -1) (list :int 0))
      (list :alt (list :p-wild) (list :var "n")))))
 (hk-test
  "negative float pattern"
  (hk-parse "case x of -0.5 -> 1")
  (list
    :case
    (list :var "x")
    (list (list :alt (list :p-float -0.5) (list :int 1)))))
 ;; ── infix constructor patterns (`:` and any consym) ──
 (hk-test
  "cons pattern"
  (hk-parse "case xs of x : rest -> x")
  (list
    :case
    (list :var "xs")
    (list
      (list
        :alt
        (list
          :p-con
          ":"
          (list (list :p-var "x") (list :p-var "rest")))
        (list :var "x")))))
 (hk-test
  "cons is right-associative in pats"
  (hk-parse "case xs of a : b : rest -> rest")
  (list
    :case
    (list :var "xs")
    (list
      (list
        :alt
        (list
          :p-con
          ":"
          (list
            (list :p-var "a")
            (list
              :p-con
              ":"
              (list (list :p-var "b") (list :p-var "rest")))))
        (list :var "rest")))))
 (hk-test
  "consym pattern"
  (hk-parse "case p of a :+: b -> a")
  (list
    :case
    (list :var "p")
    (list
      (list
        :alt
        (list
          :p-con
          ":+:"
          (list (list :p-var "a") (list :p-var "b")))
        (list :var "a")))))
 ;; ── lambda with pattern args ──
 (hk-test
  "lambda with constructor pattern"
  (hk-parse "\\(Just x) -> x")
  (list
    :lambda
    (list (list :p-con "Just" (list (list :p-var "x"))))
    (list :var "x")))
 (hk-test
  "lambda with tuple pattern"
  (hk-parse "\\(a, b) -> a + b")
  (list
    :lambda
    (list
      (list
        :p-tuple
        (list (list :p-var "a") (list :p-var "b"))))
    (list :op "+" (list :var "a") (list :var "b"))))
 (hk-test
  "lambda with wildcard"
  (hk-parse "\\_ -> 42")
  (list :lambda (list (list :p-wild)) (list :int 42)))
 (hk-test
  "lambda with mixed apats"
  (hk-parse "\\x _ (Just y) -> y")
  (list
    :lambda
    (list
      (list :p-var "x")
      (list :p-wild)
      (list :p-con "Just" (list (list :p-var "y"))))
    (list :var "y")))
 ;; ── let pattern-bindings ──
 (hk-test
  "let tuple pattern-binding"
  (hk-parse "let (x, y) = pair in x + y")
  (list
    :let
    (list
      (list
        :bind
        (list
          :p-tuple
          (list (list :p-var "x") (list :p-var "y")))
        (list :var "pair")))
    (list :op "+" (list :var "x") (list :var "y"))))
 (hk-test
  "let constructor pattern-binding"
  (hk-parse "let Just x = m in x")
  (list
    :let
    (list
      (list
        :bind
        (list :p-con "Just" (list (list :p-var "x")))
        (list :var "m")))
    (list :var "x")))
 (hk-test
  "let cons pattern-binding"
  (hk-parse "let (x : rest) = xs in x")
  (list
    :let
    (list
      (list
        :bind
        (list
          :p-con
          ":"
          (list (list :p-var "x") (list :p-var "rest")))
        (list :var "xs")))
    (list :var "x")))
 ;; ── do with constructor-pattern binds ──
 (hk-test
  "do bind to tuple pattern"
  (hk-parse "do\n  (a, b) <- pairs\n  return a")
  (list
    :do
    (list
      (list
        :do-bind
        (list
          :p-tuple
          (list (list :p-var "a") (list :p-var "b")))
        (list :var "pairs"))
      (list
        :do-expr
        (list :app (list :var "return") (list :var "a"))))))
 {:fails hk-test-fails :pass hk-test-pass :fail hk-test-fail}
--- a/lib/haskell/tests/parser-sect-comp.sx
+++ b/lib/haskell/tests/parser-sect-comp.sx
@@ -1,191 +0,0 @@
 ;; Operator sections and list comprehensions.
 ;; ── Operator references (unchanged expr shape) ──
 (hk-test
  "op as value (+)"
  (hk-parse "(+)")
  (list :var "+"))
 (hk-test
  "op as value (-)"
  (hk-parse "(-)")
  (list :var "-"))
 (hk-test
  "op as value (:)"
  (hk-parse "(:)")
  (list :var ":"))
 (hk-test
  "backtick op as value"
  (hk-parse "(`div`)")
  (list :var "div"))
 ;; ── Right sections (op expr) ──
 (hk-test
  "right section (+ 5)"
  (hk-parse "(+ 5)")
  (list :sect-right "+" (list :int 5)))
 (hk-test
  "right section (* x)"
  (hk-parse "(* x)")
  (list :sect-right "*" (list :var "x")))
 (hk-test
  "right section with backtick op"
  (hk-parse "(`div` 2)")
  (list :sect-right "div" (list :int 2)))
 ;; `-` is unary in expr position — (- 5) is negation, not a right section
 (hk-test
  "(- 5) is negation, not a section"
  (hk-parse "(- 5)")
  (list :neg (list :int 5)))
 ;; ── Left sections (expr op) ──
 (hk-test
  "left section (5 +)"
  (hk-parse "(5 +)")
  (list :sect-left "+" (list :int 5)))
 (hk-test
  "left section with backtick"
  (hk-parse "(x `mod`)")
  (list :sect-left "mod" (list :var "x")))
 (hk-test
  "left section with cons (x :)"
  (hk-parse "(x :)")
  (list :sect-left ":" (list :var "x")))
 ;; ── Mixed / nesting ──
 (hk-test
  "map (+ 1) xs"
  (hk-parse "map (+ 1) xs")
  (list
    :app
    (list
      :app
      (list :var "map")
      (list :sect-right "+" (list :int 1)))
    (list :var "xs")))
 (hk-test
  "filter (< 0) xs"
  (hk-parse "filter (< 0) xs")
  (list
    :app
    (list
      :app
      (list :var "filter")
      (list :sect-right "<" (list :int 0)))
    (list :var "xs")))
 ;; ── Plain parens and tuples still work ──
 (hk-test
  "plain parens unwrap"
  (hk-parse "(1 + 2)")
  (list :op "+" (list :int 1) (list :int 2)))
 (hk-test
  "tuple still parses"
  (hk-parse "(a, b, c)")
  (list
    :tuple
    (list (list :var "a") (list :var "b") (list :var "c"))))
 ;; ── List comprehensions ──
 (hk-test
  "simple list comprehension"
  (hk-parse "[x | x <- xs]")
  (list
    :list-comp
    (list :var "x")
    (list
      (list :q-gen (list :p-var "x") (list :var "xs")))))
 (hk-test
  "comprehension with filter"
  (hk-parse "[x * 2 | x <- xs, x > 0]")
  (list
    :list-comp
    (list :op "*" (list :var "x") (list :int 2))
    (list
      (list :q-gen (list :p-var "x") (list :var "xs"))
      (list
        :q-guard
        (list :op ">" (list :var "x") (list :int 0))))))
 (hk-test
  "comprehension with let"
  (hk-parse "[y | x <- xs, let y = x + 1]")
  (list
    :list-comp
    (list :var "y")
    (list
      (list :q-gen (list :p-var "x") (list :var "xs"))
      (list
        :q-let
        (list
          (list
            :bind
            (list :p-var "y")
            (list :op "+" (list :var "x") (list :int 1))))))))
 (hk-test
  "nested generators"
  (hk-parse "[(x, y) | x <- xs, y <- ys]")
  (list
    :list-comp
    (list :tuple (list (list :var "x") (list :var "y")))
    (list
      (list :q-gen (list :p-var "x") (list :var "xs"))
      (list :q-gen (list :p-var "y") (list :var "ys")))))
 (hk-test
  "comprehension with constructor pattern"
  (hk-parse "[v | Just v <- xs]")
  (list
    :list-comp
    (list :var "v")
    (list
      (list
        :q-gen
        (list :p-con "Just" (list (list :p-var "v")))
        (list :var "xs")))))
 (hk-test
  "comprehension with tuple pattern"
  (hk-parse "[x + y | (x, y) <- pairs]")
  (list
    :list-comp
    (list :op "+" (list :var "x") (list :var "y"))
    (list
      (list
        :q-gen
        (list
          :p-tuple
          (list (list :p-var "x") (list :p-var "y")))
        (list :var "pairs")))))
 (hk-test
  "combination: generator, let, guard"
  (hk-parse "[z | x <- xs, let z = x * 2, z > 10]")
  (list
    :list-comp
    (list :var "z")
    (list
      (list :q-gen (list :p-var "x") (list :var "xs"))
      (list
        :q-let
        (list
          (list
            :bind
            (list :p-var "z")
            (list :op "*" (list :var "x") (list :int 2)))))
      (list
        :q-guard
        (list :op ">" (list :var "z") (list :int 10))))))
 {:fails hk-test-fails :pass hk-test-pass :fail hk-test-fail}
--- a/lib/haskell/tests/program-calculator.sx
+++ b/lib/haskell/tests/program-calculator.sx
@@ -1,55 +0,0 @@
 ;; calculator.hs — recursive descent expression evaluator.
 ;;
 ;; Exercises:
 ;;   - ADTs with constructor fields: TNum Int, TOp String, R Int [Token]
 ;;   - Nested constructor pattern matching: (R v (TOp "+":rest))
 ;;   - let bindings in function bodies
 ;;   - Integer arithmetic including `div` (backtick infix)
 ;;   - Left-associative multi-level operator precedence
 (define
  hk-prog-val
  (fn
    (src name)
    (hk-deep-force (get (hk-eval-program (hk-core src)) name))))
 (define
  hk-calc-src
  "data Token = TNum Int | TOp String\ndata Result = R Int [Token]\ngetV (R v _) = v\ngetR (R _ r) = r\neval ts = getV (parseExpr ts)\nparseExpr ts = parseExprRest (parseTerm ts)\nparseExprRest (R v (TOp \"+\":rest)) =\n  let t = parseTerm rest\n  in parseExprRest (R (v + getV t) (getR t))\nparseExprRest (R v (TOp \"-\":rest)) =\n  let t = parseTerm rest\n  in parseExprRest (R (v - getV t) (getR t))\nparseExprRest r = r\nparseTerm ts = parseTermRest (parseFactor ts)\nparseTermRest (R v (TOp \"*\":rest)) =\n  let t = parseFactor rest\n  in parseTermRest (R (v * getV t) (getR t))\nparseTermRest (R v (TOp \"/\":rest)) =\n  let t = parseFactor rest\n  in parseTermRest (R (v `div` getV t) (getR t))\nparseTermRest r = r\nparseFactor (TNum n:rest) = R n rest\n")
 (hk-test
  "calculator: 2 + 3 = 5"
  (hk-prog-val
    (str hk-calc-src "result = eval [TNum 2, TOp \"+\", TNum 3]\n")
    "result")
  5)
 (hk-test
  "calculator: 2 + 3 * 4 = 14 (precedence)"
  (hk-prog-val
    (str hk-calc-src "result = eval [TNum 2, TOp \"+\", TNum 3, TOp \"*\", TNum 4]\n")
    "result")
  14)
 (hk-test
  "calculator: 10 - 3 - 2 = 5 (left-assoc)"
  (hk-prog-val
    (str hk-calc-src "result = eval [TNum 10, TOp \"-\", TNum 3, TOp \"-\", TNum 2]\n")
    "result")
  5)
 (hk-test
  "calculator: 6 / 2 * 3 = 9 (left-assoc)"
  (hk-prog-val
    (str hk-calc-src "result = eval [TNum 6, TOp \"/\", TNum 2, TOp \"*\", TNum 3]\n")
    "result")
  9)
 (hk-test
  "calculator: single number"
  (hk-prog-val
    (str hk-calc-src "result = eval [TNum 42]\n")
    "result")
  42)
 {:fails hk-test-fails :pass hk-test-pass :fail hk-test-fail}
--- a/lib/haskell/tests/program-fib.sx
+++ b/lib/haskell/tests/program-fib.sx
@@ -1,45 +0,0 @@
 ;; fib.hs — infinite Fibonacci stream classic program.
 ;;
 ;; The canonical artefact lives at lib/haskell/tests/programs/fib.hs.
 ;; The source is mirrored here as an SX string because the evaluator
 ;; doesn't have read-file in the default env. If you change one, keep
 ;; the other in sync — there's a runner-level cross-check against the
 ;; expected first-15 list.
 (define
  hk-prog-val
  (fn
    (src name)
    (hk-deep-force (get (hk-eval-program (hk-core src)) name))))
 (define hk-as-list
  (fn (xs)
    (cond
      ((and (list? xs) (= (first xs) "[]")) (list))
      ((and (list? xs) (= (first xs) ":"))
        (cons (nth xs 1) (hk-as-list (nth xs 2))))
      (:else xs))))
 (define
  hk-fib-source
  "zipPlus (x:xs) (y:ys) = x + y : zipPlus xs ys
 zipPlus _ _ = []
 myFibs = 0 : 1 : zipPlus myFibs (tail myFibs)
 result = take 15 myFibs
 ")
 (hk-test
  "fib.hs — first 15 Fibonacci numbers"
  (hk-as-list (hk-prog-val hk-fib-source "result"))
  (list 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377))
 ;; Spot-check that the user-defined zipPlus is also reachable
 (hk-test
  "fib.hs — zipPlus is a multi-clause user fn"
  (hk-as-list
    (hk-prog-val
      (str hk-fib-source "extra = zipPlus [1, 2, 3] [10, 20, 30]\n")
      "extra"))
  (list 11 22 33))
 {:fails hk-test-fails :pass hk-test-pass :fail hk-test-fail}
--- a/lib/haskell/tests/program-nqueens.sx
+++ b/lib/haskell/tests/program-nqueens.sx
@@ -1,38 +0,0 @@
 ;; nqueens.hs — n-queens solver via list comprehension + where.
 ;;
 ;; Also exercises:
 ;;   - multi-clause let/where binding (go 0 = ...; go k = ...)
 ;;   - list comprehensions (desugared to concatMap)
 ;;   - abs (from Prelude)
 ;;   - [1..n] finite range
 ;;
 ;; n=8 is too slow for a 60s timeout; n=4 and n=5 run in ~17s combined.
 (define
  hk-prog-val
  (fn
    (src name)
    (hk-deep-force (get (hk-eval-program (hk-core src)) name))))
 (define
  hk-nq-base
  "queens n = go n
  where
    go 0 = [[]]
    go k = [q:qs | qs <- go (k - 1), q <- [1..n], safe q qs]
 safe q qs = check q qs 1
 check q [] _ = True
 check q (c:cs) d = q /= c && abs (q - c) /= d && check q cs (d + 1)
 ")
 (hk-test
  "nqueens: queens 4 has 2 solutions"
  (hk-prog-val (str hk-nq-base "result = length (queens 4)\n") "result")
  2)
 (hk-test
  "nqueens: queens 5 has 10 solutions"
  (hk-prog-val (str hk-nq-base "result = length (queens 5)\n") "result")
  10)
 {:fails hk-test-fails :pass hk-test-pass :fail hk-test-fail}
--- a/lib/haskell/tests/program-quicksort.sx
+++ b/lib/haskell/tests/program-quicksort.sx
@@ -1,65 +0,0 @@
 ;; quicksort.hs — naive functional quicksort.
 (define
  hk-as-list
  (fn (xs)
    (cond
      ((and (list? xs) (= (first xs) "[]")) (list))
      ((and (list? xs) (= (first xs) ":"))
        (cons (nth xs 1) (hk-as-list (nth xs 2))))
      (:else xs))))
 (define
  hk-prog-val
  (fn
    (src name)
    (hk-deep-force (get (hk-eval-program (hk-core src)) name))))
 (define
  hk-qs-source
  "qsort [] = []
 qsort (x:xs) = qsort smaller ++ [x] ++ qsort larger
  where
    smaller = filter (< x) xs
    larger  = filter (>= x) xs
 result = qsort [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
 ")
 (hk-test
  "quicksort.hs — sort a list of ints"
  (hk-as-list (hk-prog-val hk-qs-source "result"))
  (list 1 1 2 3 3 4 5 5 5 6 9))
 (hk-test
  "quicksort.hs — empty list"
  (hk-as-list
    (hk-prog-val
      (str hk-qs-source "e = qsort []\n")
      "e"))
  (list))
 (hk-test
  "quicksort.hs — singleton"
  (hk-as-list
    (hk-prog-val
      (str hk-qs-source "s = qsort [42]\n")
      "s"))
  (list 42))
 (hk-test
  "quicksort.hs — already sorted"
  (hk-as-list
    (hk-prog-val
      (str hk-qs-source "asc = qsort [1, 2, 3, 4, 5]\n")
      "asc"))
  (list 1 2 3 4 5))
 (hk-test
  "quicksort.hs — reverse sorted"
  (hk-as-list
    (hk-prog-val
      (str hk-qs-source "desc = qsort [5, 4, 3, 2, 1]\n")
      "desc"))
  (list 1 2 3 4 5))
 {:fails hk-test-fails :pass hk-test-pass :fail hk-test-fail}
--- a/lib/haskell/tests/program-sieve.sx
+++ b/lib/haskell/tests/program-sieve.sx
@@ -1,48 +0,0 @@
 ;; sieve.hs — lazy sieve of Eratosthenes.
 ;;
 ;; The canonical artefact lives at lib/haskell/tests/programs/sieve.hs.
 ;; Mirrored here as an SX string because the default eval env has no
 ;; read-file. Uses filter + backtick `mod` + lazy [2..] — all of which
 ;; are now wired in via Phase 3 + the mod/div additions to hk-binop.
 (define
  hk-as-list
  (fn (xs)
    (cond
      ((and (list? xs) (= (first xs) "[]")) (list))
      ((and (list? xs) (= (first xs) ":"))
        (cons (nth xs 1) (hk-as-list (nth xs 2))))
      (:else xs))))
 (define
  hk-prog-val
  (fn
    (src name)
    (hk-deep-force (get (hk-eval-program (hk-core src)) name))))
 (define
  hk-sieve-source
  "sieve (p:xs) = p : sieve (filter (\\x -> x `mod` p /= 0) xs)
 sieve [] = []
 primes = sieve [2..]
 result = take 10 primes
 ")
 (hk-test
  "sieve.hs — first 10 primes"
  (hk-as-list (hk-prog-val hk-sieve-source "result"))
  (list 2 3 5 7 11 13 17 19 23 29))
 (hk-test
  "sieve.hs — 20th prime is 71"
  (nth
    (hk-as-list
      (hk-prog-val
        (str
          hk-sieve-source
          "result20 = take 20 primes\n")
        "result20"))
    19)
  71)
 {:fails hk-test-fails :pass hk-test-pass :fail hk-test-fail}
--- a/lib/haskell/tests/programs/calculator.hs
+++ b/lib/haskell/tests/programs/calculator.hs
@@ -1,40 +0,0 @@
 -- calculator.hs — recursive descent expression evaluator.
 --
 -- Tokens are represented as an ADT; the parser threads a [Token] list
 -- through a custom Result type so pattern matching can destructure the
 -- pair (value, remaining-tokens) directly inside constructor patterns.
 --
 -- Operator precedence: * and / bind tighter than + and -.
 -- All operators are left-associative.
 data Token = TNum Int | TOp String
 data Result = R Int [Token]
 getV (R v _) = v
 getR (R _ r) = r
 eval ts = getV (parseExpr ts)
 parseExpr ts = parseExprRest (parseTerm ts)
 parseExprRest (R v (TOp "+":rest)) =
  let t = parseTerm rest
  in parseExprRest (R (v + getV t) (getR t))
 parseExprRest (R v (TOp "-":rest)) =
  let t = parseTerm rest
  in parseExprRest (R (v - getV t) (getR t))
 parseExprRest r = r
 parseTerm ts = parseTermRest (parseFactor ts)
 parseTermRest (R v (TOp "*":rest)) =
  let t = parseFactor rest
  in parseTermRest (R (v * getV t) (getR t))
 parseTermRest (R v (TOp "/":rest)) =
  let t = parseFactor rest
  in parseTermRest (R (v `div` getV t) (getR t))
 parseTermRest r = r
 parseFactor (TNum n:rest) = R n rest
 result = eval [TNum 2, TOp "+", TNum 3, TOp "*", TNum 4]
--- a/lib/haskell/tests/programs/fib.hs
+++ b/lib/haskell/tests/programs/fib.hs
@@ -1,15 +0,0 @@
 -- fib.hs — infinite Fibonacci stream.
 --
 -- The classic two-line definition: `fibs` is a self-referential
 -- lazy list built by zipping itself with its own tail, summing the
 -- pair at each step. Without lazy `:` (cons cell with thunked head
 -- and tail) this would diverge before producing any output; with
 -- it, `take 15 fibs` evaluates exactly as much of the spine as
 -- demanded.
 zipPlus (x:xs) (y:ys) = x + y : zipPlus xs ys
 zipPlus _ _ = []
 myFibs = 0 : 1 : zipPlus myFibs (tail myFibs)
 result = take 15 myFibs
--- a/lib/haskell/tests/programs/nqueens.hs
+++ b/lib/haskell/tests/programs/nqueens.hs
@@ -1,18 +0,0 @@
 -- nqueens.hs — n-queens backtracking solver.
 --
 -- `queens n` returns all solutions as lists of column positions,
 -- one per row. Each call to `go k` extends all partial `(k-1)`-row
 -- solutions by one safe queen, using a list comprehension whose guard
 -- checks the new queen against all already-placed queens.
 queens n = go n
  where
    go 0 = [[]]
    go k = [q:qs | qs <- go (k - 1), q <- [1..n], safe q qs]
 safe q qs = check q qs 1
 check q [] _     = True
 check q (c:cs) d = q /= c && abs (q - c) /= d && check q cs (d + 1)
 result = length (queens 8)
--- a/lib/haskell/tests/programs/quicksort.hs
+++ b/lib/haskell/tests/programs/quicksort.hs
@@ -1,12 +0,0 @@
 -- quicksort.hs — naive functional quicksort.
 --
 -- Partition by pivot, recurse on each half, concatenate.
 -- Uses right sections `(< x)` and `(>= x)` with filter.
 qsort [] = []
 qsort (x:xs) = qsort smaller ++ [x] ++ qsort larger
  where
    smaller = filter (< x) xs
    larger  = filter (>= x) xs
 result = qsort [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
--- a/lib/haskell/tests/programs/sieve.hs
+++ b/lib/haskell/tests/programs/sieve.hs
@@ -1,13 +0,0 @@
 -- sieve.hs — lazy sieve of Eratosthenes.
 --
 -- Each recursive call to `sieve` consumes one prime `p` off the front
 -- of the input stream and produces an infinite stream of composites
 -- filtered out via `filter`. Because cons is lazy, only as much of
 -- the stream is forced as demanded by `take`.
 sieve (p:xs) = p : sieve (filter (\x -> x `mod` p /= 0) xs)
 sieve [] = []
 primes = sieve [2..]
 result = take 10 primes
--- a/lib/haskell/tests/runtime.sx
+++ b/lib/haskell/tests/runtime.sx
@@ -1,127 +0,0 @@
 ;; Runtime constructor-registry tests. Built-ins are pre-registered
 ;; when lib/haskell/runtime.sx loads; user types are registered by
 ;; walking a parsed+desugared AST with hk-register-program! (or the
 ;; `hk-load-source!` convenience).
 ;; ── Pre-registered built-ins ──
 (hk-test "True is a con" (hk-is-con? "True") true)
 (hk-test "False is a con" (hk-is-con? "False") true)
 (hk-test "[] is a con" (hk-is-con? "[]") true)
 (hk-test ": (cons) is a con" (hk-is-con? ":") true)
 (hk-test "() is a con" (hk-is-con? "()") true)
 (hk-test "True arity 0" (hk-con-arity "True") 0)
 (hk-test ": arity 2" (hk-con-arity ":") 2)
 (hk-test "[] arity 0" (hk-con-arity "[]") 0)
 (hk-test "True type Bool" (hk-con-type "True") "Bool")
 (hk-test "False type Bool" (hk-con-type "False") "Bool")
 (hk-test ": type List" (hk-con-type ":") "List")
 (hk-test "() type Unit" (hk-con-type "()") "Unit")
 ;; ── Unknown names ──
 (hk-test "is-con? false for varid" (hk-is-con? "foo") false)
 (hk-test "arity nil for unknown" (hk-con-arity "NotACon") nil)
 (hk-test "type nil for unknown" (hk-con-type "NotACon") nil)
 ;; ── data MyBool = Yes | No ──
 (hk-test
  "register simple data"
  (do
    (hk-load-source! "data MyBool = Yes | No")
    (list
      (hk-con-arity "Yes")
      (hk-con-arity "No")
      (hk-con-type "Yes")
      (hk-con-type "No")))
  (list 0 0 "MyBool" "MyBool"))
 ;; ── data Maybe a = Nothing | Just a ──
 (hk-test
  "register Maybe"
  (do
    (hk-load-source! "data Maybe a = Nothing | Just a")
    (list
      (hk-con-arity "Nothing")
      (hk-con-arity "Just")
      (hk-con-type "Nothing")
      (hk-con-type "Just")))
  (list 0 1 "Maybe" "Maybe"))
 ;; ── data Either a b = Left a | Right b ──
 (hk-test
  "register Either"
  (do
    (hk-load-source! "data Either a b = Left a | Right b")
    (list
      (hk-con-arity "Left")
      (hk-con-arity "Right")
      (hk-con-type "Left")
      (hk-con-type "Right")))
  (list 1 1 "Either" "Either"))
 ;; ── Recursive data ──
 (hk-test
  "register recursive Tree"
  (do
    (hk-load-source!
      "data Tree a = Leaf | Node (Tree a) a (Tree a)")
    (list
      (hk-con-arity "Leaf")
      (hk-con-arity "Node")
      (hk-con-type "Leaf")
      (hk-con-type "Node")))
  (list 0 3 "Tree" "Tree"))
 ;; ── newtype ──
 (hk-test
  "register newtype"
  (do
    (hk-load-source! "newtype Age = MkAge Int")
    (list
      (hk-con-arity "MkAge")
      (hk-con-type "MkAge")))
  (list 1 "Age"))
 ;; ── Multiple data decls in one program ──
 (hk-test
  "multiple data decls"
  (do
    (hk-load-source!
      "data Color = Red | Green | Blue\ndata Shape = Circle | Square\nf x = x")
    (list
      (hk-con-type "Red")
      (hk-con-type "Green")
      (hk-con-type "Blue")
      (hk-con-type "Circle")
      (hk-con-type "Square")))
  (list "Color" "Color" "Color" "Shape" "Shape"))
 ;; ── Inside a module header ──
 (hk-test
  "register from module body"
  (do
    (hk-load-source!
      "module M where\ndata Pair a = Pair a a")
    (list
      (hk-con-arity "Pair")
      (hk-con-type "Pair")))
  (list 2 "Pair"))
 ;; ── Non-data decls are ignored ──
 (hk-test
  "program with only fun-decl leaves registry unchanged for that name"
  (do
    (hk-load-source! "myFunctionNotACon x = x + 1")
    (hk-is-con? "myFunctionNotACon"))
  false)
 ;; ── Re-registering overwrites (last wins) ──
 (hk-test
  "re-registration overwrites the entry"
  (do
    (hk-load-source! "data Foo = Bar Int")
    (hk-load-source! "data Foo = Bar Int Int")
    (hk-con-arity "Bar"))
  2)
 {:fails hk-test-fails :pass hk-test-pass :fail hk-test-fail}
--- a/lib/haskell/tests/seq.sx
+++ b/lib/haskell/tests/seq.sx
@@ -1,85 +0,0 @@
 ;; seq / deepseq tests. seq is strict in its first arg (forces to
 ;; WHNF) and returns the second arg unchanged. deepseq additionally
 ;; forces the first arg to normal form.
 (define
  hk-prog-val
  (fn
    (src name)
    (hk-deep-force (get (hk-eval-program (hk-core src)) name))))
 (define hk-as-list
  (fn (xs)
    (cond
      ((and (list? xs) (= (first xs) "[]")) (list))
      ((and (list? xs) (= (first xs) ":"))
        (cons (nth xs 1) (hk-as-list (nth xs 2))))
      (:else xs))))
 (define
  hk-eval-list
  (fn (src) (hk-as-list (hk-eval-expr-source src))))
 ;; ── seq returns its second arg ──
 (hk-test
  "seq with primitive first arg"
  (hk-eval-expr-source "seq 1 99")
  99)
 (hk-test
  "seq forces first arg via let"
  (hk-eval-expr-source "let x = 1 + 2 in seq x x")
  3)
 (hk-test
  "seq second arg is whatever shape"
  (hk-eval-expr-source "seq 0 \"hello\"")
  "hello")
 ;; ── seq enables previously-lazy bottom to be forced ──
 ;; Without seq the let-binding `x = error …` is never forced;
 ;; with seq it must be forced because seq is strict in its first
 ;; argument. We don't run that error case here (it would terminate
 ;; the test), but we do verify the negative — that without seq,
 ;; the bottom bound is never demanded.
 (hk-test
  "lazy let — bottom never forced when unused"
  (hk-eval-expr-source "let x = error \"never\" in 42")
  42)
 ;; ── deepseq forces nested structure ──
 (hk-test
  "deepseq with finite list"
  (hk-eval-expr-source "deepseq [1, 2, 3] 7")
  7)
 (hk-test
  "deepseq with constructor value"
  (hk-eval-expr-source "deepseq (Just 5) 11")
  11)
 (hk-test
  "deepseq with tuple"
  (hk-eval-expr-source "deepseq (1, 2) 13")
  13)
 ;; ── seq + arithmetic ──
 (hk-test
  "seq used inside arithmetic doesn't poison the result"
  (hk-eval-expr-source "(seq 1 5) + (seq 2 7)")
  12)
 ;; ── seq in user code ──
 (hk-test
  "seq via fun-clause"
  (hk-prog-val
    "f x = seq x (x + 1)\nresult = f 10"
    "result")
  11)
 (hk-test
  "seq sequences list construction"
  (hk-eval-list "[seq 1 10, seq 2 20]")
  (list 10 20))
 {:fails hk-test-fails :pass hk-test-pass :fail hk-test-fail}
--- a/lib/prolog/compiler.sx
+++ b/lib/prolog/compiler.sx
@@ -0,0 +1,176 @@
 ;; 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)))))))
--- a/lib/prolog/conformance.sh
+++ b/lib/prolog/conformance.sh
@@ -0,0 +1,126 @@
 #!/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."
--- a/lib/prolog/parser.sx
+++ b/lib/prolog/parser.sx
@@ -1,28 +1,20 @@
 ;; lib/prolog/parser.sx — tokens → Prolog AST
 ;;
-;; Phase 1 grammar (NO operator table yet):
+;; Phase 4 grammar (with operator table):
 ;;   Program      := Clause* EOF
-;;   Clause       := Term "." | Term ":-" Term "."
+;;   Clause       := Term[999] "." | Term[999] ":-" Term[1200] "."
-;;   Term         := Atom | Var | Number | String | Compound | List
+;;   Term[Pmax] uses precedence climbing on the operator table:
-;;   Compound     := atom "(" ArgList ")"
+;;     primary = Atom | Var | Number | String | Compound | List | "(" Term[1200] ")"
-;;   ArgList      := Term ("," Term)*
+;;     while next token is infix op `op` with prec(op) ≤ Pmax:
-;;   List         := "[" "]" | "[" Term ("," Term)* ("|" Term)? "]"
+;;       consume op; parse rhs at right-prec(op); fold into compound(op-name,[lhs,rhs])
 ;;
-;; Term AST shapes (all tagged lists for uniform dispatch):
+;; Op type → right-prec for op at precedence P:
-;;   ("atom"  name)            — atom
+;;   xfx → P-1   strict-both
-;;   ("var"   name)            — variable template (parser-time only)
+;;   xfy → P     right-associative
-;;   ("num"   value)           — integer or float
+;;   yfx → P-1   left-associative
 ;;   ("str"   value)           — string literal
 ;;   ("compound" functor args) — compound term, args is list of term-ASTs
 ;;   ("cut")                   — the cut atom !
 ;;
-;; A clause is (list "clause" head body). A fact is head with body = ("atom" "true").
+;; AST shapes are unchanged — operators just become compound terms.
 ;;
 ;; 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
@@ -66,7 +58,6 @@
            (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)))
@@ -74,18 +65,14 @@
 (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
@@ -95,9 +82,61 @@
      tail
      (pl-mk-cons (first items) (pl-mk-list-term (rest items) tail)))))
-;; ── Term parser ─────────────────────────────────────────────────────
+;; ── Operator table (Phase 4) ──────────────────────────────────────
 ;; Each entry: (name precedence type). Type ∈ "xfx" "xfy" "yfx".
 (define
-  pp-parse-term
+  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
  (fn
    (st)
    (let
@@ -111,6 +150,12 @@
          ((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)
@@ -133,13 +178,51 @@
                (if (= vv nil) "" vv)
                "'"))))))))
-;; Parse one or more comma-separated terms (arguments).
+;; Operator-aware term parser: precedence climbing.
 (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 st)) (args (list)))
+      ((first-arg (pp-parse-term-prec st 999)) (args (list)))
      (do
        (append! args first-arg)
        (define
@@ -150,12 +233,12 @@
              (pp-at? st "punct" ",")
              (do
                (pp-advance! st)
-                (append! args (pp-parse-term st))
+                (append! args (pp-parse-term-prec st 999))
                (loop)))))
        (loop)
        args))))
-;; Parse a [ ... ] list literal. Consumes the "[".
+;; List literal.
 (define
  pp-parse-list
  (fn
@@ -168,7 +251,7 @@
        (let
          ((items (list)))
          (do
-            (append! items (pp-parse-term st))
+            (append! items (pp-parse-term-prec st 999))
            (define
              comma-loop
              (fn
@@ -177,52 +260,17 @@
                  (pp-at? st "punct" ",")
                  (do
                    (pp-advance! st)
-                    (append! items (pp-parse-term st))
+                    (append! items (pp-parse-term-prec st 999))
                    (comma-loop)))))
            (comma-loop)
            (let
-              ((tail (if (pp-at? st "punct" "|") (do (pp-advance! st) (pp-parse-term st)) (pl-nil-term))))
+              ((tail (if (pp-at? st "punct" "|") (do (pp-advance! st) (pp-parse-term-prec st 999)) (pl-nil-term))))
              (do (pp-expect! st "punct" "]") (pl-mk-list-term items tail)))))))))
 ;; ── Body parsing ────────────────────────────────────────────────────
-;; A clause body is a comma-separated list of goals. We flatten into a
+;; A body is a single term parsed at prec 1200 — operator parser folds
-;; right-associative `,` compound: (A, B, C) → ','(A, ','(B, C))
+;; `,`, `;`, `->` automatically into right-associative compounds.
-;; If only one goal, it's that goal directly.
+(define pp-parse-body (fn (st) (pp-parse-term-prec st 1200)))
 (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
@@ -230,12 +278,11 @@
  (fn
    (st)
    (let
-      ((head (pp-parse-term st)))
+      ((head (pp-parse-term-prec st 999)))
      (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
@@ -253,13 +300,9 @@
        (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))))
--- a/lib/prolog/query.sx
+++ b/lib/prolog/query.sx
@@ -0,0 +1,114 @@
 ;; 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)))
--- a/lib/prolog/runtime.sx
+++ b/lib/prolog/runtime.sx
--- a/lib/prolog/scoreboard.json
+++ b/lib/prolog/scoreboard.json
@@ -0,0 +1,7 @@
 {
  "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"
 }
--- a/lib/prolog/scoreboard.md
+++ b/lib/prolog/scoreboard.md
@@ -0,0 +1,35 @@
 # 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 …`.
--- a/lib/prolog/tests/advanced.sx
+++ b/lib/prolog/tests/advanced.sx
@@ -0,0 +1,254 @@
 ;; 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}))
--- a/lib/prolog/tests/assert_rules.sx
+++ b/lib/prolog/tests/assert_rules.sx
@@ -0,0 +1,215 @@
 ;; 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}))
--- a/lib/prolog/tests/atoms.sx
+++ b/lib/prolog/tests/atoms.sx
@@ -0,0 +1,305 @@
 ;; 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}))
--- a/lib/prolog/tests/char_predicates.sx
+++ b/lib/prolog/tests/char_predicates.sx
@@ -0,0 +1,290 @@
 ;; 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}))
--- a/lib/prolog/tests/clausedb.sx
+++ b/lib/prolog/tests/clausedb.sx
@@ -0,0 +1,99 @@
 ;; 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}))
--- a/lib/prolog/tests/compiler.sx
+++ b/lib/prolog/tests/compiler.sx
@@ -0,0 +1,185 @@
 ;; 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}))
--- a/lib/prolog/tests/cross_validate.sx
+++ b/lib/prolog/tests/cross_validate.sx
@@ -0,0 +1,86 @@
 ;; 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}))
--- a/lib/prolog/tests/dynamic.sx
+++ b/lib/prolog/tests/dynamic.sx
@@ -0,0 +1,158 @@
 ;; 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}))
--- a/lib/prolog/tests/findall.sx
+++ b/lib/prolog/tests/findall.sx
@@ -0,0 +1,167 @@
 ;; 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}))
--- a/lib/prolog/tests/io_predicates.sx
+++ b/lib/prolog/tests/io_predicates.sx
@@ -0,0 +1,326 @@
 ;; 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}))
--- a/lib/prolog/tests/iso_predicates.sx
+++ b/lib/prolog/tests/iso_predicates.sx
@@ -0,0 +1,320 @@
 ;; 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}))
--- a/lib/prolog/tests/list_predicates.sx
+++ b/lib/prolog/tests/list_predicates.sx
@@ -0,0 +1,335 @@
 ;; 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}))
--- a/lib/prolog/tests/meta_call.sx
+++ b/lib/prolog/tests/meta_call.sx
@@ -0,0 +1,197 @@
 ;; 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}))
--- a/lib/prolog/tests/meta_predicates.sx
+++ b/lib/prolog/tests/meta_predicates.sx
@@ -0,0 +1,252 @@
 ;; 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}))
--- a/lib/prolog/tests/operators.sx
+++ b/lib/prolog/tests/operators.sx
@@ -0,0 +1,193 @@
 ;; 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}))
--- a/lib/prolog/tests/programs/append.pl
+++ b/lib/prolog/tests/programs/append.pl
@@ -0,0 +1,5 @@
 %% 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).
--- a/lib/prolog/tests/programs/append.sx
+++ b/lib/prolog/tests/programs/append.sx
@@ -0,0 +1,114 @@
 ;; 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}))
--- a/lib/prolog/tests/programs/family.pl
+++ b/lib/prolog/tests/programs/family.pl
@@ -0,0 +1,24 @@
 %% 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).
--- a/lib/prolog/tests/programs/family.sx
+++ b/lib/prolog/tests/programs/family.sx
@@ -0,0 +1,116 @@
 ;; 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}))
--- a/lib/prolog/tests/programs/member.pl
+++ b/lib/prolog/tests/programs/member.pl
@@ -0,0 +1,4 @@
 %% member/2 — list membership.
 %% Generates all solutions on backtracking when the element is unbound.
 member(X, [X|_]).
 member(X, [_|T]) :- member(X, T).
--- a/lib/prolog/tests/programs/member.sx
+++ b/lib/prolog/tests/programs/member.sx
@@ -0,0 +1,91 @@
 ;; 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}))
--- a/lib/prolog/tests/programs/nqueens.pl
+++ b/lib/prolog/tests/programs/nqueens.pl
@@ -0,0 +1,27 @@
 %% 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).
--- a/lib/prolog/tests/programs/nqueens.sx
+++ b/lib/prolog/tests/programs/nqueens.sx
@@ -0,0 +1,108 @@
 ;; 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}))
--- a/lib/prolog/tests/programs/reverse.pl
+++ b/lib/prolog/tests/programs/reverse.pl
@@ -0,0 +1,7 @@
 %% 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).
--- a/lib/prolog/tests/programs/reverse.sx
+++ b/lib/prolog/tests/programs/reverse.sx
@@ -0,0 +1,113 @@
 ;; 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}))
--- a/lib/prolog/tests/query_api.sx
+++ b/lib/prolog/tests/query_api.sx
@@ -0,0 +1,127 @@
 ;; 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}))
--- a/lib/prolog/tests/set_predicates.sx
+++ b/lib/prolog/tests/set_predicates.sx
@@ -0,0 +1,195 @@
 ;; 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}))
--- a/lib/prolog/tests/solve.sx
+++ b/lib/prolog/tests/solve.sx
@@ -0,0 +1,618 @@
 ;; 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}))
--- a/lib/prolog/tests/string_agg.sx
+++ b/lib/prolog/tests/string_agg.sx
@@ -0,0 +1,273 @@
 ;; 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}))
--- a/lib/prolog/tests/term_inspect.sx
+++ b/lib/prolog/tests/term_inspect.sx
@@ -0,0 +1,147 @@
 ;; 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}))
--- a/plans/haskell-on-sx.md
+++ b/plans/haskell-on-sx.md
@@ -55,40 +55,33 @@ Key mappings:
 ### Phase 1 — tokenizer + parser + layout rule
 - [x] Tokenizer: reserved words, qualified names, operators, numbers (int, float, Rational later), chars/strings, comments (`--` and `{-` nested)
- [x] Layout algorithm: turn indentation into virtual `{`, `;`, `}` tokens per Haskell 98 §10.3
+- [ ] Layout algorithm: turn indentation into virtual `{`, `;`, `}` tokens per Haskell 98 §10.3
- Parser (split into sub-items — implement one per iteration):
+- [ ] Parser: modules, imports (stub), top-level decls, type sigs, function clauses with patterns + guards + where-clauses, expressions with operator precedence, lambdas, `let`, `if`, `case`, `do`, list comp, sections
-  - [x] Expressions: atoms, parens, tuples, lists, ranges, application, infix with full Haskell-98 precedence table, unary `-`, backtick operators, lambdas, `if`, `let`
+- [ ] AST design modelled on GHC's HsSyn at a surface level
  - [x] `case … of` and `do`-notation expressions (plus minimal patterns needed for arms/binds: var, wildcard, literal, 0-arity and applied constructor, tuple, list)
  - [x] Patterns — full: `as` patterns, nested, negative literal, `~` lazy, infix constructor (`:` / consym), extend lambdas/let with non-var patterns
  - [x] Top-level decls: function clauses (simple — no guards/where yet), pattern bindings, multi-name type signatures, `data` with type vars and recursive constructors, `type` synonyms, `newtype`, fixity (`infix`/`infixl`/`infixr` with optional precedence, comma-separated ops, backtick names). Types: vars / constructors / application / `->` (right-assoc) / tuples / lists. `hk-parse-top` entry.
  - [x] `where` clauses + guards (on fun-clauses, case alts, and let/do-let bindings — with the let funclause shorthand `let f x = …` now supported)
  - [x] Module header + imports — `module NAME [exports] where …`, qualified/as/hiding/explicit imports, operator exports, `module Foo` exports, dotted names, headerless-with-imports
  - [x] List comprehensions + operator sections — `(op)` / `(op e)` / `(e op)` (excluding `-` from right sections), `[e | q1, q2, …]` with `q-gen` / `q-guard` / `q-let` qualifiers
 - [x] AST design modelled on GHC's HsSyn at a surface level — keyword-tagged lists cover modules/imports/decls/types/patterns/expressions; see parser.sx docstrings for the full node catalogue
 - [x] Unit tests in `lib/haskell/tests/parse.sx` (43 tokenizer tests, all green)
 ### Phase 2 — desugar + eager-ish eval + ADTs (untyped)
- [x] Desugar: guards → nested `if`s; `where` → `let`; list comp → `concatMap`-based; do-notation stays for now (desugared in phase 3)
+- [ ] Desugar: guards → nested `if`s; `where` → `let`; list comp → `concatMap`-based; do-notation stays for now (desugared in phase 3)
- [x] `data` declarations register constructors in runtime
+- [ ] `data` declarations register constructors in runtime
- [x] Pattern match (tag-based, value-level): atoms, vars, wildcards, constructor patterns, `as` patterns, nested
+- [ ] Pattern match (tag-based, value-level): atoms, vars, wildcards, constructor patterns, `as` patterns, nested
- [x] Evaluator (still strict internally — laziness in phase 3): `let`, `lambda`, application, `case`, literals, constructors
+- [ ] Evaluator (still strict internally — laziness in phase 3): `let`, `lambda`, application, `case`, literals, constructors
- [x] 30+ eval tests in `lib/haskell/tests/eval.sx`
+- [ ] 30+ eval tests in `lib/haskell/tests/eval.sx`
 ### Phase 3 — laziness + classic programs
- [x] Transpile to thunk-wrapped SX: every application arg becomes `(make-thunk (lambda () <arg>))`
+- [ ] Transpile to thunk-wrapped SX: every application arg becomes `(make-thunk (lambda () <arg>))`
- [x] `force` = SX eval-thunk-to-WHNF primitive
+- [ ] `force` = SX eval-thunk-to-WHNF primitive
- [x] Pattern match forces scrutinee before matching
+- [ ] Pattern match forces scrutinee before matching
- [x] Infinite structures: `repeat x`, `iterate f x`, `[1..]`, Fibonacci stream (sieve deferred — needs lazy `++` and is exercised under `Classic programs`)
+- [ ] Infinite structures: `repeat x`, `iterate f x`, `[1..]`, Fibonacci stream, sieve of Eratosthenes
- [x] `seq`, `deepseq` from Prelude
+- [ ] `seq`, `deepseq` from Prelude
- [x] Do-notation for a stub `IO` monad (just threading, no real side effects yet)
+- [ ] Do-notation for a stub `IO` monad (just threading, no real side effects yet)
- [x] Classic programs in `lib/haskell/tests/programs/`:
+- [ ] Classic programs in `lib/haskell/tests/programs/`:
-  - [x] `fib.hs` — infinite Fibonacci stream
+  - [ ] `fib.hs` — infinite Fibonacci stream
-  - [x] `sieve.hs` — lazy sieve of Eratosthenes
+  - [ ] `sieve.hs` — lazy sieve of Eratosthenes
-  - [x] `quicksort.hs` — naive QS
+  - [ ] `quicksort.hs` — naive QS
-  - [x] `nqueens.hs`
+  - [ ] `nqueens.hs`
-  - [x] `calculator.hs` — parser combinator style expression evaluator
+  - [ ] `calculator.hs` — parser combinator style expression evaluator
- [x] `lib/haskell/conformance.sh` + runner; `scoreboard.json` + `scoreboard.md`
+- [ ] `lib/haskell/conformance.sh` + runner; `scoreboard.json` + `scoreboard.md`
- [x] Target: 5/5 classic programs passing
+- [ ] Target: 5/5 classic programs passing
 ### Phase 4 — Hindley-Milner inference
 - [ ] Algorithm W: unification + type schemes + generalisation + instantiation
@@ -114,435 +107,6 @@ Key mappings:
 _Newest first._
 - **2026-04-25** — `conformance.sh` runner + `scoreboard.json` + `scoreboard.md`.
  Script runs each classic program's test suite, prints per-program pass/fail,
  and writes both files. `--check` mode skips writing for CI use.
  Initial snapshot: 16/16 tests, 5/5 programs passing. Phase 3 complete.
 - **2026-04-25** — Classic program `calculator.hs`: recursive descent
  expression evaluator using ADTs for tokens and results.
  `data Token = TNum Int | TOp String` + `data Result = R Int [Token]`;
  parser threads token lists through `R` constructors enabling nested
  constructor pattern matching (`R v (TOp "+":rest)`). Handles two-level
  operator precedence (* / tighter than + −) and left-associativity.
  5 tests: addition, precedence, left-assoc subtraction, left-assoc
  div+mul, single number. All 5 classic programs complete. 402/402 green.
 - **2026-04-25** — Classic program `nqueens.hs`: backtracking n-queens via list
  comprehension and multi-clause `where`. Three fixes needed: (1) `hk-eval-let`
  now delegates to `hk-bind-decls!` so multi-clause `where`/`let` bindings
  (e.g., `go 0 = [[]]; go k = [...]`) are grouped as multifuns; (2) added
  `concatMap`, `concat`, `abs`, `negate` to `hk-prelude-src` (list comprehensions
  desugar to `concatMap`); (3) cached the Prelude env in `hk-env0` so
  `hk-eval-expr-source` copies it instead of re-parsing. Tests: `queens 4 = 2`,
  `queens 5 = 10`. n=8 (92 solutions) is too slow at ~50s/n — omitted.
  397/397 green.
 - **2026-04-25** — Classic program `quicksort.hs`: naive functional quicksort.
  `qsort (x:xs) = qsort smaller ++ [x] ++ qsort larger where smaller = filter (< x) xs; larger = filter (>= x) xs`.
  No new runtime additions needed — right sections, `filter`, `++` all worked out of the box.
  5 tests (general sort, empty, singleton, already-sorted, reverse-sorted). 395/395 green.
 - **2026-04-25** — Classic program `sieve.hs`: lazy sieve of Eratosthenes.
  Added `mod`, `div`, `rem`, `quot` to `hk-binop` (and as first-class
  values in `hk-init-env`), enabling backtick operator use. The filter-based
  sieve `sieve (p:xs) = p : sieve (filter (\x -> x \`mod\` p /= 0) xs)` works
  with the existing lazy cons + Prelude `filter`. 2 new tests in
  `lib/haskell/tests/program-sieve.sx` (first 10 primes, 20th prime = 71).
  390/390 green.
 - **2026-04-25** — First classic program: `fib.hs`. Canonical Haskell
  source lives at `lib/haskell/tests/programs/fib.hs` (the
  two-cons-cell self-referential fibs definition plus a hand-rolled
  `zipPlus`). The runner at `lib/haskell/tests/program-fib.sx`
  mirrors the source as an SX string (the OCaml server's
  `read-file` lives in the page-helpers env, not the default load
  env, so direct file reads from inside `eval` aren't available).
  Tests: `take 15 myFibs == [0,1,1,2,3,5,8,13,21,34,55,89,144,233,377]`,
  plus a spot-check that the user-defined `zipPlus` is also
  reachable. Found and fixed an ordering bug in `hk-bind-decls!`:
  pass 3 (0-arity body evaluation) iterated `(keys groups)` whose
  order is implementation-defined, so a top-down program where
  `result = take 15 myFibs` came after `myFibs = …` could see
  `myFibs` still bound to its `nil` placeholder. Now group names
  are tracked in source order via a parallel list and pass 3 walks
  that. 388/388 green.
 - **2026-04-25** — Phase 3 do-notation + stub IO monad. Added a
  `hk-desugar-do` pass that follows Haskell 98 §3.14 verbatim:
  `do { e } = e`, `do { e ; ss } = e >> do { ss }`,
  `do { p <- e ; ss } = e >>= \p -> do { ss }`, and
  `do { let ds ; ss } = let ds in do { ss }`. The desugarer's
  `:do` branch now invokes this pass directly so the surface
  AST forms (`:do-expr`, `:do-bind`, `:do-let`) never reach the
  evaluator. IO is represented as a tagged value
  `("IO" payload)` — `return` (lazy builtin) wraps; `>>=` (lazy
  builtin) forces the action, unwraps, and calls the bound
  function on the payload; `>>` (lazy builtin) forces the
  action and returns the second one. All three are non-strict
  in their action arguments so deeply nested do-blocks don't
  walk the whole chain at construction time. 14 new tests in
  `lib/haskell/tests/do-io.sx` cover single-stmt do, single
  and multi-bind, `>>` sequencing (last action wins), do-let
  (single, multi, interleaved with bind), bind-to-`Just`,
  bind-to-tuple, do inside a top-level fun, nested do, and
  using `(>>=)`/`(>>)` directly as functions. 382/382 green.
 - **2026-04-25** — Phase 3 `seq` + `deepseq`. Built-ins were strict
  in all args by default (every collected thunk forced before
  invoking the underlying SX fn) — that defeats `seq`'s purpose,
  which is strict in its first argument and lazy in its second.
  Added a tiny `lazy` flag on the builtin record (set by a new
  `hk-mk-lazy-builtin` constructor) and routed `hk-apply-builtin`
  to skip the auto-force when the flag is true. `seq a b` calls
  `hk-force a` then returns `b` unchanged so its laziness is
  preserved; `deepseq` does the same with `hk-deep-force`. 9 new
  tests in `lib/haskell/tests/seq.sx` cover primitive, computed,
  and let-bound first args, deepseq on a list / `Just` /
  tuple, seq inside arithmetic, seq via a fun-clause, and
  `[seq 1 10, seq 2 20]` to confirm seq composes inside list
  literals. The lazy-when-unused negative case is also tested:
  `let x = error "never" in 42 == 42`. 368/368 green.
 - **2026-04-24** — Phase 3 infinite structures + Prelude. Two
  evaluator changes turn the lazy primitives into a working
  language:
  1. Op-form `:` is now non-strict in both args — `hk-eval-op`
     special-cases it before the eager force-and-binop path, so a
     cons-cell holds two thunks. This is what makes `repeat x =
     x : repeat x`, `iterate f x = x : iterate f (f x)`, and the
     classic `fibs = 0 : 1 : zipWith plus fibs (tail fibs)`
     terminate when only a finite prefix is consumed.
  2. Operators are now first-class values via a small
     `hk-make-binop-builtin` helper, so `(+)`, `(*)`, `(==)` etc.
     can be passed to `zipWith` and `map`.
  Added range support across parser + evaluator: `[from..to]` and
  `[from,next..to]` evaluate eagerly via `hk-build-range` (handles
  step direction); `[from..]` parses to a new `:range-from` node
  that the evaluator desugars to `iterate (+ 1) from`. New
  `hk-load-into!` runs the regular pipeline (parse → desugar →
  register data → bind decls) on a source string, and `hk-init-env`
  preloads `hk-prelude-src` with the Phase-3 Prelude:
  `head`, `tail`, `fst`, `snd`, `take`, `drop`, `repeat`, `iterate`,
  `length`, `map`, `filter`, `zipWith`, plus `fibs` and `plus`.
  25 new tests in `lib/haskell/tests/infinite.sx`, including
  `take 10 fibs == [0,1,1,2,3,5,8,13,21,34]`,
  `head (drop 99 [1..])`, `iterate (\x -> x * 2) 1` powers of two,
  user-defined `ones = 1 : ones`, `naturalsFrom`, range edge cases,
  composed `map`/`filter`, and a custom `mySum`. 359/359 green.
  Sieve of Eratosthenes is deferred — it needs lazy `++` plus a
  `mod` primitive — and lives under `Classic programs` anyway.
 - **2026-04-24** — Phase 3 laziness foundation. Added a thunk type to
  `lib/haskell/eval.sx` (`hk-mk-thunk` / `hk-is-thunk?`) backed by a
  one-shot memoizing `hk-force` that evaluates the deferred AST, then
  flips a `forced` flag and caches the value on the thunk dict; the
  shared `hk-deep-force` walks the result tree at the test/output
  boundary. Three single-line wiring changes in the evaluator make
  every application argument lazy: `:app` now wraps its argument in
  `hk-mk-thunk` rather than evaluating it. To preserve correctness
  where values must be inspected, `hk-apply`, `hk-eval-op`,
  `hk-eval-if`, `hk-eval-case`, and `hk-eval` for `:neg` now force
  their operand. `hk-apply-builtin` forces every collected arg
  before invoking the underlying SX fn so built-ins (`error`, `not`,
  `id`) stay strict. The pattern matcher in `match.sx` now forces
  the scrutinee just-in-time only for patterns that need to inspect
  shape — `p-wild`, `p-var`, `p-as`, and `p-lazy` are no-force
  paths, so the value flows through as a thunk and binding
  preserves laziness. `hk-match-list-pat` forces at every cons-spine
  step. 6 new lazy-specific tests in `lib/haskell/tests/eval.sx`
  verify that `(\x y -> x) 1 (error …)` and `(\x y -> y) (error …) 99`
  return without diverging, that `case Just (error …) of Just _ -> 7`
  short-circuits, that `const` drops its second arg, that
  `myHead (1 : error … : [])` returns 1 without touching the tail,
  and that `Just (error …)` survives a wildcard-arm `case`. 333/333
  green, all prior eval tests preserved by deep-forcing the result
  in `hk-eval-expr-source` and `hk-prog-val`.
 - **2026-04-24** — Phase 2 evaluator (`lib/haskell/eval.sx`) — ties
  the whole pipeline together. Strict semantics throughout (laziness
  is Phase 3). Function values are tagged dicts: `closure`,
  `multi`(fun), `con-partial`, `builtin`. `hk-apply` unifies dispatch
  across all four; closures and multifuns curry one argument at a
  time, multifuns trying each clause's pat-list in order once arity
  is reached. Top-level `hk-bind-decls!` is three-pass —
  collect groups + pre-seed names → install multifuns (so closures
  observe later names) → eval 0-arity bodies and pat-binds — making
  forward and mutually recursive references work. `hk-eval-let` does
  the same trick with a mutable child env. Built-ins:
  `error`/`not`/`id`, plus `otherwise = True`. Operators wired:
  arithmetic, comparison (returning Bool conses), `&&`, `||`, `:`,
  `++`. Sections evaluate the captured operand once and return a
  closure synthesized via the existing AST. `hk-eval-program`
  registers data decls then binds, returning the env; `hk-run`
  fetches `main` if present. Also extended `runtime.sx` to
  pre-register the standard Prelude conses (`Maybe`, `Either`,
  `Ordering`) so expression-level eval doesn't need a leading
  `data` decl. 48 new tests in `lib/haskell/tests/eval.sx` cover
  literals, arithmetic precedence, comparison/Bool, `if`, `let`
  (incl. recursive factorial), lambdas (incl. constructor pattern
  args), constructors, `case` (Just/Nothing/literal/tuple/wildcard),
  list literals + cons + `++`, tuples, sections, multi-clause
  top-level (factorial, list length via cons pattern, Maybe handler
  with default), user-defined `data` with case-style matching, a
  binary-tree height program, currying, higher-order (`twice`),
  short-circuit `error` via `if`, and the three built-ins. 329/329
  green. Phase 2 is now complete; Phase 3 (laziness) is next.
 - **2026-04-24** — Phase 2: value-level pattern matcher
  (`lib/haskell/match.sx`). Core entry `hk-match pat val env` returns
  an extended env dict on success or `nil` on failure (uses `assoc`
  rather than `dict-set!` so failed branches never pollute the
  caller's env). Constructor values are tagged lists with the
  constructor name as the first element; tuples use the tag `"Tuple"`,
  lists are chained `(":" h t)` cons cells terminated by `("[]")`.
  Value builders `hk-mk-con` / `hk-mk-tuple` / `hk-mk-nil` /
  `hk-mk-cons` / `hk-mk-list` keep tests readable. The matcher
  handles every pattern node the parser emits:
  - `:p-wild` (always matches), `:p-var` (binds), `:p-int` /
    `:p-float` / `:p-string` / `:p-char` (literal equality)
  - `:p-as` (sub-match then bind whole), `:p-lazy` (eager for now;
    laziness wired in phase 3)
  - `:p-con` with arity check + recursive arg matching, including
    deeply nested patterns and infix `:` cons (uses the same
    code path as named constructors)
  - `:p-tuple` against `"Tuple"` values, `:p-list` against an
    exact-length cons spine.
  Helper `hk-parse-pat-source` lifts a real Haskell pattern out of
  `case _ of <pat> -> 0`, letting tests drive against parser output.
  31 new tests in `lib/haskell/tests/match.sx` cover atomic
  patterns, success/failure for each con/tuple/list shape, nested
  `Just (Just x)`, cons-vs-empty, `as` over con / wildcard /
  failing-sub, `~` lazy, plus four parser-driven cases (`Just x`,
  `x : xs`, `(a, b)`, `n@(Just x)`). 281/281 green.
 - **2026-04-24** — Phase 2: runtime constructor registry
  (`lib/haskell/runtime.sx`). A mutable dict `hk-constructors` keyed
  by constructor name, each entry carrying arity and owning type.
  `hk-register-data!` walks a `:data` AST and registers every
  `:con-def` with its arity (= number of field types) and the type
  name; `hk-register-newtype!` does the one-constructor variant;
  `hk-register-decls!` / `hk-register-program!` filter a decls list
  (or a `:program` / `:module` AST) and call the appropriate
  registrar. `hk-load-source!` composes it with `hk-core`
  (tokenize → layout → parse → desugar → register). Pre-registers
  five built-ins tied to Haskell syntactic forms: `True` / `False`
  (Bool), `[]` and `:` (List), `()` (Unit) — everything else comes
  from user declarations or the eventual Prelude. Query helpers:
  `hk-is-con?`, `hk-con-arity`, `hk-con-type`, `hk-con-names`. 24
  new tests in `lib/haskell/tests/runtime.sx` cover each built-in
  (arity + type), unknown-name probes, registration of `MyBool` /
  `Maybe` / `Either` / recursive `Tree` / `newtype Age`, multi-data
  programs, a module-header body, ignoring non-data decls, and
  last-wins re-registration. 250/250 green.
 - **2026-04-24** — Phase 2 kicks off with `lib/haskell/desugar.sx` — a
  tree-walking rewriter that eliminates the three surface-only forms
  produced by the parser, leaving a smaller core AST for the evaluator:
  - `:where BODY DECLS` → `:let DECLS BODY`
  - `:guarded ((:guard C1 E1) (:guard C2 E2) …)` → right-folded
    `(:if C1 E1 (:if C2 E2 … (:app (:var "error") (:string "…"))))`
  - `:list-comp E QUALS` → Haskell 98 §3.11 translation:
    empty quals → `(:list (E))`, `:q-guard` → `(:if … (:list (E)) (:list ()))`,
    `:q-gen PAT SRC` → `(concatMap (\PAT -> …) SRC)`, `:q-let BINDS` →
    `(:let BINDS …)`. Nested generators compile to nested concatMap.
  Every other expression, decl, pattern, and type node is recursed
  into and passed through unchanged. Public entries `hk-desugar`,
  `hk-core` (tokenize → layout → parse → desugar on a module), and
  `hk-core-expr` (the same for an expression). 15 new tests in
  `lib/haskell/tests/desugar.sx` cover two- and three-way guards,
  case-alt guards, single/multi-binding `where`, guards + `where`
  combined, the four list-comprehension cases (single-gen, gen +
  filter, gen + let, nested gens), and pass-through for literals,
  lambdas, simple fun-clauses, `data` decls, and a module header
  wrapping a guarded function. 226/226 green.
 - **2026-04-24** — Phase 1 parser is now complete. This iteration adds
  operator sections and list comprehensions, the two remaining
  aexp-level forms, plus ticks the “AST design” item (the keyword-
  tagged list shape has accumulated a full HsSyn-level surface).
  Changes:
  - `hk-parse-infix` now bails on `op )` without consuming the op, so
    the paren parser can claim it as a left section.
  - `hk-parse-parens` rewritten to recognise five new forms:
    `()` (unit), `(op)` → `(:var OP)`, `(op e)` → `(:sect-right OP E)`
    (excluded for `-` so that `(- 5)` stays `(:neg 5)`), `(e op)` →
    `(:sect-left OP E)`, plus regular parens and tuples. Works for
    varsym, consym, reservedop `:`, and backtick-quoted varids.
  - `hk-section-op-info` inspects the current token and returns a
    `{:name :len}` dict, so the same logic handles 1-token ops and
    3-token backtick ops uniformly.
  - `hk-parse-list-lit` now recognises a `|` after the first element
    and dispatches to `hk-parse-qual` per qualifier (comma-separated),
    producing `(:list-comp EXPR QUALS)`. Qualifiers are:
    `(:q-gen PAT EXPR)` when a paren-balanced lookahead
    (`hk-comp-qual-is-gen?`) finds `<-` before the next `,`/`]`,
    `(:q-let BINDS)` for `let …`, and `(:q-guard EXPR)` otherwise.
  - `hk-parse-comp-let` accepts `]` or `,` as an implicit block close
    (single-line comprehensions never see layout's vrbrace before the
    qualifier terminator arrives); explicit `{ }` still closes
    strictly.
  22 new tests in `lib/haskell/tests/parser-sect-comp.sx` cover
  op-references (inc. `(-)`, `(:)`, backtick), right sections (inc.
  backtick), left sections, the `(- 5)` → `:neg` corner, plain parens
  and tuples, six comprehension shapes (simple, filter, let,
  nested-generators, constructor pattern bind, tuple pattern bind,
  and a three-qualifier mix). 211/211 green.
 - **2026-04-24** — Phase 1: module header + imports. Added
  `hk-parse-module-header`, `hk-parse-import`, plus shared helpers for
  import/export entity lists (`hk-parse-ent`, `hk-parse-ent-member`,
  `hk-parse-ent-list`). New AST:
  - `(:module NAME EXPORTS IMPORTS DECLS)` — NAME `nil` means no header,
    EXPORTS `nil` means no export list (distinct from empty `()`)
  - `(:import QUALIFIED NAME AS SPEC)` — QUALIFIED bool, AS alias or nil,
    SPEC nil / `(:spec-items ENTS)` / `(:spec-hiding ENTS)`
  - Entity refs: `:ent-var`, `:ent-all` (`Tycon(..)`), `:ent-with`
    (`Tycon(m1, m2, …)`), `:ent-module` (exports only).
  `hk-parse-program` now dispatches on the leading token: `module`
  keyword → full header-plus-body parse (consuming the `where` layout
  brace around the module body); otherwise collect any leading
  `import` decls and then remaining decls with the existing logic.
  The outer shell is `(:module …)` as soon as any header or import is
  present, and stays as `(:program DECLS)` otherwise — preserving every
  previous test expectation untouched. Handles operator exports `((+:))`,
  dotted module names (`Data.Map`), and the Haskell-98 context-sensitive
  keywords `qualified`/`as`/`hiding` (all lexed as ordinary varids and
  matched only in import position). 16 new tests in
  `lib/haskell/tests/parser-module.sx` covering simple/exports/empty
  headers, dotted names, operator exports, `module Foo` exports,
  qualified/aliased/items/hiding imports, and a headerless-with-imports
  file. 189/189 green.
 - **2026-04-24** — Phase 1: guards + where clauses. Factored a single
  `hk-parse-rhs sep` that all body-producing sites now share: it reads
  a plain `sep expr` body or a chain of `| cond sep expr` guards, then
  — regardless of which form — looks for an optional `where` block and
  wraps accordingly. AST additions:
  - `:guarded GUARDS` where each GUARD is `:guard COND EXPR`
  - `:where BODY DECLS` where BODY is a plain expr or a `:guarded`
  Both can nest (guards inside where). `hk-parse-alt` now routes through
  `hk-parse-rhs "->"`, `hk-parse-fun-clause` and `hk-parse-bind` through
  `hk-parse-rhs "="`. `hk-parse-where-decls` reuses `hk-parse-decl` so
  where-blocks accept any decl form (signatures, fixity, nested funs).
  As a side effect, `hk-parse-bind` now also picks up the Haskell-native
  `let f x = …` funclause shorthand: a varid followed by one or more
  apats produces `(:fun-clause NAME APATS BODY)` instead of a
  `(:bind (:p-var …) …)` — keeping the simple `let x = e` shape
  unchanged for existing tests. 11 new tests in
  `lib/haskell/tests/parser-guards-where.sx` cover two- and three-way
  guards, mixed guarded + equality clauses, single- and multi-binding
  where blocks, guards plus where, case-alt guards, case-alt where,
  let with funclause shorthand, let with guards, and a where containing
  a type signature alongside a fun-clause. 173/173 green.
 - **2026-04-24** — Phase 1: top-level decls. Refactored `hk-parse-expr` into a
  `hk-parser tokens mode` with `:expr` / `:module` dispatch so the big lexical
  state is shared (peek/advance/pat/expr helpers all reachable); added public
  wrappers `hk-parse-expr`, `hk-parse-module`, and source-level entry
  `hk-parse-top`. New type parser (`hk-parse-type` / `hk-parse-btype` /
  `hk-parse-atype`): type variables (`:t-var`), type constructors (`:t-con`),
  type application (`:t-app`, left-assoc), right-associative function arrow
  (`:t-fun`), unit/tuples (`:t-tuple`), and lists (`:t-list`). New decl parser
  (`hk-parse-decl` / `hk-parse-program`) producing a `(:program DECLS)` shell:
  - `:type-sig NAMES TYPE` — comma-separated multi-name support
  - `:fun-clause NAME APATS BODY` — patterns for args, body via existing expr
  - `:pat-bind PAT BODY` — top-level pattern bindings like `(a, b) = pair`
  - `:data NAME TVARS CONS` with `:con-def CNAME FIELDS` for nullary and
    multi-arg constructors, including recursive references
  - `:type-syn NAME TVARS TYPE`, `:newtype NAME TVARS CNAME FIELD`
  - `:fixity ASSOC PREC OPS` — assoc one of `"l"`/`"r"`/`"n"`, default prec 9,
    comma-separated operator names, including backtick-quoted varids.
  Sig vs fun-clause disambiguated by a paren-balanced top-level scan for
  `::` before the next `;`/`}` (`hk-has-top-dcolon?`). 24 new tests in
  `lib/haskell/tests/parser-decls.sx` cover all decl forms, signatures with
  application / tuples / lists / right-assoc arrows, nullary and recursive
  data types, multi-clause functions, and a mixed program with data + type-
  synonym + signature + two function clauses. Not yet: guards, where
  clauses, module header, imports, deriving, contexts, GADTs. 162/162 green.
 - **2026-04-24** — Phase 1: full patterns. Added `as` patterns
  (`name@apat` → `(:p-as NAME PAT)`), lazy patterns (`~apat` →
  `(:p-lazy PAT)`), negative literal patterns (`-N` / `-F` resolving
  eagerly in the parser so downstream passes see a plain `(:p-int -1)`),
  and infix constructor patterns via a right-associative single-band
  layer on top of `hk-parse-pat-lhs` for any `consym` or reservedop `:`
  (so `x : xs` parses as `(:p-con ":" [x, xs])`, `a :+: b` likewise).
  Extended `hk-apat-start?` with `-` and `~` so the pattern-argument
  loops in lambdas and constructor applications pick these up.
  Lambdas now parse apat parameters instead of bare varids — so the
  `:lambda` AST is `(:lambda APATS BODY)` with apats as pattern nodes.
  `hk-parse-bind` became a plain `pat = expr` form, so `:bind` now has
  a pattern LHS throughout (simple `x = 1` → `(:bind (:p-var "x") …)`);
  this picks up `let (x, y) = pair in …` and `let Just x = m in x`
  automatically, and flows through `do`-notation lets. Eight existing
  tests updated to the pattern-flavoured AST. Also fixed a pragmatic
  layout issue that surfaced in multi-line `let`s: when a layout-indent
  would emit a spurious `;` just before an `in` token (because the
  let block had already been closed by dedent), `hk-peek-next-reserved`
  now lets the layout pass skip that indent and leave closing to the
  existing `in` handler. 18 new tests in
  `lib/haskell/tests/parser-patterns.sx` cover every pattern variant,
  lambda with mixed apats, let pattern-bindings (tuple / constructor /
  cons), and do-bind with a tuple pattern. 138/138 green.
 - **2026-04-24** — Phase 1: `case … of` and `do`-notation parsers. Added `hk-parse-case`
  / `hk-parse-alt`, `hk-parse-do` / `hk-parse-do-stmt` / `hk-parse-do-let`, plus the
  minimal pattern language needed to make arms and binds meaningful:
  `hk-parse-apat` (var, wildcard `_`, int/float/string/char literal, 0-arity
  conid/qconid, paren+tuple, list) and `hk-parse-pat` (conid applied to
  apats greedily). AST nodes: `:case SCRUT ALTS`, `:alt PAT BODY`, `:do STMTS`
  with stmts `:do-expr E` / `:do-bind PAT E` / `:do-let BINDS`, and pattern
  tags `:p-wild` / `:p-int` / `:p-float` / `:p-string` / `:p-char` / `:p-var`
  / `:p-con NAME ARGS` / `:p-tuple` / `:p-list`. `do`-stmts disambiguate
  `pat <- e` vs bare expression with a forward paren/bracket/brace-balanced
  scan for `<-` before the next `;`/`}` — no backtracking, no AST rewrite.
  `case` and `do` accept both implicit (`vlbrace`/`vsemi`/`vrbrace`) and
  explicit braces. Added to `hk-parse-lexp` so they participate fully in
  operator-precedence expressions. 19 new tests in
  `lib/haskell/tests/parser-case-do.sx` cover every pattern variant,
  explicit-brace `case`, expression scrutinees, do with bind/let/expr,
  multi-binding `let` in `do`, constructor patterns in binds, and
  `case`/`do` nested inside `let` and lambda. The full pattern item (as
  patterns, negative literals, `~` lazy, lambda/let pattern extension)
  remains a separate sub-item. 119/119 green.
 - **2026-04-24** — Phase 1: expression parser (`lib/haskell/parser.sx`, ~380 lines).
  Pratt-style precedence climbing against a Haskell-98-default op table (24
  operators across precedence 0–9, left/right/non assoc, default infixl 9 for
  anything unlisted). Supports literals (int/float/string/char), varid/conid
  (qualified variants folded into `:var` / `:con`), parens / unit / tuples,
  list literals, ranges `[a..b]` and `[a,b..c]`, left-associative application,
  unary `-`, backtick operators (`x \`mod\` 3`), lambdas, `if-then-else`, and
  `let … in` consuming both virtual and explicit braces. AST uses keyword
  tags (`:var`, `:op`, `:lambda`, `:let`, `:bind`, `:tuple`, `:range`,
  `:range-step`, `:app`, `:neg`, `:if`, `:list`, `:int`, `:float`, `:string`,
  `:char`, `:con`). The parser skips a leading `vlbrace` / `lbrace` so it can
  be called on full post-layout output, and uses a `raise`-based error channel
  with location-lite messages. 42 new tests in `lib/haskell/tests/parser-expr.sx`
  cover literals, identifiers, parens/tuple/unit, list + range, app associativity,
  operator precedence (mul over add, cons right-assoc, function-composition
  right-assoc, `$` lowest), backtick ops, unary `-`, lambda multi-param,
  `if` with infix condition, single- and multi-binding `let` (both implicit
  and explicit braces), plus a few mixed nestings. 100/100 green.
 - **2026-04-24** — Phase 1: layout algorithm (`lib/haskell/layout.sx`, ~260 lines)
  implementing Haskell 98 §10.3. Two-pass design: a pre-pass augments the raw
  token stream with explicit `layout-open` / `layout-indent` markers (suppressing
  `<n>` when `{n}` already applies, per note 3), then an L pass consumes the
  augmented stream against a stack of implicit/explicit layout contexts and
  emits `vlbrace` / `vsemi` / `vrbrace` tokens; newlines are dropped. Supports
  the initial module-level implicit open (skipped when the first token is
  `module` or `{`), the four layout keywords (`let`/`where`/`do`/`of`), explicit
  braces disabling layout, dedent closing nested implicit blocks while also
  emitting `vsemi` at the enclosing level, and the pragmatic single-line
  `let … in` rule (emit `}` when `in` meets an implicit let). 15 new tests
  in `lib/haskell/tests/layout.sx` cover module-start, do/let/where/case/of,
  explicit braces, multi-level dedent, line continuation, and EOF close-down.
  Shared test helpers moved to `lib/haskell/testlib.sx` so both test files
  can share one `hk-test`. `test.sh` preloads tokenizer + layout + testlib.
  58/58 green.
 - **2026-04-24** — Phase 1: Haskell 98 tokenizer (`lib/haskell/tokenizer.sx`, 490 lines)
  covering idents (lower/upper/qvarid/qconid), 23 reserved words, 11 reserved ops,
  varsym/consym operator chains, integer/hex/octal/float literals incl. exponent
--- a/plans/prolog-on-sx.md
+++ b/plans/prolog-on-sx.md
@@ -39,59 +39,91 @@ Representation choices (finalise in phase 1, document here):
 ## Roadmap
 ### Phase 1 — tokenizer + term parser (no operator table)
- [ ] Tokenizer: atoms (lowercase/quoted), variables (uppercase/`_`), numbers, strings, punct `( ) , . [ ] | ! :-`, comments (`%`, `/* */`)
+- [x] Tokenizer: atoms (lowercase/quoted), variables (uppercase/`_`), numbers, strings, punct `( ) , . [ ] | ! :-`, comments (`%`, `/* */`)
- [ ] Parser: clauses `head :- body.` and facts `head.`; terms `atom | Var | number | compound(args) | [list,sugar]`
+- [x] Parser: clauses `head :- body.` and facts `head.`; terms `atom | Var | number | compound(args) | [list,sugar]`
- [ ] **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] **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.
- [ ] Unit tests in `lib/prolog/tests/parse.sx`
+- [x] Unit tests in `lib/prolog/tests/parse.sx` — 25 pass
 ### Phase 2 — unification + trail
- [ ] `make-var`, `walk` (follow binding chain), `prolog-unify!` (terms + trail → bool), `trail-undo-to!`
+- [x] `make-var`, `walk` (follow binding chain), `prolog-unify!` (terms + trail → bool), `trail-undo-to!`
- [ ] Occurs-check off by default, exposed as flag
+- [x] Occurs-check off by default, exposed as flag
- [ ] 30+ unification tests in `lib/prolog/tests/unify.sx`: atoms, vars, compounds, lists, cyclic (no-occurs-check), mutual occurs
+- [x] 30+ unification tests in `lib/prolog/tests/unify.sx`: atoms, vars, compounds, lists, cyclic (no-occurs-check), mutual occurs — 47 pass
 ### Phase 3 — clause DB + DFS solver + cut + first classic programs
- [ ] Clause DB: `"functor/arity" → list-of-clauses`, loader inserts
+- [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`
- [ ] 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] 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.
- [ ] Cut (`!`): cut barrier at current choice-point frame; collapse all up to barrier
+- [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.
- [ ] Built-ins: `=/2`, `\\=/2`, `true/0`, `fail/0`, `!/0`, `,/2`, `;/2`, `->/2` inside `;`, `call/1`, `write/1`, `nl/0`
+- [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.
- [ ] Arithmetic `is/2` with `+ - * / mod abs`
+- [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.
- [ ] Classic programs in `lib/prolog/tests/programs/`:
+- [x] Classic programs in `lib/prolog/tests/programs/`:
-  - [ ] `append.pl` — list append (with backtracking)
+  - [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]).
-  - [ ] `reverse.pl` — naive reverse
+  - [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.
-  - [ ] `member.pl` — generate all solutions via backtracking
+  - [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.
-  - [ ] `nqueens.pl` — 8-queens
+  - [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.).
-  - [ ] `family.pl` — facts + rules (parent/ancestor)
+  - [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 + `\=`.
- [ ] `lib/prolog/conformance.sh` + runner, `scoreboard.json` + `scoreboard.md`
+- [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.
- [ ] Target: all 5 classic programs passing
+- [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.
 ### Phase 4 — operator table + more built-ins (next run)
- [ ] Operator table parsing (prefix/infix/postfix, precedence, assoc)
+- [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.
- [ ] `assert/1`, `asserta/1`, `assertz/1`, `retract/1`
+- [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`.
- [ ] `findall/3`, `bagof/3`, `setof/3`
+- [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`.
- [ ] `copy_term/2`, `functor/3`, `arg/3`, `=../2`
+- [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`.
- [ ] String/atom predicates
+- [x] String/atom predicates
 ### Phase 5 — Hyperscript integration
- [ ] `prolog-query` primitive callable from SX/Hyperscript
+- [x] `prolog-query` primitive callable from SX/Hyperscript
- [ ] Hyperscript DSL: `when allowed(user, :edit) then …`
+- [ ] Hyperscript DSL: `when allowed(user, :edit) then …` ← **blocked** (needs `lib/hyperscript/**`, out of scope)
 - [ ] Integration suite
 ### Phase 6 — ISO conformance
- [ ] Vendor Hirst's conformance tests
+- [x] Vendor Hirst's conformance tests
- [ ] Drive scoreboard to 200+
+- [x] Drive scoreboard to 200+
 ### Phase 7 — compiler (later, optional)
- [ ] Compile clauses to SX continuations for speed
+- [x] Compile clauses to SX continuations for speed
- [ ] Keep interpreter as the reference
+- [x] 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._
- _(none yet)_
+- **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.
Author	SHA1	Message	Date
giles	81f96df5fa	plans: tick keep-interpreter box, update progress log Some checks failed Test, Build, and Deploy / test-build-deploy (push) Failing after 11s Details	2026-04-25 18:32:52 +00:00
giles	1819156d1e	prolog: cross-validate compiler vs interpreter (+17) Some checks failed Test, Build, and Deploy / test-build-deploy (push) Has been cancelled Details	2026-04-25 18:32:36 +00:00
giles	8fd55d6aa0	plans: tick compiler box, update progress log Some checks failed Test, Build, and Deploy / test-build-deploy (push) Has been cancelled Details	2026-04-25 18:08:46 +00:00
giles	8a9c074141	prolog: compile clauses to SX closures (+17) Some checks failed Test, Build, and Deploy / test-build-deploy (push) Has been cancelled Details	2026-04-25 18:08:27 +00:00
giles	00db8b7763	Progress log: predsort+term_variables+arith, 517/517 Some checks failed Test, Build, and Deploy / test-build-deploy (push) Has been cancelled Details	2026-04-25 14:13:59 +00:00
giles	788ac9dd05	predsort/3, term_variables/2, arith: floor/ceiling/truncate/round/sign/sqrt/pow Some checks failed Test, Build, and Deploy / test-build-deploy (push) Has been cancelled Details - pl-eval-arith: add floor, ceiling, truncate, round, sqrt, sign, pow, integer, float, float_integer_part, float_fractional_part, **, ^ operators - pl-collect-vars: helper that extracts unbound variables from a term (left-to-right, deduplicated by var id) - term_variables/2: dispatches via pl-collect-vars, unifies second arg with var list - pl-predsort-insert!: inserts one element into a sorted list using a 3-arg comparator predicate; deduplicates elements where comparator returns '=' - pl-predsort-build!: builds sorted list via fold over pl-predsort-insert! - predsort/3: full ISO predsort — sorts and deduplicates a list using a caller-supplied predicate - lib/prolog/tests/advanced.sx: 21 tests (12 arith, 5 term_variables, 4 predsort) - conformance.sh: add advanced suite - scoreboard: 517/517 (was 496/496) Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-04-25 14:13:12 +00:00
giles	bf250a24bf	Progress log: sub_atom+aggregate_all, 496/496 Some checks failed Test, Build, and Deploy / test-build-deploy (push) Has been cancelled Details	2026-04-25 13:50:54 +00:00
giles	537e2cdb5a	sub_atom/5 (non-det substring) + aggregate_all/3 (count/bag/sum/max/min/set) Some checks failed Test, Build, and Deploy / test-build-deploy (push) Has been cancelled Details Adds two new builtins to lib/prolog/runtime.sx: - sub_atom/5: non-deterministic substring enumeration. Iterates all (start, length) pairs over the atom string, tries to unify Before, Length, After, SubAtom for each candidate. Uses CPS loop helpers pl-substring, pl-sub-atom-try-one!, pl-sub-atom-loop!. Fixed trail undo semantics: only undo on backtrack (k returns false), not on success. - aggregate_all/3: collects all solutions via pl-collect-solutions then reduces. Templates: count, bag(T), sum(E), max(E), min(E), set(T). max/min fail on empty; count/bag/sum/set always succeed. New test suite lib/prolog/tests/string_agg.sx: 25 tests, all passing. Total conformance: 496/496. Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-04-25 13:50:13 +00:00
giles	0a8b30b7b8	Progress log: assert_rules + :- op, 471/471 Some checks failed Test, Build, and Deploy / test-build-deploy (push) Has been cancelled Details	2026-04-25 13:22:58 +00:00
giles	2075db62ba	Add :- to op table (prec 1200 xfx); enable assert/asserta/assertz with rule terms Some checks failed Test, Build, and Deploy / test-build-deploy (push) Has been cancelled Details - parser.sx: add (":-" 1200 "xfx") to pl-op-table so (head :- body) parses inside paren expressions (parens reset prec to 1200, allowing xfx match) - parser.sx: extend pl-token-op to accept "op" token type, not just "atom", since the tokenizer emits :- as {:type "op" :value ":-"} - tests/assert_rules.sx: 15 new tests covering assertz/asserta with rule terms, conjunction in rule body, recursive rules, and ordering - conformance.sh: wire in assert_rules suite - 456 → 471 tests, all passing Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-04-25 13:22:09 +00:00
giles	1aca2c7bc5	Progress log: io_predicates batch, 456/456 Some checks failed Test, Build, and Deploy / test-build-deploy (push) Has been cancelled Details	2026-04-25 13:01:17 +00:00
giles	be2000a048	IO predicates: term_to_atom/2, term_string/2, with_output_to/2, format/1,2, writeln/1 Some checks failed Test, Build, and Deploy / test-build-deploy (push) Has been cancelled Details Adds 6 new built-in predicates to the Prolog runtime and 24 tests covering term<->atom conversion (bidirectional), output capture, format directives (~w/~a/~d/~n/~~). 456/456 tests passing. Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-04-25 13:00:42 +00:00
giles	0be5eeafd8	Progress log: char_predicates batch, 432/432 Some checks failed Test, Build, and Deploy / test-build-deploy (push) Has been cancelled Details	2026-04-25 12:42:21 +00:00
giles	04ed092f88	Char predicates: char_type/2, upcase_atom/2, downcase_atom/2, string_upper/2, string_lower/2 Some checks failed Test, Build, and Deploy / test-build-deploy (push) Has been cancelled Details 27 new tests, 432/432 total. char_type/2 supports alpha, alnum, digit, digit(Weight), space/white, upper(Lower), lower(Upper), ascii(Code), punct. Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-04-25 12:41:31 +00:00
giles	776ae18a20	Progress log: set_predicates batch, 405/405 Some checks failed Test, Build, and Deploy / test-build-deploy (push) Has been cancelled Details	2026-04-25 12:22:58 +00:00
giles	5a83f4ef51	Set predicates: foldl/4, list_to_set/2, intersection/3, subtract/3, union/3 Some checks failed Test, Build, and Deploy / test-build-deploy (push) Has been cancelled Details Adds 5 new built-in predicates to the Prolog runtime with 15 tests. 390 → 405 tests across 20 suites (all passing). Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-04-25 12:22:03 +00:00
giles	73080bb7de	Progress log + tick classic-programs checkbox; 390/390 Some checks failed Test, Build, and Deploy / test-build-deploy (push) Has been cancelled Details	2026-04-25 12:00:20 +00:00
giles	8f0af85d01	Meta-call predicates: forall/2, maplist/2, maplist/3, include/3, exclude/3 Some checks failed Test, Build, and Deploy / test-build-deploy (push) Has been cancelled Details Adds pl-apply-goal helper for safe call/N goal construction (atom or compound), five solver helpers (pl-solve-forall!, pl-solve-maplist2!, pl-solve-maplist3!, pl-solve-include!, pl-solve-exclude!), five cond clauses in pl-solve!, and a new test suite (15/15 passing). Total conformance: 390/390. Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-04-25 11:59:35 +00:00
giles	07a22257f6	Progress log: list_predicates batch, 375/375 total Some checks failed Test, Build, and Deploy / test-build-deploy (push) Has been cancelled Details	2026-04-25 11:38:27 +00:00
giles	8ef05514b5	List/utility predicates: ==/2, \==/2, flatten/2, numlist/3, atomic_list_concat/2,3, sum_list/2, max_list/2, min_list/2, delete/3 Some checks failed Test, Build, and Deploy / test-build-deploy (push) Has been cancelled Details 33 new tests, all 375/375 conformance tests passing. Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-04-25 11:37:52 +00:00
giles	0823832dcd	Meta/logic predicates: \\+/not/once/ignore/ground/sort/msort/atom_number/number_string (+25 tests, 342 total) Some checks failed Test, Build, and Deploy / test-build-deploy (push) Has been cancelled Details Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-04-25 11:06:10 +00:00
giles	8ee0928a3d	ISO predicates: succ/2 + plus/3 + between/3 + length/2 + last/2 + nth0/3 + nth1/3 + max/min arith (+29 tests, 317 total) Some checks failed Test, Build, and Deploy / test-build-deploy (push) Has been cancelled Details Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-04-25 10:31:28 +00:00
giles	25a4ce4a05	prolog-query SX API: pl-load + pl-query-all + pl-query-one + pl-query (+16 tests) Some checks failed Test, Build, and Deploy / test-build-deploy (push) Has been cancelled Details Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-04-25 09:58:56 +00:00
giles	f72868c445	String/atom predicates: var/nonvar/atom/number/compound/callable/atomic/is_list + atom_length/atom_concat/atom_chars/atom_codes/char_code/number_codes/number_chars Some checks failed Test, Build, and Deploy / test-build-deploy (push) Has been cancelled Details Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-04-25 09:27:08 +00:00
giles	c6f58116bf	prolog: copy_term/2 + functor/3 + arg/3, 14 tests; =.. deferred Some checks failed Test, Build, and Deploy / test-build-deploy (push) Has been cancelled Details	2026-04-25 08:39:32 +00:00
giles	76ee8cc39b	prolog: findall/3 + bagof/3 + setof/3, 11 tests Some checks failed Test, Build, and Deploy / test-build-deploy (push) Has been cancelled Details	2026-04-25 08:06:35 +00:00
giles	373d57cbcb	prolog: assert/asserta/assertz/retract for facts, 11 tests Some checks failed Test, Build, and Deploy / test-build-deploy (push) Has been cancelled Details	2026-04-25 07:32:09 +00:00
giles	3190e770fb	prolog: operator-table parser + < > =< >= built-ins, 19 tests Some checks failed Test, Build, and Deploy / test-build-deploy (push) Has been cancelled Details	2026-04-25 06:57:48 +00:00
giles	e018ba9423	prolog: conformance.sh + scoreboard.{json,md}, 183/183 baseline Some checks failed Test, Build, and Deploy / test-build-deploy (push) Has been cancelled Details	2026-04-25 06:19:54 +00:00
giles	09683b8a18	prolog: family.pl + family.sx, 10 tests; 5/5 classic programs done Some checks failed Test, Build, and Deploy / test-build-deploy (push) Has been cancelled Details	2026-04-25 05:52:28 +00:00
giles	64e3b3f44e	prolog: nqueens.pl + nqueens.sx (N=1..5), 6 tests Some checks failed Test, Build, and Deploy / test-build-deploy (push) Has been cancelled Details	2026-04-25 05:24:49 +00:00
giles	1302f5a3cc	prolog: member.pl + member.sx generator, 7 tests Some checks failed Test, Build, and Deploy / test-build-deploy (push) Has been cancelled Details	2026-04-25 04:54:32 +00:00
giles	93b31b6c8a	prolog: reverse.pl + reverse.sx (naive via append), 6 tests Some checks failed Test, Build, and Deploy / test-build-deploy (push) Has been cancelled Details	2026-04-25 04:26:20 +00:00
giles	ffc3716b0e	prolog: append.pl + append.sx classic, 6 tests (build/check/split/deduce) Some checks failed Test, Build, and Deploy / test-build-deploy (push) Has been cancelled Details	2026-04-25 03:58:12 +00:00
giles	7fb4c52159	prolog: is/2 arithmetic with + - * / mod abs, 11 tests Some checks failed Test, Build, and Deploy / test-build-deploy (push) Has been cancelled Details	2026-04-25 03:27:56 +00:00
giles	072735a6de	prolog: write/1 + nl/0 via output buffer, 7 tests; built-ins box done Some checks failed Test, Build, and Deploy / test-build-deploy (push) Has been cancelled Details	2026-04-25 02:56:31 +00:00
giles	1846be0bd8	prolog: ->/2 if-then-else (in ; and standalone), 9 tests Some checks failed Test, Build, and Deploy / test-build-deploy (push) Has been cancelled Details	2026-04-25 02:23:44 +00:00
giles	3adad8e50e	prolog: \=/2 + ;/2 + call/1 built-ins, 11 tests Some checks failed Test, Build, and Deploy / test-build-deploy (push) Has been cancelled Details	2026-04-25 01:48:57 +00:00
giles	f019d42727	prolog: cut !/0 with two-cut-box barrier scheme, 6 tests Some checks failed Test, Build, and Deploy / test-build-deploy (push) Has been cancelled Details	2026-04-25 01:14:12 +00:00
giles	738f44e47d	prolog: DFS solver (CPS, trail-based) + true/fail/=/conj built-ins, 18 tests Some checks failed Test, Build, and Deploy / test-build-deploy (push) Has been cancelled Details	2026-04-25 00:38:50 +00:00
giles	1888c272f9	prolog: clause DB + loader (functor/arity → clauses), 14 tests green Some checks failed Test, Build, and Deploy / test-build-deploy (push) Has been cancelled Details	2026-04-24 23:59:46 +00:00
giles	60b7f0d7bb	prolog: tick phase 1+2 boxes (parse 25/25, unify 47/47 green) Some checks failed Test, Build, and Deploy / test-build-deploy (push) Has been cancelled Details	2026-04-24 16:58:30 +00:00