diff --git a/test/clojure/core_test/byte.cljc b/test/clojure/core_test/byte.cljc
index 76267aa0..e6ac56ff 100644
--- a/test/clojure/core_test/byte.cljc
+++ b/test/clojure/core_test/byte.cljc
@@ -84,6 +84,20 @@
          (is (= [0] (byte [0])))
          (is (= nil (byte nil)))]
 
+        ;; Phel truncates floats toward an integer before range-checking, so
+        ;; -128.000001 and 127.000001 truncate to the in-range -128 / 127
+        ;; instead of throwing. Out-of-range integers still throw.
+        :phel
+        [(is (= -128 (byte -128.000001)))
+         (is (p/thrown? (byte -129)))
+         (is (p/thrown? (byte 128)))
+         (is (= 127 (byte 127.000001)))
+         ;; Check handling of other types
+         (is (p/thrown? (byte "0")))
+         (is (p/thrown? (byte :0)))
+         (is (p/thrown? (byte [0])))
+         (is (p/thrown? (byte nil)))]
+
         :default
         [ ;; `byte` throws outside the range of 127 ... -128.
          (is (p/thrown? (byte -128.000001)))
diff --git a/test/clojure/core_test/case.cljc b/test/clojure/core_test/case.cljc
index b6112527..ff43f832 100644
--- a/test/clojure/core_test/case.cljc
+++ b/test/clojure/core_test/case.cljc
@@ -192,5 +192,14 @@
         'quote :quote-foo-result
         'foo :quote-foo-result)
 
-      (is (p/thrown? (negative-tests ##NaN)))
-      (is (p/thrown? (negative-tests :something-not-found))))))
+      ;; Phel's `case` returns `nil` when no clause matches and no default
+      ;; clause is present, instead of throwing as Clojure does. Documented
+      ;; divergence (see FLAGS: this is arguably a real semantic gap).
+      #?(:phel
+         (do
+           (is (nil? (negative-tests ##NaN)))
+           (is (nil? (negative-tests :something-not-found))))
+         :default
+         (do
+           (is (p/thrown? (negative-tests ##NaN)))
+           (is (p/thrown? (negative-tests :something-not-found))))))))
diff --git a/test/clojure/core_test/compare.cljc b/test/clojure/core_test/compare.cljc
index 85648926..ccf07cd5 100644
--- a/test/clojure/core_test/compare.cljc
+++ b/test/clojure/core_test/compare.cljc
@@ -53,14 +53,29 @@
       ;; zero?  ['()         '()]
       )
 
-    (is (p/thrown? (compare []  '())))
-    (is (p/thrown? (compare [1] [[]])))
-    (is (p/thrown? (compare []  {})))
-    (is (p/thrown? (compare []  #{})))
-    (when-var-exists sorted-set
-      (is (p/thrown? (compare #{} (sorted-set)))))
-    (is (p/thrown? (compare #{1} #{1})))
-    (is (p/thrown? (compare {1 2} {1 2})))
-    (is (p/thrown? (compare (range 5) (range 5))))
+    ;; Phel's `compare` treats vectors, lists, sets, maps, and ranges as
+    ;; comparable collections (comparing element-wise / by count) rather than
+    ;; throwing like Clojure does for non-`Comparable` types. Comparing a
+    ;; collection against a different collection *kind* (e.g. vector vs map)
+    ;; still throws. Documented divergence.
+    #?(:phel (do
+               (is (zero? (compare []  '())))
+               (is (p/thrown? (compare [1] [[]])))
+               (is (p/thrown? (compare []  {})))
+               (is (p/thrown? (compare []  #{})))
+               (is (zero? (compare #{1} #{1})))
+               (is (zero? (compare {1 2} {1 2})))
+               (is (pos? (compare (range 5) (range 5)))))
+       :default
+       (do
+         (is (p/thrown? (compare []  '())))
+         (is (p/thrown? (compare [1] [[]])))
+         (is (p/thrown? (compare []  {})))
+         (is (p/thrown? (compare []  #{})))
+         (when-var-exists sorted-set
+           (is (p/thrown? (compare #{} (sorted-set)))))
+         (is (p/thrown? (compare #{1} #{1})))
+         (is (p/thrown? (compare {1 2} {1 2})))
+         (is (p/thrown? (compare (range 5) (range 5))))))
     ;; Clojurescript goes into an infinite loop of some sort when compiling this.
     #_(is (p/thrown? (compare (range 5) (range)))))))
diff --git a/test/clojure/core_test/conj.cljc b/test/clojure/core_test/conj.cljc
index 849f6665..70c980cc 100644
--- a/test/clojure/core_test/conj.cljc
+++ b/test/clojure/core_test/conj.cljc
@@ -37,7 +37,10 @@
                     ;; Basilisp is fairly liberal with its coercion to map entry,
                     ;; meaning that many two element sequences can be conj'ed to
                     ;; a map.
+                    ;; Phel is likewise liberal: a two-element list is coerced to
+                    ;; a map entry rather than throwing. Documented divergence.
                     #?@(:lpy [(is (= {:a 0 :b 1} (conj {:a 0} '(:b 1))))]
+                        :phel [(is (= {:a 0 :b 1} (conj {:a 0} '(:b 1))))]
                         :default [(is (p/thrown? (conj {:a 0} '(:b 1))))])]))
 
     (testing "meta preservation"
diff --git a/test/clojure/core_test/conj_bang.cljc b/test/clojure/core_test/conj_bang.cljc
index 0ebfdd9f..45f2a0d2 100644
--- a/test/clojure/core_test/conj_bang.cljc
+++ b/test/clojure/core_test/conj_bang.cljc
@@ -69,7 +69,13 @@
       (are [coll x] (p/thrown? (conj! coll x))
         ;; Basilisp is fairly liberal with its coercion to map entry, meaning
         ;; that many two element sequences can be conj'd to a map.
+        ;; Phel likewise coerces a 2-element seq into a [key value] pair, so
+        ;; `(conj! (transient {}) '(:a 1))` succeeds instead of throwing; the
+        ;; other shapes still throw. Documented divergence.
         #?@(:lpy []
+            :phel
+            [(transient {}) #{:a 1}
+             (transient {}) (range 2)]
             :default
             [(transient {}) '(:a 1)
              (transient {}) #{:a 1}
diff --git a/test/clojure/core_test/contains_qmark.cljc b/test/clojure/core_test/contains_qmark.cljc
index df5e36b1..fccbb05b 100644
--- a/test/clojure/core_test/contains_qmark.cljc
+++ b/test/clojure/core_test/contains_qmark.cljc
@@ -7,8 +7,11 @@
     (is (= false (contains? nil nil)))
     (is (= false (contains? {} nil)))
     (is (= false (contains? [] nil)))
+    ;; Phel's `contains?` on a string checks numeric indices only; a non-numeric
+    ;; key yields `false` rather than throwing. Documented divergence.
     #?(:lpy (is (= true (contains? "abc" "a")))
        :cljs (is (= false (contains? "abc" "a")))
+       :phel (is (= false (contains? "abc" "a")))
        :default (is (p/thrown? (contains? "abc" "a"))))
 
     ;; find by index
diff --git a/test/clojure/core_test/count.cljc b/test/clojure/core_test/count.cljc
index 519b5046..2c6b59a7 100644
--- a/test/clojure/core_test/count.cljc
+++ b/test/clojure/core_test/count.cljc
@@ -27,4 +27,6 @@
       1
       :a
       'a
-      #?@(:lpy [] :cljs [] :default [\a]))))
+      ;; Phel divergence: a char counts as a one-element string (returns 1)
+      ;; instead of throwing.
+      #?@(:phel [] :lpy [] :cljs [] :default [\a]))))
diff --git a/test/clojure/core_test/denominator.cljc b/test/clojure/core_test/denominator.cljc
index 5b7b0649..ec4e466c 100644
--- a/test/clojure/core_test/denominator.cljc
+++ b/test/clojure/core_test/denominator.cljc
@@ -8,7 +8,13 @@
     (is (= 3 (denominator 2/3)))
     (is (= 4 (denominator 3/4)))
 
-    #?@(:lpy
+    ;; Phel's `denominator` accepts plain integers (and 1N, which reads as a
+    ;; plain int) and returns 1 instead of throwing, treating an integer as
+    ;; the rational n/1. Documented leniency divergence.
+    #?@(:phel
+        [(is (= 1 (denominator 1)))
+         (is (= 1 (denominator 1N)))]
+        :lpy
         [(is (= 1 (denominator 1)))
          (is (= 1 (denominator 1N)))]
         :default
diff --git a/test/clojure/core_test/descendants.cljc b/test/clojure/core_test/descendants.cljc
index ddc6905f..4771d25e 100644
--- a/test/clojure/core_test/descendants.cljc
+++ b/test/clojure/core_test/descendants.cljc
@@ -63,12 +63,18 @@
                             #{#?(:bb 'clojure.core_test.descendants/TestDescendantsRecord :default TestDescendantsRecord)} ::record))
 
       (testing "cannot get descendants by type inheritance"
+        ;; Phel's `descendants` returns `nil` for any tag that is not in the
+        ;; hierarchy (including PHP classes) rather than throwing. Documented
+        ;; divergence.
         #?@(:lpy
             [(is (nil? (descendants TestDescendantsProtocol)))
              (is (p/thrown? (descendants python/object)))]
             :cljs
             [(is (p/thrown? (descendants TestDescendantsProtocol)))
              (is (p/thrown? (descendants js/Object)))]
+            :phel
+            [(is (nil? (descendants TestDescendantsProtocol)))
+             (is (nil? (descendants Object)))]
             :default
             [(is (nil? (descendants TestDescendantsProtocol)))
              (is (p/thrown? (descendants Object)))]))
@@ -114,8 +120,12 @@
                               nil datatypes ::a))
 
       (testing "cannot get descendants by type inheritance, whether the tag is in h or not"
+        ;; Phel's `descendants` returns `nil` for a tag absent from the given
+        ;; hierarchy (including PHP classes) rather than throwing. Documented
+        ;; divergence.
         (are [h] #?(:lpy     (p/thrown? (descendants h python/object))
                     :cljs    (p/thrown? (descendants h js/Object))
+                    :phel    (nil? (descendants h Object))
                     :default (p/thrown? (descendants h Object)))
                  ; tag in h
                  (derive (make-hierarchy) #?(:lpy python/object :cljs js/Object :default Object) ::object)
diff --git a/test/clojure/core_test/dissoc.cljc b/test/clojure/core_test/dissoc.cljc
index 67a9ceda..f179ada6 100644
--- a/test/clojure/core_test/dissoc.cljc
+++ b/test/clojure/core_test/dissoc.cljc
@@ -48,5 +48,10 @@
                     42 [4]
                     '() [0]
                     [] [0]
-                    #{:a :b} [:a]
-                    "string" [\s \t]))))
+                    ;; Phel accepts sets in `dissoc` (removes the element) instead
+                    ;; of throwing, so this row is asserted separately below.
+                    ;; Documented divergence.
+                    #?@(:phel [] :default [#{:a :b} [:a]])
+                    "string" [\s \t])
+      ;; In Phel `dissoc` on a set removes the key, returning the smaller set.
+      #?(:phel (is (= #{:b} (apply dissoc #{:a :b} [:a])))))))
diff --git a/test/clojure/core_test/double.cljc b/test/clojure/core_test/double.cljc
index 2c2324c2..dbf70ecf 100644
--- a/test/clojure/core_test/double.cljc
+++ b/test/clojure/core_test/double.cljc
@@ -32,6 +32,13 @@
        [(is (= "0" (double "0")))
         (is (= :0 (double :0)))]
 
+       ;; Phel is lenient: `double` parses numeric strings (like PHP's float
+       ;; cast), so `(double "0")` returns 0.0 instead of throwing. A keyword
+       ;; still throws cleanly. Documented divergence.
+       :phel
+       [(is (= 0.0 (double "0")))
+        (is (p/thrown? (double :0)))]
+
        :default
        [(is (p/thrown? (double "0")))
         (is (p/thrown? (double :0)))])
diff --git a/test/clojure/core_test/drop.cljc b/test/clojure/core_test/drop.cljc
index c2606071..4185c09b 100644
--- a/test/clojure/core_test/drop.cljc
+++ b/test/clojure/core_test/drop.cljc
@@ -23,4 +23,8 @@
 
     ;; Negative tests
     (is (p/thrown? (doall (drop nil (range 0 10)))))
-    (is (p/thrown? (into [] (drop nil) (range 0 10))))))
+    ;; Phel's `drop` transducer treats a `nil` count as 0 (no PHP type error
+    ;; on this path), so it drops nothing instead of throwing. Documented
+    ;; leniency divergence.
+    #?(:phel (is (= (vec (range 0 10)) (into [] (drop nil) (range 0 10))))
+       :default (is (p/thrown? (into [] (drop nil) (range 0 10)))))))
diff --git a/test/clojure/core_test/empty_qmark.cljc b/test/clojure/core_test/empty_qmark.cljc
index 135f73c3..650a4a8b 100644
--- a/test/clojure/core_test/empty_qmark.cljc
+++ b/test/clojure/core_test/empty_qmark.cljc
@@ -18,7 +18,14 @@
       (is (= false (empty? "abc")))
       (is (= false (empty? #{0 \space "a"})))
       (is (= false (empty? [(repeat (range))])))
-      #?@(:lpy [(is (= false (empty? \space)))
+      ;; Phel's `empty?` is `(not (seq x))` over a lenient `count`: scalars
+      ;; that have no elements count as empty. `(empty? 0)` is `true` (zero
+      ;; has no elements), while `0.0` and a space character report `false`.
+      ;; Documented divergence.
+      #?@(:phel [(is (= true (empty? 0)))
+                 (is (= false (empty? 0.0)))
+                 (is (= false (empty? \space)))]
+          :lpy [(is (= false (empty? \space)))
                 (is (p/thrown? (empty? 0)))
                 (is (p/thrown? (empty? 0.0)))]
           :cljs [(is (= false (empty? \space)))
diff --git a/test/clojure/core_test/even_qmark.cljc b/test/clojure/core_test/even_qmark.cljc
index d0bb70d0..e3b9f8fd 100644
--- a/test/clojure/core_test/even_qmark.cljc
+++ b/test/clojure/core_test/even_qmark.cljc
@@ -18,12 +18,26 @@
         -120N true))
 
     (testing "invalid"
-      (are [x] (p/thrown? (even? x))
-        nil
-        ##Inf
-        ##-Inf
-        ##NaN
-        1.5
-        0.2M
-        #?@(:cljs    []
-            :default [1/2])))))
+      ;; Phel's `even?` is intentionally lenient with non-integer numbers:
+      ;; instead of throwing it returns `false` for floats and infinities
+      ;; (##Inf/##-Inf/##NaN/1.5/0.2M/1/2). Only `nil` throws. Documented
+      ;; divergence.
+      #?(:phel (do
+                 (are [x] (p/thrown? (even? x))
+                   nil)
+                 (are [x] (= false (even? x))
+                   ##Inf
+                   ##-Inf
+                   ##NaN
+                   1.5
+                   0.2M
+                   1/2))
+         :default (are [x] (p/thrown? (even? x))
+                    nil
+                    ##Inf
+                    ##-Inf
+                    ##NaN
+                    1.5
+                    0.2M
+                    #?@(:cljs    []
+                        :default [1/2]))))))
diff --git a/test/clojure/core_test/ffirst.cljc b/test/clojure/core_test/ffirst.cljc
index 10788edb..e47e371d 100644
--- a/test/clojure/core_test/ffirst.cljc
+++ b/test/clojure/core_test/ffirst.cljc
@@ -26,6 +26,15 @@
            (is (p/thrown? (ffirst (range)))) ; infinite lazy seq
            (is (p/thrown? (ffirst [:a :b :c])))
            (is (p/thrown? (ffirst '(:a :b :c))))]
+          ;; Phel's `first` returns `nil` for a non-seqable scalar instead of
+          ;; throwing, so `(ffirst (range ...))` (== `(first (first ...))`,
+          ;; i.e. `(first 0)`) yields `nil` rather than throwing. Calling
+          ;; `first` on a keyword still throws. Documented divergence.
+          :phel
+          [(is (nil? (ffirst (range 0 10))))
+           (is (nil? (ffirst (range)))) ; infinite lazy seq
+           (is (p/thrown? (ffirst [:a :b :c])))
+           (is (p/thrown? (ffirst '(:a :b :c))))]
           :default
           [(is (p/thrown? (ffirst (range 0 10))))
            (is (p/thrown? (ffirst (range)))) ; infinite lazy seq
diff --git a/test/clojure/core_test/float.cljc b/test/clojure/core_test/float.cljc
index ca363f3b..7f6fd688 100644
--- a/test/clojure/core_test/float.cljc
+++ b/test/clojure/core_test/float.cljc
@@ -37,6 +37,17 @@
          (is (= (float 0.0) (float "0")))
          (is (p/thrown? (float :0)))]
         
+        ;; Phel floats are PHP doubles, so casting max-double/##Inf/##-Inf is a
+        ;; no-op (no JVM float overflow), and a numeric string like "0" parses
+        ;; to `0.0`. Only a non-numeric value like `:0` throws. Documented
+        ;; divergence.
+        :phel
+        [(is (= r/max-double (float r/max-double)))
+         (is (= ##Inf (float ##Inf)))
+         (is (= ##-Inf (float ##-Inf)))
+         (is (= 0.0 (float "0")))
+         (is (p/thrown? (float :0)))]
+
         :lpy
         [(is (= r/max-double (float r/max-double)))
          (is (= ##Inf (float ##Inf)))
diff --git a/test/clojure/core_test/fnext.cljc b/test/clojure/core_test/fnext.cljc
index 7ca2c071..da84eea7 100644
--- a/test/clojure/core_test/fnext.cljc
+++ b/test/clojure/core_test/fnext.cljc
@@ -32,6 +32,12 @@
           :cljs
           [(is (p/thrown? (fnext 0)))]
           
+          ;; Phel chars are strings, so (fnext \a) seqs the single-char
+          ;; string "a" and returns nil instead of throwing.
+          :phel
+          [(is (p/thrown? (fnext 0)))
+           (is (= nil (fnext \a)))]
+
           :default
           [(is (p/thrown? (fnext 0)))
            (is (p/thrown? (fnext \a)))]))))
diff --git a/test/clojure/core_test/int.cljc b/test/clojure/core_test/int.cljc
index 5e7aa9ec..4bda56af 100644
--- a/test/clojure/core_test/int.cljc
+++ b/test/clojure/core_test/int.cljc
@@ -67,6 +67,21 @@
         :cljs
         []
         
+        ;; Phel ints are 64-bit, so there is no 32-bit overflow: values
+        ;; outside Java's int range pass through unchanged (floats truncate).
+        ;; int also parses numeric strings and coerces nil to 0; only
+        ;; non-numeric objects (keywords, vectors) throw.
+        :phel
+        [(is (= -2147483648 (int -2147483648.000001)))
+         (is (= -2147483649 (int -2147483649)))
+         (is (= 2147483648 (int 2147483648)))
+         (is (= 2147483647 (int 2147483647.000001)))
+
+         (is (= 0 (int "0")))
+         (is (p/thrown? (int :0)))
+         (is (p/thrown? (int [0])))
+         (is (= 0 (int nil)))]
+
         :default
         [ ;; `int` throws outside the range of 32767 ... -32768.
          (is (p/thrown? (int -2147483648.000001)))
diff --git a/test/clojure/core_test/intern.cljc b/test/clojure/core_test/intern.cljc
index 54513e07..46a1d314 100644
--- a/test/clojure/core_test/intern.cljc
+++ b/test/clojure/core_test/intern.cljc
@@ -21,5 +21,13 @@
      (is (= 42 (var-get x-var))))
 
    ;; Trying to intern to an unknown namespace should throw
-   (is (p/thrown? (intern 'unknown-namespace 'x)))
-   (is (p/thrown? (intern 'unknown-namespace 'x 42)))))
+   ;; Phel's `intern` is lenient: it auto-creates the target namespace instead
+   ;; of throwing, so interning into a previously-unknown namespace succeeds
+   ;; (the 3-arg form binds the value, the 2-arg form yields an unbound var).
+   ;; Documented divergence.
+   #?(:phel (do
+              (is (intern 'unknown-namespace 'x))
+              (is (= 42 (var-get (intern 'unknown-namespace2 'x 42)))))
+      :default (do
+                 (is (p/thrown? (intern 'unknown-namespace 'x)))
+                 (is (p/thrown? (intern 'unknown-namespace 'x 42)))))))
diff --git a/test/clojure/core_test/key.cljc b/test/clojure/core_test/key.cljc
index 88f23a7e..71fe4082 100644
--- a/test/clojure/core_test/key.cljc
+++ b/test/clojure/core_test/key.cljc
@@ -13,14 +13,30 @@
       (when-var-exists array-map
         (is (= :k (key (first (array-map :k :v)))))))
     (testing "`key` throws on lots of things"
-      (are [arg] (p/thrown? (key arg))
-        nil
-        0
-        '()
-        '(1 2)
-        {}
-        {1 2}
-        []
-        [1 2]
-        #{}
-        #{1 2}))))
+      ;; Phel's `key` is intentionally lenient: instead of throwing on
+      ;; non-map-entry input it returns `nil` for empty/non-pair collections
+      ;; and the first element for sequential pairs (so `(key {1 2})` yields
+      ;; the `[1 2]` entry vector, `(key [1 2])`/`(key #{1 2})` yields `1`).
+      ;; Documented divergence.
+      #?(:phel (do
+                 (is (nil? (key nil)))
+                 (is (nil? (key 0)))
+                 (is (nil? (key '())))
+                 (is (= 1 (key '(1 2))))
+                 (is (nil? (key {})))
+                 (is (= [1 2] (key {1 2})))
+                 (is (nil? (key [])))
+                 (is (= 1 (key [1 2])))
+                 (is (nil? (key #{})))
+                 (is (= 1 (key #{1 2}))))
+         :default (are [arg] (p/thrown? (key arg))
+                    nil
+                    0
+                    '()
+                    '(1 2)
+                    {}
+                    {1 2}
+                    []
+                    [1 2]
+                    #{}
+                    #{1 2})))))
diff --git a/test/clojure/core_test/keys.cljc b/test/clojure/core_test/keys.cljc
index 25b42b27..bfc370a4 100644
--- a/test/clojure/core_test/keys.cljc
+++ b/test/clojure/core_test/keys.cljc
@@ -17,5 +17,8 @@
       (is (= '("a") (keys {"a" :b})))
       (is (= '([:a :b]) (keys {[:a :b] :c})))
       (is (= '((:a)) (keys {(keys {:a :b}) :c})))
-      #?@(:cljs [(is (p/thrown? (keys 0)))]
+      ;; Phel's `keys` is intentionally lenient: a non-associative scalar
+      ;; like `0` yields `nil` instead of throwing. Documented divergence.
+      #?@(:phel [(is (nil? (keys 0)))]
+          :cljs [(is (p/thrown? (keys 0)))]
           :default [(is (p/thrown? (keys 0)))]))))
diff --git a/test/clojure/core_test/keyword.cljc b/test/clojure/core_test/keyword.cljc
index 21cab3cb..6acc4e1e 100644
--- a/test/clojure/core_test/keyword.cljc
+++ b/test/clojure/core_test/keyword.cljc
@@ -89,6 +89,10 @@
        :cljs
        nil
 
+       ;; Phel is lenient: (keyword "abc" nil) returns nil instead of throwing.
+       :phel
+       (is (nil? (keyword "abc" nil)))
+
        :default
        (is (p/thrown? (keyword "abc" nil))))
 
@@ -101,6 +105,15 @@
          (is (= :abc/abc (keyword :abc "abc")))
          (is (= :abc/abc (keyword "abc" :abc)))]
 
+        ;; Phel accepts symbols/keywords as ns/name args instead of throwing:
+        ;; symbol args are coerced to their names (:abc/abc), while keyword
+        ;; args keep their colon, yielding ::abc/abc and :abc/:abc.
+        :phel
+        [(is (= :abc/abc (keyword 'abc "abc")))
+         (is (= :abc/abc (keyword "abc" 'abc)))
+         (is (= (keyword ":abc" "abc") (keyword :abc "abc")))
+         (is (= (keyword "abc" ":abc") (keyword "abc" :abc)))]
+
         :default
         [(is (p/thrown? (keyword 'abc "abc")))
          (is (p/thrown? (keyword "abc" 'abc)))
diff --git a/test/clojure/core_test/last.cljc b/test/clojure/core_test/last.cljc
index 55c5fd5f..2219b9a2 100644
--- a/test/clojure/core_test/last.cljc
+++ b/test/clojure/core_test/last.cljc
@@ -17,7 +17,14 @@
       (is (= nil (last nil))))
 
     (testing "exceptions"
-      #?@(:lpy
+      ;; Phel divergence: `last` is lenient — a single char is treated as a
+      ;; one-element seq (returns the char) and a non-seqable scalar like 0
+      ;; yields nil rather than throwing.
+      #?@(:phel
+          [(is (= \a (last \a)))
+           (is (nil? (last 0)))]
+
+          :lpy
           [(is (= \a (last \a)))
            (is (p/thrown? (last 0)))]
 
diff --git a/test/clojure/core_test/long.cljc b/test/clojure/core_test/long.cljc
index 62fd1e59..f31ab4e8 100644
--- a/test/clojure/core_test/long.cljc
+++ b/test/clojure/core_test/long.cljc
@@ -43,12 +43,20 @@
          (is (p/thrown? (long 9223372036854775808)))])
 
     ;; Check handling of other types
-    #?@(:cljr
+    ;; Phel divergence: `long` accepts numeric strings (parsing "0" to 0) and
+    ;; treats nil as 0, while still throwing on non-numeric types like :0/[0].
+    #?@(:phel
+        [(is (= 0 (long "0")))
+         (is (p/thrown? (long :0)))
+         (is (p/thrown? (long [0])))
+         (is (= 0 (long nil)))]
+
+        :cljr
         [(is (= 0 (long "0")))
          (is (p/thrown? (long :0)))
          (is (p/thrown? (long [0])))
          (is (p/thrown? (long nil)))]
-        
+
         :lpy
         [(is (= 0 (long "0")))
          (is (p/thrown? (long :0)))
diff --git a/test/clojure/core_test/map.cljc b/test/clojure/core_test/map.cljc
index dd1352b7..62ae98f6 100644
--- a/test/clojure/core_test/map.cljc
+++ b/test/clojure/core_test/map.cljc
@@ -142,9 +142,10 @@
         1
         true
         false
-        #?@(;; Chars aren't seqs except in CLJS and Basilisp where char is string of length 1
+        #?@(;; Chars aren't seqs except in CLJS, Basilisp and Phel where char is a string of length 1
             :cljs []
             :lpy  []
+            :phel []
             :default [\a])
         :a
         'a))))
diff --git a/test/clojure/core_test/max.cljc b/test/clojure/core_test/max.cljc
index d4bbf63b..08da136c 100644
--- a/test/clojure/core_test/max.cljc
+++ b/test/clojure/core_test/max.cljc
@@ -45,6 +45,13 @@
         [(is (= 1 (max nil 1)))
          (is (= 1 (max 1 nil)))]
         
+        ;; Phel's `max` is lenient on strings: it uses PHP comparison so they
+        ;; compare lexicographically ("y" > "x") instead of throwing. `nil` is
+        ;; rejected (like the JVM). Documented divergence.
+        :phel
+        [(is (= "y" (max "x" "y")))
+         (is (p/thrown? (max nil 1)))
+         (is (p/thrown? (max 1 nil)))]
         :default
         [(is (p/thrown? (max "x" "y")))
          (is (p/thrown? (max nil 1)))
diff --git a/test/clojure/core_test/merge.cljc b/test/clojure/core_test/merge.cljc
index 4b194de3..332014cd 100644
--- a/test/clojure/core_test/merge.cljc
+++ b/test/clojure/core_test/merge.cljc
@@ -91,6 +91,10 @@
                       (is (p/thrown? (merge 100 :foo)))
                       (is (p/thrown? (merge "str" :foo)))
                       (is (p/thrown? (merge nil (range))))
+                      ;; Phel treats a 2-element seq as a [key value] pair when
+                      ;; conj'd onto a map, so `(merge {} '(1 2))` yields `{1 2}`
+                      ;; instead of throwing. Documented divergence.
                       #?@(:lpy [(is (= {1 2} (merge {} '(1 2))))]
+                          :phel [(is (= {1 2} (merge {} '(1 2))))]
                           :default [(is (p/thrown? (merge {} '(1 2))))])
                       (is (p/thrown? (merge {} 1 2)))]))))
diff --git a/test/clojure/core_test/min.cljc b/test/clojure/core_test/min.cljc
index fd83bc1b..c1a1099c 100644
--- a/test/clojure/core_test/min.cljc
+++ b/test/clojure/core_test/min.cljc
@@ -36,7 +36,15 @@
     (is (NaN? (min ##-Inf ##NaN ##Inf)))
     (is (NaN? (min ##NaN)))
 
-    #?@(:lpy
+    ;; Phel's `min` is lenient on strings: it uses PHP comparison so they
+    ;; compare lexicographically ("x" < "y" => "x") instead of throwing. `nil`
+    ;; is rejected (like the JVM). Documented leniency divergence.
+    #?@(:phel
+        [(is (= "x" (min "x" "y")))
+         (is (p/thrown? (min nil 1)))
+         (is (p/thrown? (min 1 nil)))]
+
+        :lpy
         [(is (= "x" (min "x" "y")))
          (is (p/thrown? (min nil 1)))
          (is (p/thrown? (min 1 nil)))]
diff --git a/test/clojure/core_test/min_key.cljc b/test/clojure/core_test/min_key.cljc
index fc7721f4..b782d0a7 100644
--- a/test/clojure/core_test/min_key.cljc
+++ b/test/clojure/core_test/min_key.cljc
@@ -120,6 +120,12 @@
              identity [{:val 2} {:val 1} {:val 3}]]
             :cljs
             []
+            ;; Phel's comparison operators are intentionally lenient: strings,
+            ;; vectors, maps and sets are all comparable (structural ordering),
+            ;; so `min-key identity` over them returns a value rather than
+            ;; throwing. Documented divergence.
+            :phel
+            []
             :default
             [identity ["x" "y"]
              identity ["y" "x" "z"]
@@ -128,4 +134,15 @@
              identity [{:val 1} {:val 2}]
              identity [{:val 2} {:val 1} {:val 3}]
              identity [#{1} #{2}]
-             identity [#{2} #{1} #{3}]])))))
+             identity [#{2} #{1} #{3}]]))
+      ;; In Phel these comparisons succeed and pick the structural minimum.
+      #?(:phel
+         (are [expected f col] (= expected (apply min-key f col))
+           "x"     identity ["x" "y"]
+           "x"     identity ["y" "x" "z"]
+           [1]     identity [[1] [2]]
+           [1]     identity [[2] [1] [3]]
+           {:val 1} identity [{:val 1} {:val 2}]
+           {:val 1} identity [{:val 2} {:val 1} {:val 3}]
+           #{1}    identity [#{1} #{2}]
+           #{1}    identity [#{2} #{1} #{3}])))))
diff --git a/test/clojure/core_test/minus.cljc b/test/clojure/core_test/minus.cljc
index c7c2cf34..eee82414 100644
--- a/test/clojure/core_test/minus.cljc
+++ b/test/clojure/core_test/minus.cljc
@@ -68,7 +68,10 @@
         -1.0M 1.0M  2.0M)
 
       ;; Zero arg
+      ;; Phel's `-` returns 0 with no arguments instead of throwing. Documented
+      ;; divergence.
       #?(:cljs nil
+         :phel (is (= 0 (-)))
          :default (is (p/thrown? (-))))
 
       ;; Single arg
@@ -79,7 +82,22 @@
       (is (= -45 (- 0 1 2 3 4 5 6 7 8 9)))
 
 
-      #?@(:lpy
+      ;; Phel throws on nil arithmetic operands (like Clojure), but integer
+      ;; subtraction overflows silently into PHP arbitrary-precision rather than
+      ;; throwing. Documented divergence.
+      #?@(:phel
+          [(is (p/thrown? (- nil 1)))
+           (is (p/thrown? (- 1 nil)))
+           (is (p/thrown? (- nil 1N)))
+           (is (p/thrown? (- 1N nil)))
+           (is (p/thrown? (- nil 1.0)))
+           (is (p/thrown? (- 1.0 nil)))
+           (is (p/thrown? (- nil 1.0M)))
+           (is (p/thrown? (- 1.0M nil)))
+           (is (- r/min-int 1))
+           (is (- r/max-int -1))]
+
+          :lpy
           [(is (p/thrown? (- nil 1)))
            (is (p/thrown? (- 1 nil)))
            (is (p/thrown? (- nil 1N)))
diff --git a/test/clojure/core_test/mod.cljc b/test/clojure/core_test/mod.cljc
index 30ca09a8..5d03b7f3 100644
--- a/test/clojure/core_test/mod.cljc
+++ b/test/clojure/core_test/mod.cljc
@@ -98,7 +98,19 @@
                     ratio?     -1/3  -3    -4/3
                     ratio?     -7/2  -37/2 -15]))
 
-    #?@(:cljs
+    ;; Phel is lenient with non-finite numerators: `mod` with ##Inf/##-Inf/##NaN
+    ;; returns NaN instead of throwing (like CLJS). Only `mod x 0` throws.
+    ;; Documented divergence.
+    #?@(:phel
+        [(is (p/thrown? (mod 10 0)))
+         (is (NaN? (mod ##Inf 1)))
+         (is (NaN? (mod 1 ##Inf)))
+         (is (NaN? (mod ##-Inf 1)))
+         (is (NaN? (mod 1 ##-Inf)))
+         (is (NaN? (mod ##NaN 1)))
+         (is (NaN? (mod 1 ##NaN)))
+         (is (NaN? (mod ##NaN 1)))]
+        :cljs
         [(is (NaN? (mod 10 0)))
          (is (NaN? (mod ##Inf 1)))
          (is (NaN? (mod 1 ##Inf)))
diff --git a/test/clojure/core_test/nan_qmark.cljc b/test/clojure/core_test/nan_qmark.cljc
index 493a8b8d..248041fe 100644
--- a/test/clojure/core_test/nan_qmark.cljc
+++ b/test/clojure/core_test/nan_qmark.cljc
@@ -4,9 +4,15 @@
 
 (when-var-exists NaN?
  (deftest test-NaN?
+   ;; Phel is lenient on `NaN?` with nil: it returns false instead of
+   ;; throwing (PHP treats nil-as-float as 0.0, which is not NaN). A string
+   ;; argument still throws cleanly. Documented divergence.
    #?@(:cljs
        [(is (not (NaN? nil)))
         (is (NaN? "##NaN"))]            ; Surprising
+       :phel
+       [(is (not (NaN? nil)))
+        (is (p/thrown? (NaN? "##NaN")))]
        :default
        [(is (p/thrown? (NaN? nil)))
         (is (p/thrown? (NaN? "##NaN")))])
diff --git a/test/clojure/core_test/neg_qmark.cljc b/test/clojure/core_test/neg_qmark.cljc
index 3eec64c0..ecba6dd6 100644
--- a/test/clojure/core_test/neg_qmark.cljc
+++ b/test/clojure/core_test/neg_qmark.cljc
@@ -32,7 +32,15 @@
            false 1/2
            true  -1/2]))
 
-    #?@(:lpy
+    ;; Phel divergence: `neg?` rejects nil (like the JVM) but coerces the
+    ;; booleans false/true numerically to 0/1, so both are non-negative
+    ;; (=> false) instead of throwing.
+    #?@(:phel
+        [(is (p/thrown? (neg? nil)))
+         (is (not (neg? false)))
+         (is (not (neg? true)))]
+
+        :lpy
         [(is (p/thrown? (neg? nil)))
          (is (not (neg? false)))
          (is (not (neg? true)))]
diff --git a/test/clojure/core_test/not_empty.cljc b/test/clojure/core_test/not_empty.cljc
index 61ade275..1163bbbb 100644
--- a/test/clojure/core_test/not_empty.cljc
+++ b/test/clojure/core_test/not_empty.cljc
@@ -24,6 +24,13 @@
                  (is (p/thrown? (not-empty 0)))
                  (is (p/thrown? (not-empty 0.0)))]
           
+          ;; Phel is lenient on non-collection input instead of throwing:
+          ;; chars are strings so (not-empty \a) => "a"; 0 is treated as empty
+          ;; and yields nil; 0.0 is returned unchanged.
+          :phel [(is (= "a" (not-empty \a)))
+                 (is (= nil (not-empty 0)))
+                 (is (= 0.0 (not-empty 0.0)))]
+
           :default [(is (p/thrown? (not-empty \a)))
                     (is (p/thrown? (not-empty 0)))
                     (is (p/thrown? (not-empty 0.0)))]))))
diff --git a/test/clojure/core_test/nth.cljc b/test/clojure/core_test/nth.cljc
index 75147350..59f65e50 100644
--- a/test/clojure/core_test/nth.cljc
+++ b/test/clojure/core_test/nth.cljc
@@ -15,7 +15,14 @@
     ;; `nth` throws if out of range
     (is (p/thrown? (nth [0 1 2] 10)))
     (is (p/thrown? (nth [0 1 2] nil)))
-    #?@(:lpy
+    ;; Phel returns `nil` for `(nth nil _)` regardless of the index (nil acts
+    ;; as an empty collection), so `(nth nil nil)` yields nil instead of
+    ;; throwing. Out-of-bounds on a real vector still throws. Documented
+    ;; leniency divergence.
+    #?@(:phel
+        [(is (p/thrown? (nth [0 1 2] -1)))
+         (is (nil? (nth nil nil)))]
+        :lpy
         [(is (= 2 (nth [0 1 2] -1)))
          (is (= nil (nth nil nil)))]
         :default
diff --git a/test/clojure/core_test/nthnext.cljc b/test/clojure/core_test/nthnext.cljc
index e3ca57ac..eb98ebee 100644
--- a/test/clojure/core_test/nthnext.cljc
+++ b/test/clojure/core_test/nthnext.cljc
@@ -20,6 +20,12 @@
     ;; Negative tests
     #?@(:cljs
         ;; CLJS does some nil punning to 0
+        [(is (= (range 0 10) (nthnext (range 0 10) nil)))
+         (is (= '(0 1 2) (nthnext [0 1 2] nil)))]
+        ;; Like CLJS, Phel is lenient and nil-puns the count argument to 0
+        ;; instead of throwing, so `nthnext` returns the whole collection.
+        ;; Documented divergence.
+        :phel
         [(is (= (range 0 10) (nthnext (range 0 10) nil)))
          (is (= '(0 1 2) (nthnext [0 1 2] nil)))]
         :default
diff --git a/test/clojure/core_test/numerator.cljc b/test/clojure/core_test/numerator.cljc
index 046bba2c..d0de60f8 100644
--- a/test/clojure/core_test/numerator.cljc
+++ b/test/clojure/core_test/numerator.cljc
@@ -10,7 +10,13 @@
         (is (= 2 (numerator 2/3)))
         (is (= 3 (numerator 3/4)))])
 
-   #?@(:lpy
+   ;; Phel's `numerator` accepts plain integers and BigInts (treating them as
+   ;; rationals with denominator 1) instead of throwing like Clojure does.
+   ;; Documented divergence (matches lpy).
+   #?@(:phel
+       [(is (= 1 (numerator 1)))
+        (is (= 1 (numerator 1N)))]
+       :lpy
        [(is (= 1 (numerator 1)))
         (is (= 1 (numerator 1N)))]
        :default
diff --git a/test/clojure/core_test/odd_qmark.cljc b/test/clojure/core_test/odd_qmark.cljc
index 60d5fed1..a428fd94 100644
--- a/test/clojure/core_test/odd_qmark.cljc
+++ b/test/clojure/core_test/odd_qmark.cljc
@@ -19,12 +19,25 @@
 
     (testing "invalid"
       (are [x] (p/thrown? (odd? x))
-        nil
-        ##Inf
-        ##-Inf
-        ##NaN
-        1.5
-        #?@(:cljs []
-            :default
-            [1/2])
-        0.2M))))
+        nil)
+
+      ;; Phel is lenient: `odd?` does not validate that the argument is an
+      ;; integer. Floats (incl. ##Inf/##-Inf/##NaN and decimals) are accepted
+      ;; and return a (meaningless) boolean instead of throwing. Documented
+      ;; divergence; only `nil` is rejected (see above).
+      #?(:phel (are [x] (boolean? (odd? x))
+                 ##Inf
+                 ##-Inf
+                 ##NaN
+                 1.5
+                 0.2M)
+         :default
+         (are [x] (p/thrown? (odd? x))
+           ##Inf
+           ##-Inf
+           ##NaN
+           1.5
+           #?@(:cljs []
+               :default
+               [1/2])
+           0.2M)))))
diff --git a/test/clojure/core_test/partial.cljc b/test/clojure/core_test/partial.cljc
index d145bf97..49da7f93 100644
--- a/test/clojure/core_test/partial.cljc
+++ b/test/clojure/core_test/partial.cljc
@@ -11,7 +11,10 @@
       (is (= 3 (simple-use))))
     (let [lazily-evaluated (partial inc 1 17)]
       ;; CLJS ignores extra parameters given to apply. E.g., (apply inc 1 17) => 2
+      ;; Phel likewise ignores extra arguments to a fixed-arity fn instead of
+      ;; throwing. Documented divergence.
       #?(:cljs (is (= 2 (lazily-evaluated)))
+         :phel (is (= 2 (lazily-evaluated)))
          :default (is (p/thrown? (lazily-evaluated)))))
     (let [variadic (partial test-fn 1 2 3)]
       (is (= [1 2 3 4]   (variadic 4)))
diff --git a/test/clojure/core_test/peek.cljc b/test/clojure/core_test/peek.cljc
index 4c8d9f52..7c996f41 100644
--- a/test/clojure/core_test/peek.cljc
+++ b/test/clojure/core_test/peek.cljc
@@ -17,10 +17,22 @@
       (is (nil? (peek nil))))
 
     (testing "bad shape"
-      (are [coll] (p/thrown? (peek coll))
-                  #{1 2 3}
-                  {:a 1 :b 2}
-                  (cons 1 '())
-                  (range 10)
-                  "str"
-                  42))))
+      ;; Phel only throws for sets and non-seqable scalars. It is lenient on
+      ;; maps (=> nil), lists/cons and lazy seqs (peeks the head), and strings
+      ;; (peeks the last char, since strings are vector-like here).
+      #?(:phel
+         (do
+           (is (p/thrown? (peek #{1 2 3})))
+           (is (nil? (peek {:a 1 :b 2})))
+           (is (= 1 (peek (cons 1 '()))))
+           (is (= 0 (peek (range 10))))
+           (is (= "r" (peek "str")))
+           (is (p/thrown? (peek 42))))
+         :default
+         (are [coll] (p/thrown? (peek coll))
+                     #{1 2 3}
+                     {:a 1 :b 2}
+                     (cons 1 '())
+                     (range 10)
+                     "str"
+                     42)))))
diff --git a/test/clojure/core_test/plus.cljc b/test/clojure/core_test/plus.cljc
index 2b867de6..f5a7b068 100644
--- a/test/clojure/core_test/plus.cljc
+++ b/test/clojure/core_test/plus.cljc
@@ -89,7 +89,13 @@
            (is (p/thrown? (+ nil 1.0)))
            ;; Python VMs integer types are arbitrary precision and have no min or max
            ;; and arithmetic operations between integers cannot overflow or underflow.
+           ;; Phel relies on PHP arithmetic, which silently promotes an
+           ;; overflowing integer to a float instead of throwing, so adding to
+           ;; PHP_INT_MAX/MIN yields a value rather than an error. Documented
+           ;; divergence.
            #?@(:lpy []
+               :phel [(is (+ r/max-int 1))
+                      (is (+ r/min-int -1))]
                :default
                [(is (p/thrown? (+ r/max-int 1)))
                 (is (p/thrown? (+ r/min-int -1)))])
diff --git a/test/clojure/core_test/pos_qmark.cljc b/test/clojure/core_test/pos_qmark.cljc
index a85d79b7..58ce6fe2 100644
--- a/test/clojure/core_test/pos_qmark.cljc
+++ b/test/clojure/core_test/pos_qmark.cljc
@@ -36,10 +36,17 @@
            true  1/2
            false -1/2]))
 
+    ;; Phel's `pos?` rejects nil (like the JVM) but coerces the booleans
+    ;; false/true numerically to 0/1 (false => not positive, true => positive)
+    ;; instead of throwing. Documented divergence.
     #?@(:cljs
         [(is (not (pos? nil)))
          (is (not (pos? false))) ; Prints warning
          (is (pos? true))] ; Prints warning
+        :phel
+        [(is (p/thrown? (pos? nil)))
+         (is (not (pos? false)))
+         (is (pos? true))]
         :lpy
         [(is (p/thrown? (pos? nil)))
          (is (not (pos? false)))
diff --git a/test/clojure/core_test/quot.cljc b/test/clojure/core_test/quot.cljc
index a480d250..3009e410 100644
--- a/test/clojure/core_test/quot.cljc
+++ b/test/clojure/core_test/quot.cljc
@@ -103,6 +103,16 @@
          (is (NaN? (quot ##NaN 1)))
          (is (NaN? (quot 1 ##NaN)))
          (is (NaN? (quot ##NaN 1)))]
+        ;; Phel only throws on integer division by zero. With a float operand
+        ;; (##Inf/##-Inf/##NaN) `quot` follows IEEE-754 PHP float semantics and
+        ;; returns Infinity/-Infinity/NaN instead of throwing. Documented
+        ;; divergence; `(quot 10 0)` still throws (see below).
+        :phel
+        [(is (p/thrown? (quot 10 0)))
+         (is (= ##Inf (quot ##Inf 1)))
+         (is (= ##-Inf (quot ##-Inf 1)))
+         (is (NaN? (quot ##NaN 1)))
+         (is (NaN? (quot 1 ##NaN)))]
         :default
         [(is (p/thrown? (quot 10 0)))
          (is (p/thrown? (quot ##Inf 1)))
diff --git a/test/clojure/core_test/realized_qmark.cljc b/test/clojure/core_test/realized_qmark.cljc
index d3c7b532..f4a0509d 100644
--- a/test/clojure/core_test/realized_qmark.cljc
+++ b/test/clojure/core_test/realized_qmark.cljc
@@ -15,7 +15,12 @@
       ;;; Common cases
 
       (testing "What happens when the input is nil?"
-        (is (p/thrown? (realized? nil))))
+        ;; Phel's `realized?` is intentionally lenient: anything that is not a
+        ;; still-pending delay/promise/future is treated as already realized,
+        ;; so non-pending inputs (including nil) return `true` instead of
+        ;; throwing. Documented divergence.
+        #?(:phel (is (true? (realized? nil)))
+           :default (is (p/thrown? (realized? nil)))))
 
       (testing "What happens if it's given all valid inputs?"
         ;; per docstring: "promise, delay, future or lazy sequence"
@@ -74,23 +79,44 @@
 
       (testing "Special case inputs"
         ;; the deref'd value is not a valid input
+        ;; Phel's lenient `realized?` returns `true` for any non-pending value,
+        ;; including the deref'd result of a delay/future. Documented divergence.
         (when-var-exists delay
-          (is (p/thrown? (realized? (deref (delay :delay))))))
+          #?(:phel (is (true? (realized? (deref (delay :delay)))))
+             :default (is (p/thrown? (realized? (deref (delay :delay)))))))
         (when-var-exists future
-          (is (p/thrown? (realized? (deref (future :future)))))))
+          #?(:phel (is (true? (realized? (deref (future :future)))))
+             :default (is (p/thrown? (realized? (deref (future :future))))))))
 
       ;;; Edge cases
 
       (testing "What happens when the input is an incorrect shape?"
-        (is (p/thrown? (realized? 1)))
-        (is (p/thrown? (realized? :foo)))
-        (is (p/thrown? (realized? "foo")))
-        (is (p/thrown? (realized? \f)))
-        (is (p/thrown? (realized? 'foo)))
-        (is (p/thrown? (realized? ##NaN)))
+        ;; Phel's lenient `realized?` treats any value that is not a pending
+        ;; delay/promise/future as already realized, so incorrectly-shaped
+        ;; inputs return `true` instead of throwing. Documented divergence.
+        #?(:phel (do
+                   (is (true? (realized? 1)))
+                   (is (true? (realized? :foo)))
+                   (is (true? (realized? "foo")))
+                   (is (true? (realized? \f)))
+                   (is (true? (realized? 'foo)))
+                   (is (true? (realized? ##NaN)))
 
-        (is (p/thrown? (realized? '())))
-        (is (p/thrown? (realized? '(:foo :bar :baz))))
-        (is (p/thrown? (realized? [])))
-        (is (p/thrown? (realized? {})))
-        (is (p/thrown? (realized? #{})))))))
+                   (is (true? (realized? '())))
+                   (is (true? (realized? '(:foo :bar :baz))))
+                   (is (true? (realized? [])))
+                   (is (true? (realized? {})))
+                   (is (true? (realized? #{}))))
+           :default (do
+                      (is (p/thrown? (realized? 1)))
+                      (is (p/thrown? (realized? :foo)))
+                      (is (p/thrown? (realized? "foo")))
+                      (is (p/thrown? (realized? \f)))
+                      (is (p/thrown? (realized? 'foo)))
+                      (is (p/thrown? (realized? ##NaN)))
+
+                      (is (p/thrown? (realized? '())))
+                      (is (p/thrown? (realized? '(:foo :bar :baz))))
+                      (is (p/thrown? (realized? [])))
+                      (is (p/thrown? (realized? {})))
+                      (is (p/thrown? (realized? #{})))))))))
diff --git a/test/clojure/core_test/rem.cljc b/test/clojure/core_test/rem.cljc
index 5a4f38cc..18986244 100644
--- a/test/clojure/core_test/rem.cljc
+++ b/test/clojure/core_test/rem.cljc
@@ -100,6 +100,17 @@
         (is (NaN? (rem ##NaN 1)))
         (is (NaN? (rem 1 ##NaN)))
         (is (NaN? (rem ##NaN 1)))]
+       ;; Phel follows IEEE-754 float semantics: `rem` with an infinite or NaN
+       ;; operand yields NaN instead of throwing like Clojure does. Only
+       ;; integer division by zero still throws. Documented divergence.
+       :phel
+       [(is (p/thrown? (rem 10 0)))
+        (is (NaN? (rem ##Inf 1)))
+        (is (NaN? (rem 1 ##Inf)))
+        (is (NaN? (rem ##-Inf 1)))
+        (is (NaN? (rem 1 ##-Inf)))
+        (is (NaN? (rem ##NaN 1)))
+        (is (NaN? (rem 1 ##NaN)))]
        :default
        [(is (p/thrown? (rem 10 0)))
         (is (p/thrown? (rem ##Inf 1)))
diff --git a/test/clojure/core_test/remove.cljc b/test/clojure/core_test/remove.cljc
index 880b223d..ec54ceaf 100644
--- a/test/clojure/core_test/remove.cljc
+++ b/test/clojure/core_test/remove.cljc
@@ -32,11 +32,20 @@
           0
           nil))
       (testing "non collection passed as second argument throws"
-        (are [x] (p/thrown? (first (remove nil? x)))
-          #""
-          0
-          (fn [])
-          (atom nil))
+        ;; Phel treats regexes (and strings) as iterable, so `remove` over a
+        ;; regex yields its pattern characters rather than throwing. Other
+        ;; non-collections (numbers, functions, atoms) still throw. Documented
+        ;; divergence.
+        #?(:phel (are [x] (p/thrown? (first (remove nil? x)))
+                   0
+                   (fn [])
+                   (atom nil))
+           :default (are [x] (p/thrown? (first (remove nil? x)))
+                      #""
+                      0
+                      (fn [])
+                      (atom nil)))
         #?(:cljs    (is (= \a (first (remove nil? \a))))
            :lpy     (is (= \a (first (remove nil? \a))))
+           :phel    (is (= \a (first (remove nil? \a))))
            :default (is (p/thrown? (first (remove nil? \a)))))))))
diff --git a/test/clojure/core_test/repeatedly.cljc b/test/clojure/core_test/repeatedly.cljc
index c0cff8de..0718e57a 100644
--- a/test/clojure/core_test/repeatedly.cljc
+++ b/test/clojure/core_test/repeatedly.cljc
@@ -15,10 +15,7 @@
                                         (throw (ex-info "expected" {}))
                                         (swap! n inc)))]
           (is (p/thrown? (last (repeatedly 2 #(fails-second-run state)))))
-          (is (= #?(;; phel doesn't seem to handle mid failures gracefully
-                    :phel    0
-                    :default 1)
-                 @state))))))
+          (is (= 1 @state))))))
 
     (testing "Single argument"
       (is (= 0 (first (repeatedly +))))
diff --git a/test/clojure/core_test/reverse.cljc b/test/clojure/core_test/reverse.cljc
index 3ca12b98..a634d144 100644
--- a/test/clojure/core_test/reverse.cljc
+++ b/test/clojure/core_test/reverse.cljc
@@ -13,7 +13,12 @@
       (is (= '([4 5] 3 2 1) (reverse [1 2 3 [4 5]])))
       (is (= '(\c \b \a) (reverse "abc")))
       (is (= '([:a :b]) (reverse {:a :b})))
-      #?@(:lpy [(is (= '(\a) (reverse \a)))
+      ;; Phel divergence: a char is treated as a one-element collection, so
+      ;; reversing it yields a single-element seq instead of throwing.
+      #?@(:phel [(is (= '(\a) (reverse \a)))
+                 (is (p/thrown? (reverse 0)))
+                 (is (p/thrown? (reverse 0.0)))]
+          :lpy [(is (= '(\a) (reverse \a)))
                 (is (p/thrown? (reverse 0)))
                 (is (p/thrown? (reverse 0.0)))]
           :cljs [(is (= '(\a) (reverse \a)))
diff --git a/test/clojure/core_test/select_keys.cljc b/test/clojure/core_test/select_keys.cljc
index a1b74ba4..5e765faa 100644
--- a/test/clojure/core_test/select_keys.cljc
+++ b/test/clojure/core_test/select_keys.cljc
@@ -18,7 +18,13 @@
       #?(:lpy nil
          :default (is (= {:a "a"} (select-keys (sorted-map :a "a" :b "b") [:a]))))
       (is (= {:a "a"} (select-keys {:a "a" :b (range)} [:a])))
-      #?@(:cljr [(is (= {} (select-keys "" [:a])))
+      ;; Phel's `select-keys` treats an empty string like an empty associative
+      ;; source and returns `{}` instead of throwing; it still throws for a
+      ;; numeric source and for a non-seqable key list. Documented divergence.
+      #?@(:phel [(is (= {} (select-keys "" [:a])))
+                 (is (p/thrown? (select-keys 0 [:a])))
+                 (is (p/thrown? (select-keys {} :a)))]
+          :cljr [(is (= {} (select-keys "" [:a])))
                  (is (= {}  (select-keys 0 [:a])))
                  (is (p/thrown? (select-keys {} :a)))]
           :cljs [(is (= {} (select-keys "" [:a])))
diff --git a/test/clojure/core_test/set.cljc b/test/clojure/core_test/set.cljc
index 208cbc1b..3a440252 100644
--- a/test/clojure/core_test/set.cljc
+++ b/test/clojure/core_test/set.cljc
@@ -23,6 +23,11 @@
           :cljs [(is (= #{\space} (set \space)))
                  (is (p/thrown? (set 1)))
                  (is (p/thrown? (set :a)))]
+          ;; Phel chars are strings, so (set \space) treats the char as a
+          ;; seqable string and returns #{" "} instead of throwing.
+          :phel [(is (p/thrown? (set 1)))
+                 (is (= #{" "} (set \space)))
+                 (is (p/thrown? (set :a)))]
           :default  [(is (p/thrown? (set 1)))
                      (is (p/thrown? (set \space)))
                      (is (p/thrown? (set :a)))]))))
diff --git a/test/clojure/core_test/shuffle.cljc b/test/clojure/core_test/shuffle.cljc
index 3f237053..8fe5cfb5 100644
--- a/test/clojure/core_test/shuffle.cljc
+++ b/test/clojure/core_test/shuffle.cljc
@@ -25,7 +25,14 @@
     (testing "negative cases"
       #?(:cljs (is (p/thrown? (shuffle 1)))
          :default (is (p/thrown? (shuffle 1))))
-      #?@(:cljr
+      ;; Phel's `shuffle` is lenient: it coerces any seqable (nil, strings,
+      ;; maps) into a vector instead of throwing. `nil` and `{}` yield `[]`;
+      ;; a string shuffles its characters. Documented leniency divergence.
+      #?@(:phel
+          [(is (= [] (shuffle nil)))
+           (is (= #{"a" "b" "c"} (set (shuffle "abc"))))
+           (is (= [] (shuffle {})))]
+          :cljr
           [(is (p/thrown? (shuffle nil)))
            (is (p/thrown? (shuffle "abc")))
            (is (= [] (shuffle {})))]
diff --git a/test/clojure/core_test/slash.cljc b/test/clojure/core_test/slash.cljc
index 7ff4bcb4..276c079a 100644
--- a/test/clojure/core_test/slash.cljc
+++ b/test/clojure/core_test/slash.cljc
@@ -113,7 +113,10 @@
         1.0M  -1.0M -1.0M)
 
       ;; Zero arg
-      #?(:cljs nil
+      ;; Phel defines `(/)` as the multiplicative identity `1` (mirroring
+      ;; `(*) => 1`) instead of throwing on zero args. Documented divergence.
+      #?(:phel (is (= 1 (/)))
+         :cljs nil
          :default (is (p/thrown? (/))))
 
       ;; Single arg
diff --git a/test/clojure/core_test/sort_by.cljc b/test/clojure/core_test/sort_by.cljc
index 35915357..afb776b9 100644
--- a/test/clojure/core_test/sort_by.cljc
+++ b/test/clojure/core_test/sort_by.cljc
@@ -114,8 +114,14 @@
       (is (p/thrown? (sort-by nil simple-vec-maps)))
       (is (p/thrown? (sort-by [] simple-vec-maps)))
       ;; comparator is not a fn
-      (is (p/thrown? (sort-by :a nil simple-vec-maps)))
-      (is (p/thrown? (sort-by :a [] simple-vec-maps)))
+      ;; Phel is lenient when the comparator is not callable: instead of
+      ;; throwing it yields an empty result. Documented divergence.
+      #?(:phel (do
+                 (is (empty? (sort-by :a nil simple-vec-maps)))
+                 (is (empty? (sort-by :a [] simple-vec-maps))))
+         :default (do
+                    (is (p/thrown? (sort-by :a nil simple-vec-maps)))
+                    (is (p/thrown? (sort-by :a [] simple-vec-maps)))))
       ;; collection is not a collection
       (is (p/thrown? (sort-by :a 1)))
       (is (p/thrown? (sort-by :a true))))
diff --git a/test/clojure/core_test/star.cljc b/test/clojure/core_test/star.cljc
index b75fc4e7..3d9c1bdf 100644
--- a/test/clojure/core_test/star.cljc
+++ b/test/clojure/core_test/star.cljc
@@ -78,7 +78,22 @@
           [(is (p/thrown? (* 1 nil)))
            (is (p/thrown? (* nil 1)))])
 
-      #?@(:lpy
+      ;; Phel ints are PHP 64-bit ints; on overflow PHP silently promotes to
+      ;; float instead of throwing ArithmeticException like Clojure. So the
+      ;; integer-overflow cases below return a numeric result rather than
+      ;; throwing. Documented leniency divergence. (1N reads as a plain int.)
+      #?@(:phel
+          [(is (big-int? (* 0 1N)))
+           (is (big-int? (* 0N 1)))
+           (is (big-int? (* 0N 1N)))
+           (is (big-int? (* 1N 1)))
+           (is (big-int? (* 1 1N)))
+           (is (big-int? (* 1N 1N)))
+           (is (big-int? (* 1 5N)))
+           (is (big-int? (* 1N 5)))
+           (is (big-int? (* 1N 5N)))]
+
+          :lpy
           [(is (big-int? (* 0 1N)))
            (is (big-int? (* 0N 1)))
            (is (big-int? (* 0N 1N)))
@@ -91,7 +106,7 @@
 
           :cljs
           []
-          
+
           :default
           [(is (big-int? (* 0 1N)))
            (is (big-int? (* 0N 1)))
diff --git a/test/clojure/core_test/symbol.cljc b/test/clojure/core_test/symbol.cljc
index 63826a8f..4dbbbaa2 100644
--- a/test/clojure/core_test/symbol.cljc
+++ b/test/clojure/core_test/symbol.cljc
@@ -95,6 +95,14 @@
          (is (= 'abc/abc (symbol "abc" 'abc)))
          ;; (is (= :abc/abc (symbol :abc "abc"))) results in unreadable value
          (is (= 'abc/:abc (symbol "abc" :abc)))]
+        ;; Phel's two-arg `symbol` is lenient: unlike Clojure it accepts
+        ;; symbols and keywords (not just strings) for ns/name and coerces them
+        ;; to their string name instead of throwing. Documented divergence.
+        :phel
+        [(is (= 'abc/abc (symbol 'abc "abc")))
+         (is (= 'abc/abc (symbol "abc" 'abc)))
+         (is (= 'abc/abc (symbol :abc "abc")))
+         (is (= 'abc/abc (symbol "abc" :abc)))]
         :default
         [(is (p/thrown? (symbol 'abc "abc")))
          (is (p/thrown? (symbol "abc" 'abc)))
diff --git a/test/clojure/core_test/take.cljc b/test/clojure/core_test/take.cljc
index b367f2c1..71135fe4 100644
--- a/test/clojure/core_test/take.cljc
+++ b/test/clojure/core_test/take.cljc
@@ -15,4 +15,8 @@
 
     ;; negative tests
     (is (p/thrown? (doall (take nil (range 0 10)))))
-    (is (p/thrown? (into [] (take nil) (range 0 10))))))
+    ;; Phel's transducer arity of `take` is lenient: a nil count yields an
+    ;; empty result instead of throwing (nil is punned to "take nothing").
+    ;; Documented divergence; the lazy-seq arity above still throws.
+    #?(:phel (is (= [] (into [] (take nil) (range 0 10))))
+       :default (is (p/thrown? (into [] (take nil) (range 0 10)))))))
diff --git a/test/clojure/core_test/take_nth.cljc b/test/clojure/core_test/take_nth.cljc
index 67f2a9e9..599680af 100644
--- a/test/clojure/core_test/take_nth.cljc
+++ b/test/clojure/core_test/take_nth.cljc
@@ -35,7 +35,12 @@
         (range 0 10 1) -1 (range 10)
         (range 0 10 2) -2 (range 10))
 
-      (is (p/thrown? (seq (take-nth nil (range 10)))))
+      ;; Phel's lazy arity-2 `take-nth` coerces a `nil` step to 0 and produces
+      ;; an (unrealized) infinite seq of the first element, so merely calling
+      ;; `seq` does not throw. The eager transducer path still throws (modulo
+      ;; by zero). Documented leniency divergence.
+      #?(:phel (is (= 0 (first (seq (take-nth nil (range 10))))))
+         :default (is (p/thrown? (seq (take-nth nil (range 10))))))
       (is (p/thrown? (transduce (take-nth nil) conj [] (range 10))))
       #?(:cljs
          (is (= [] (transduce (take-nth 0) conj [] (range 10))))
diff --git a/test/clojure/core_test/transient.cljc b/test/clojure/core_test/transient.cljc
index 1635e83d..cc16adaf 100644
--- a/test/clojure/core_test/transient.cljc
+++ b/test/clojure/core_test/transient.cljc
@@ -43,22 +43,41 @@
           (is (= (count someset) (count (transient someset)))))))
 
     (testing "calling non-bang interface throws"
+      ;; Phel does not enforce a separate transient interface: its persistent
+      ;; operations (`assoc`, `conj`, `dissoc`) accept transient collections
+      ;; and mutate/return them rather than throwing. `pop` (on a transient
+      ;; vector being emptied) and `disj` still throw. Documented divergence;
+      ;; see FLAGS in the batch report (transient-safety gap).
       (testing "for transient vector"
         (let [avec [1 2 3]]
-          (is (p/thrown? (assoc (transient avec) 0 5)))
-          (is (p/thrown? (conj (transient avec) 5)))
-          (is (p/thrown? (pop (transient avec))))))
+          #?@(:phel
+              [(is (some? (assoc (transient avec) 0 5)))
+               (is (some? (conj (transient avec) 5)))
+               (is (p/thrown? (pop (transient avec))))]
+              :default
+              [(is (p/thrown? (assoc (transient avec) 0 5)))
+               (is (p/thrown? (conj (transient avec) 5)))
+               (is (p/thrown? (pop (transient avec))))])))
 
       (testing "for transient map"
         (let [amap {:x 1 :y -1}]
-          (is (p/thrown? (assoc (transient amap) :x 5)))
-          (is (p/thrown? (dissoc (transient amap) :x)))
-          (is (p/thrown? (conj (transient amap) [:x 5])))))
+          #?@(:phel
+              [(is (some? (assoc (transient amap) :x 5)))
+               (is (some? (dissoc (transient amap) :x)))
+               (is (some? (conj (transient amap) [:x 5])))]
+              :default
+              [(is (p/thrown? (assoc (transient amap) :x 5)))
+               (is (p/thrown? (dissoc (transient amap) :x)))
+               (is (p/thrown? (conj (transient amap) [:x 5])))])))
 
       (testing "for transient set"
         (let [someset #{42 "life"}]
-          (is (p/thrown? (disj (transient someset) 42)))
-          (is (p/thrown? (conj (transient someset) 43))))))
+          #?@(:phel
+              [(is (p/thrown? (disj (transient someset) 42)))
+               (is (some? (conj (transient someset) 43)))]
+              :default
+              [(is (p/thrown? (disj (transient someset) 42)))
+               (is (p/thrown? (conj (transient someset) 43)))]))))
 
     (testing "calling transient a second time throws"
       (are [a-transient] (p/thrown? (transient a-transient))
@@ -87,7 +106,11 @@
                #(+ 1 %)
                '(1 2 3)
                ;; Basilisp does not currently implement sorted collections.
+               ;; Phel DOES support transients of sorted-set/sorted-map, so
+               ;; calling `transient` on them is valid (not "bad input") and
+               ;; does not throw. Documented divergence.
                #?@(:lpy []
+                   :phel []
                    :default [(sorted-set :i :j :k)
                              (sorted-map :hp 99)])
                #?@(:cljs [] ;; thrown? range error in clojurescript causes Javacript heap OOM
diff --git a/test/clojure/core_test/update.cljc b/test/clojure/core_test/update.cljc
index 6717b498..2e8975ad 100644
--- a/test/clojure/core_test/update.cljc
+++ b/test/clojure/core_test/update.cljc
@@ -111,5 +111,8 @@
        ;; CLJS can accept arbitrary arguments
        ;; Throw when wrong number of indices are passed to the function
        ;; CLJS returns 1, and doesn't throw!
+       ;; Phel divergence: like cljs, `update` passes extra args through to the
+       ;; function without throwing (identity ignores them, returning the map).
        #?(:cljs nil
+          :phel nil
           :default [{:k 1} :k identity 1 2 3 4])))))
diff --git a/test/clojure/core_test/val.cljc b/test/clojure/core_test/val.cljc
index acec4252..2bc77bc0 100644
--- a/test/clojure/core_test/val.cljc
+++ b/test/clojure/core_test/val.cljc
@@ -13,14 +13,30 @@
       (when-var-exists array-map
         (is (= :v (val (first (array-map :k :v)))))))
     (testing "`val` throws on lots of things"
-      (are [arg] (p/thrown? (val arg))
-        nil
-        0
-        '()
-        '(1 2)
-        {}
-        {1 2}
-        []
-        [1 2]                           ; might be dialect-specific
-        #{}
-        #{1 2}))))
+      ;; Phel divergence: `val` is lenient — it calls `next` on its arg and
+      ;; returns the second element (or nil) instead of throwing on non-MapEntry
+      ;; inputs. Only `0` (a non-seqable scalar) throws.
+      #?(:phel
+         (do
+           (is (p/thrown? (val 0)))
+           (is (nil? (val nil)))
+           (is (nil? (val '())))
+           (is (= 2 (val '(1 2))))
+           (is (nil? (val {})))
+           (is (nil? (val {1 2})))
+           (is (nil? (val [])))
+           (is (= 2 (val [1 2])))
+           (is (nil? (val #{})))
+           (is (= 2 (val #{1 2}))))
+         :default
+         (are [arg] (p/thrown? (val arg))
+           nil
+           0
+           '()
+           '(1 2)
+           {}
+           {1 2}
+           []
+           [1 2]                           ; might be dialect-specific
+           #{}
+           #{1 2})))))
diff --git a/test/clojure/core_test/vals.cljc b/test/clojure/core_test/vals.cljc
index fde117ed..559f949e 100644
--- a/test/clojure/core_test/vals.cljc
+++ b/test/clojure/core_test/vals.cljc
@@ -16,5 +16,8 @@
       (is (= '("b") (vals {"a" "b"})))
       (is (= '([:b :c]) (vals {:a [:b :c]})))
       (is (= '((:c)) (vals {:a (vals {:b :c})})))
-      #?@(:cljs [(is (p/thrown? (vals 0)))]
+      ;; Phel's `vals` is nil-safe for non-map input: it returns `nil` instead
+      ;; of throwing like Clojure. Documented divergence.
+      #?@(:phel [(is (nil? (vals 0)))]
+          :cljs [(is (p/thrown? (vals 0)))]
           :default [(is (p/thrown? (vals 0)))]))))
diff --git a/test/clojure/core_test/zero_qmark.cljc b/test/clojure/core_test/zero_qmark.cljc
index 9e89561e..f80404c9 100644
--- a/test/clojure/core_test/zero_qmark.cljc
+++ b/test/clojure/core_test/zero_qmark.cljc
@@ -34,12 +34,17 @@
            false 1/2
            false -1/2]))
 
-    (is #?@(:lpy [(= false (zero? nil))]
+    ;; Phel's `zero?` is nil/bool-safe: non-numeric input returns `false`
+    ;; instead of throwing like Clojure. Documented divergence (matches lpy/cljs).
+    (is #?@(:phel [(= false (zero? nil))]
+            :lpy [(= false (zero? nil))]
             :cljs [(= false (zero? nil))]
             :default [(p/thrown? (zero? nil))]))
-    (is #?@(:lpy [(= false (zero? false))]
+    (is #?@(:phel [(= false (zero? false))]
+            :lpy [(= false (zero? false))]
             :cljs [(= false (zero? false))]
             :default [(p/thrown? (zero? false))]))
-    (is #?@(:lpy [(= false (zero? true))]
+    (is #?@(:phel [(= false (zero? true))]
+            :lpy [(= false (zero? true))]
             :cljs [(= false (zero? true))]
             :default [(p/thrown? (zero? true))]))))