mod: Ext 15 — disjunctive (:any) conditions, 333/333

(:any (list c1 c2 ...)) compiles to Prolog disjunction (g1 ; g2 ; ...), completing
the condition boolean algebra (AND via :when list, :not, :any). cond->goal
recurses so combinators nest arbitrarily; the proof tree shows the compiled
disjunction verbatim. Maps onto Prolog's control constructs rather than
reimplementing boolean logic in SX. +10 tests.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

lib/mod/policy.sx

@@ -1,10 +1,13 @@
 ;; lib/mod/policy.sx — moderation rules → Prolog clauses.
 ;;
 ;; A rule is {:name :action :when}. :when is a list of condition forms; each
-;; compiles to a Prolog goal. Rule order is precedence: the engine queries with
-;; pl-query-one, so the first clause that proves wins. The final default rule has
-;; an empty body (true) so every report yields at least :keep — "no rule matched"
-;; is a real result, not a query failure.
+;; compiles to a Prolog goal. The conditions in a :when list are ANDed (joined by
+;; ", "); :not negates and :any (a list of sub-conditions) disjoins — so the
+;; condition language is a small boolean algebra over the leaf predicates.
+;; Rule order is precedence: the engine queries with pl-query-one, so the first
+;; clause that proves wins. The final default rule has an empty body (true) so
+;; every report yields at least :keep — "no rule matched" is a real result, not a
+;; query failure.
 ;;
 ;; cond->goal takes an id-term so the same condition can be compiled with the
 ;; head variable "Id" (for clause bodies) or a concrete report id (for proof-tree
@@ -43,14 +46,14 @@
 ;; (:classification "spam")  → classification(Id, spam)
 ;; (:evidence "kind")        → evidence(Id, 'kind', _)
 ;; (:attr "verified")        → attr(Id, verified)
-;; (:not <cond>)             → not(<cond>)        (negation as failure)
+;; (:not <cond>)             → not(<cond>)                        (negation)
+;; (:any (list c1 c2 ...))   → (g1 ; g2 ; ...)                    (disjunction)
 ;; (:count-at-least 3)       → report(Id, B, S), report_count(S, N), N >= 3
 ;; (:score-at-least 5)       → aggregate_all(sum(W), signal(Id, _, W), T), T >= 5
 ;; (:reporters-at-least 2)   → report(Id, _, Sr), setof(Br, report(_, Br, Sr), Bsr),
-;;                             length(Bsr, Nr), Nr >= 2   (distinct reporters;
-;;                             needs the quorum engine which asserts every report)
+;;                             length(Bsr, Nr), Nr >= 2   (quorum engine)
 ;; (:burst-at-least 3)       → report(Id, _, Sb), burst_count(Sb, Nb), Nb >= 3
-;;                             (reports in a time window; needs the temporal engine)
+;;                             (temporal engine)
 
 (define
   mod/cond->goal
@@ -71,6 +74,15 @@
         ((= tag :attr) (str "attr(" idterm ", " (nth c 1) ")"))
         ((= tag :not)
           (str "not(" (mod/cond->goal (nth c 1) idterm) ")"))
+        ((= tag :any)
+          (str
+            "("
+            (mod/join-with
+              " ; "
+              (map
+                (fn (sub) (mod/cond->goal sub idterm))
+                (nth c 1)))
+            ")"))
         ((= tag :count-at-least)
           (str
             "report("