Progress log: predsort+term_variables+arith, 517/517

predsort/3, term_variables/2, arith: floor/ceiling/truncate/round/sign/sqrt/pow
- 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:59 +00:00 · 2026-04-25 14:13:12 +00:00 · 2026-04-25 13:50:54 +00:00 · 2026-04-25 13:50:13 +00:00 · 2026-04-25 13:22:58 +00:00 · 2026-04-25 13:22:09 +00:00
35 changed files with 8088 additions and 107 deletions
--- a/lib/prolog/conformance.sh
+++ b/lib/prolog/conformance.sh
@@ -0,0 +1,123 @@
+#!/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!"
+)
+
+SCRIPT='(epoch 1)
+(load "lib/prolog/tokenizer.sx")
+(load "lib/prolog/parser.sx")
+(load "lib/prolog/runtime.sx")
+(load "lib/prolog/query.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 "."
-;;   Term         := Atom | Var | Number | String | Compound | List
-;;   Compound     := atom "(" ArgList ")"
-;;   ArgList      := Term ("," Term)*
-;;   List         := "[" "]" | "[" Term ("," Term)* ("|" Term)? "]"
+;;   Clause       := Term[999] "." | Term[999] ":-" Term[1200] "."
+;;   Term[Pmax] uses precedence climbing on the operator table:
+;;     primary = Atom | Var | Number | String | Compound | List | "(" Term[1200] ")"
+;;     while next token is infix op `op` with prec(op) ≤ Pmax:
+;;       consume op; parse rhs at right-prec(op); fold into compound(op-name,[lhs,rhs])
 ;;
-;; Term AST shapes (all tagged lists for uniform dispatch):
-;;   ("atom"  name)            — atom
-;;   ("var"   name)            — variable template (parser-time only)
-;;   ("num"   value)           — integer or float
-;;   ("str"   value)           — string literal
-;;   ("compound" functor args) — compound term, args is list of term-ASTs
-;;   ("cut")                   — the cut atom !
+;; Op type → right-prec for op at precedence P:
+;;   xfx → P-1   strict-both
+;;   xfy → P     right-associative
+;;   yfx → P-1   left-associative
 ;;
-;; A clause is (list "clause" head body). A fact is head with body = ("atom" "true").
-;;
-;; The empty list is (atom "[]"). Cons is compound "." with two args:
-;; [1, 2, 3]   → .(1, .(2, .(3, [])))
-;; [H|T]       → .(H, T)
+;; AST shapes are unchanged — operators just become compound terms.

-;; ── 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
-;; right-associative `,` compound: (A, B, C) → ','(A, ','(B, C))
-;; If only one goal, it's that goal directly.
-(define
-  pp-parse-body
-  (fn
-    (st)
-    (let
-      ((first-goal (pp-parse-term st)) (rest-goals (list)))
-      (do
-        (define
-          gloop
-          (fn
-            ()
-            (when
-              (pp-at? st "punct" ",")
-              (do
-                (pp-advance! st)
-                (append! rest-goals (pp-parse-term st))
-                (gloop)))))
-        (gloop)
-        (if
-          (= (len rest-goals) 0)
-          first-goal
-          (pp-build-conj first-goal rest-goals))))))
-
-(define
-  pp-build-conj
-  (fn
-    (first-goal rest-goals)
-    (if
-      (= (len rest-goals) 0)
-      first-goal
-      (pl-mk-compound
-        ","
-        (list
-          first-goal
-          (pp-build-conj (first rest-goals) (rest rest-goals)))))))
+;; A body is a single term parsed at prec 1200 — operator parser folds
+;; `,`, `;`, `->` automatically into right-associative compounds.
+(define pp-parse-body (fn (st) (pp-parse-term-prec st 1200)))

 ;; ── 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/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/prolog-on-sx.md
+++ b/plans/prolog-on-sx.md
@@ -39,46 +39,46 @@ 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 (`%`, `/* */`)
- [ ] 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.
- [ ] Unit tests in `lib/prolog/tests/parse.sx`
+- [x] Tokenizer: atoms (lowercase/quoted), variables (uppercase/`_`), numbers, strings, punct `( ) , . [ ] | ! :-`, comments (`%`, `/* */`)
+- [x] Parser: clauses `head :- body.` and facts `head.`; terms `atom | Var | number | compound(args) | [list,sugar]`
+- [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.
+- [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!`
- [ ] 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] `make-var`, `walk` (follow binding chain), `prolog-unify!` (terms + trail → bool), `trail-undo-to!`
+- [x] Occurs-check off by default, exposed as flag
+- [x] 30+ unification tests in `lib/prolog/tests/unify.sx`: atoms, vars, compounds, lists, cyclic (no-occurs-check), mutual occurs — 47 pass

 ### Phase 3 — clause DB + DFS solver + cut + first classic programs
- [ ] Clause DB: `"functor/arity" → list-of-clauses`, loader inserts
- [ ] 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
- [ ] Cut (`!`): cut barrier at current choice-point frame; collapse all up to barrier
- [ ] Built-ins: `=/2`, `\\=/2`, `true/0`, `fail/0`, `!/0`, `,/2`, `;/2`, `->/2` inside `;`, `call/1`, `write/1`, `nl/0`
- [ ] Arithmetic `is/2` with `+ - * / mod abs`
- [ ] Classic programs in `lib/prolog/tests/programs/`:
-  - [ ] `append.pl` — list append (with backtracking)
-  - [ ] `reverse.pl` — naive reverse
-  - [ ] `member.pl` — generate all solutions via backtracking
-  - [ ] `nqueens.pl` — 8-queens
-  - [ ] `family.pl` — facts + rules (parent/ancestor)
- [ ] `lib/prolog/conformance.sh` + runner, `scoreboard.json` + `scoreboard.md`
- [ ] Target: all 5 classic programs passing
+- [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`
+- [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.
+- [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.
+- [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.
+- [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.
+- [x] Classic programs in `lib/prolog/tests/programs/`:
+  - [x] `append.pl` — list append (with backtracking) — `lib/prolog/tests/programs/append.{pl,sx}`. 6 tests cover: build (`append([], L, X)`, `append([1,2], [3,4], X)`), check ground match/mismatch, full split-backtracking (`append(X, Y, [1,2,3])` → 4 solutions), single-deduce (`append(X, [3], [1,2,3])` → X=[1,2]).
+  - [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.
+  - [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.
+  - [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.).
+  - [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 + `\=`.
+- [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.
+- [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)
- [ ] `assert/1`, `asserta/1`, `assertz/1`, `retract/1`
- [ ] `findall/3`, `bagof/3`, `setof/3`
- [ ] `copy_term/2`, `functor/3`, `arg/3`, `=../2`
- [ ] String/atom predicates
+- [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.
+- [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`.
+- [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`.
+- [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`.
+- [x] String/atom predicates

 ### Phase 5 — Hyperscript integration
- [ ] `prolog-query` primitive callable from SX/Hyperscript
- [ ] Hyperscript DSL: `when allowed(user, :edit) then …`
+- [x] `prolog-query` primitive callable from SX/Hyperscript
+- [ ] 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
- [ ] Drive scoreboard to 200+
+- [x] Vendor Hirst's conformance tests
+- [x] Drive scoreboard to 200+

 ### Phase 7 — compiler (later, optional)
 - [ ] Compile clauses to SX continuations for speed
@@ -88,10 +88,40 @@ Representation choices (finalise in phase 1, document here):

 _Newest first. Agent appends on every commit._

+- 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	00db8b7763	Progress log: predsort+term_variables+arith, 517/517 Some checks are pending Test, Build, and Deploy / test-build-deploy (push) Waiting to run 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