host-persist: content-addressed blob adapter — Blocker CLOSED

blob/put|get|has? backed by <root>/blobs/<cid>, CIDv1 (raw codec,
sha2-256 via Sx_cid/Sx_sha2). put idempotent; persist stores only the
{:cid :size :mime} ref. persist_durable_test.sh extended (8/8): blob
round-trip + content-address idempotency + bytes/ref surviving real
restart. Mock blob suite 14/0 on worktree binary. Durable-storage
Blocker now CLOSED.

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

hosts/ocaml/bin/sx_server.ml

@@ -571,9 +571,12 @@ and cek_run_with_io state =
           Hashtbl.replace d "descent" (Number desc);
           Dict d
         | _ ->
-          let args = let a = Sx_runtime.get_val request (String "args") in
+          let argsv = Sx_runtime.get_val request (String "args") in
-            (match a with List l -> l | _ -> [a]) in
+          (match Sx_persist_store.handle_op op argsv with
-          io_request op args
+           | Some resp -> resp
+           | None ->
+             let args = (match argsv with List l -> l | _ -> [argsv]) in
+             io_request op args)
       in
       s := Sx_ref.cek_resume !s response;
       loop ()
@@ -1540,7 +1543,12 @@ let rec dispatch env cmd =
                | Some path -> load_library_file path | None -> ());
               Nil
             end
-          end else Nil (* non-import IO: resume with nil *) in
+          end else
+            (* durable-storage ops: service against on-disk store *)
+            let args = Sx_runtime.get_val request (String "args") in
+            (match Sx_persist_store.handle_op op args with
+             | Some resp -> resp
+             | None -> Nil (* non-import IO: resume with nil *)) in
           s := Sx_ref.cek_resume !s response
         done;
         Sx_ref.cek_value !s
@@ -3893,7 +3901,10 @@ let http_mode port =
       Dict d
     | "io-sleep" | "sleep" -> Nil
     | "import" -> Nil
-    | _ -> Nil);
+    | _ ->
+      (match Sx_persist_store.handle_op op args with
+       | Some resp -> resp
+       | None -> Nil));
   (* Response cache — path → full HTTP response string.
      Populated during pre-warm, serves cached responses in <0.1ms.
      Thread-safe: reads are lock-free (Hashtbl.find_opt is atomic for

hosts/ocaml/lib/sx_persist_store.ml

@@ -0,0 +1,293 @@
+(* sx_persist_store — host durable-storage adapter for lib/persist.
+   Production twin of `persist/serve` (lib/persist/durable.sx): it answers the
+   same `persist/...` IO ops, but backs them with real on-disk storage so writes
+   survive a process restart. Stateless-on-disk: every op reads/writes the
+   filesystem directly, so a fresh process recovers state with no warm-up — the
+   log on disk IS the state.
+
+   On-disk layout under the root dir (default ./persist-data, or $SX_PERSIST_DIR):
+     streams/<hex(stream)>.log   append-only, one SX-serialized event per line
+     streams/<hex(stream)>.seq   per-stream monotonic high-water counter (int)
+     kv/<hex(key)>               one SX-serialized value per key
+
+   Invariants honoured (see plans/persist-on-sx.md Blocker spec):
+   1. last-seq is a per-stream monotonic counter stored in .seq, SEPARATE from
+      the rows — it keeps climbing across truncate, so a compacted stream never
+      reassigns a seq.
+   2. append never renumbers — the event already carries its :seq (log.sx does
+      last-seq+1); the host only bumps the high-water mark to max(hw, seq).
+   3. read returns surviving events in append order with :seq intact.
+   4. streams is the set of streams that ever had an append — keyed off the .seq
+      file, which truncate never deletes, so it survives full compaction.
+   5. values round-trip structurally via the SX serializer/parser. *)
+
+open Sx_types
+
+(* ---- root dir ---------------------------------------------------------- *)
+
+let _root : string option ref = ref None
+
+let set_root dir = _root := Some dir
+
+let root_dir () =
+  match !_root with
+  | Some d -> d
+  | None -> (try Sys.getenv "SX_PERSIST_DIR" with Not_found -> "persist-data")
+
+(* ---- filesystem helpers ------------------------------------------------ *)
+
+let rec ensure_dir dir =
+  if dir = "" || dir = "." || dir = "/" || Sys.file_exists dir then ()
+  else begin
+    ensure_dir (Filename.dirname dir);
+    (try Unix.mkdir dir 0o755 with Unix.Unix_error (Unix.EEXIST, _, _) -> ())
+  end
+
+let streams_dir () = Filename.concat (root_dir ()) "streams"
+let kv_dir () = Filename.concat (root_dir ()) "kv"
+let blobs_dir () = Filename.concat (root_dir ()) "blobs"
+
+let read_file path =
+  let ic = open_in_bin path in
+  let n = in_channel_length ic in
+  let s = really_input_string ic n in
+  close_in ic;
+  s
+
+(* Atomic write: temp file in the same dir then rename over the target. *)
+let write_file_atomic path contents =
+  ensure_dir (Filename.dirname path);
+  let tmp = path ^ ".tmp" in
+  let oc = open_out_bin tmp in
+  output_string oc contents;
+  flush oc;
+  close_out oc;
+  Sys.rename tmp path
+
+let append_line path line =
+  ensure_dir (Filename.dirname path);
+  let oc = open_out_gen [Open_append; Open_creat; Open_wronly] 0o644 path in
+  output_string oc line;
+  output_char oc '\n';
+  close_out oc
+
+(* ---- name <-> filename (hex, reversible, fs-safe) ---------------------- *)
+
+let hex_encode s =
+  let b = Buffer.create (String.length s * 2) in
+  String.iter (fun c -> Buffer.add_string b (Printf.sprintf "%02x" (Char.code c))) s;
+  Buffer.contents b
+
+let hex_decode s =
+  let n = String.length s / 2 in
+  String.init n (fun i -> Char.chr (int_of_string ("0x" ^ String.sub s (i * 2) 2)))
+
+let stream_log stream = Filename.concat (streams_dir ()) (hex_encode stream ^ ".log")
+let stream_seq stream = Filename.concat (streams_dir ()) (hex_encode stream ^ ".seq")
+let kv_path key = Filename.concat (kv_dir ()) (hex_encode key)
+
+(* ---- value <-> SX text (round-trips through Sx_parser) ----------------- *)
+
+let escape_str s =
+  let len = String.length s in
+  let buf = Buffer.create (len + 16) in
+  for i = 0 to len - 1 do
+    match s.[i] with
+    | '"'  -> Buffer.add_string buf "\\\""
+    | '\\' -> Buffer.add_string buf "\\\\"
+    | '\n' -> Buffer.add_string buf "\\n"
+    | '\r' -> Buffer.add_string buf "\\r"
+    | '\t' -> Buffer.add_string buf "\\t"
+    | c    -> Buffer.add_char buf c
+  done;
+  Buffer.contents buf
+
+let rec serialize = function
+  | Nil -> "nil"
+  | Bool true -> "true"
+  | Bool false -> "false"
+  | Integer n -> string_of_int n
+  | Number n -> format_number n
+  | String s -> "\"" ^ escape_str s ^ "\""
+  | Symbol s -> "(quote " ^ s ^ ")"
+  | Keyword k -> ":" ^ k
+  | List items | ListRef { contents = items } ->
+    "(list" ^ (List.fold_left (fun acc v -> acc ^ " " ^ serialize v) "" items) ^ ")"
+  | Dict d ->
+    let pairs = Hashtbl.fold (fun k v acc ->
+      (Printf.sprintf ":%s %s" k (serialize v)) :: acc) d [] in
+    "{" ^ String.concat " " (List.sort String.compare pairs) ^ "}"
+  | _ -> "nil"
+
+(* Parse one serialized value back. Empty / blank -> Nil. *)
+let rec deserialize line =
+  let line = String.trim line in
+  if line = "" then Nil
+  else match Sx_parser.parse_all line with
+    | v :: _ -> eval_quote_lists v
+    | [] -> Nil
+
+(* serialize emits lists as `(list ...)` and symbols as `(quote s)` so the
+   parser yields data, not a call — but the parser leaves those as AST. Walk
+   the parsed AST and collapse `(list ...)`/`(quote s)` back to values. *)
+and eval_quote_lists v =
+  match v with
+  | List (Symbol "quote" :: x :: []) -> x
+  | List (Symbol "list" :: rest) -> List (List.map eval_quote_lists rest)
+  | List items -> List (List.map eval_quote_lists items)
+  | ListRef { contents = items } -> List (List.map eval_quote_lists items)
+  | Dict d ->
+    let d' = Hashtbl.create (Hashtbl.length d) in
+    Hashtbl.iter (fun k v -> Hashtbl.replace d' k (eval_quote_lists v)) d;
+    Dict d'
+  | other -> other
+
+(* ---- seq counter ------------------------------------------------------- *)
+
+let read_seq stream =
+  let p = stream_seq stream in
+  if Sys.file_exists p then (try int_of_string (String.trim (read_file p)) with _ -> 0)
+  else 0
+
+let write_seq stream n = write_file_atomic (stream_seq stream) (string_of_int n)
+
+let value_to_int = function
+  | Integer n -> n
+  | Number n -> int_of_float n
+  | _ -> 0
+
+let event_seq ev =
+  match ev with
+  | Dict d -> (match Hashtbl.find_opt d "seq" with Some v -> value_to_int v | None -> 0)
+  | _ -> 0
+
+(* ---- ops --------------------------------------------------------------- *)
+
+let do_append stream ev =
+  ensure_dir (streams_dir ());
+  (* bump the monotonic high-water mark; create .seq on first append so the
+     stream shows up in `streams` and survives later truncation. *)
+  let hw = read_seq stream in
+  let s = event_seq ev in
+  write_seq stream (max hw s);
+  append_line (stream_log stream) (serialize ev)
+
+let do_read stream =
+  let p = stream_log stream in
+  if not (Sys.file_exists p) then List []
+  else begin
+    let content = read_file p in
+    let lines = String.split_on_char '\n' content in
+    let evs = List.filter_map (fun l ->
+      if String.trim l = "" then None else Some (deserialize l)) lines in
+    List evs
+  end
+
+let do_last_seq stream = Number (float_of_int (read_seq stream))
+
+let list_dir_suffix dir suffix =
+  if not (Sys.file_exists dir) then []
+  else
+    Array.to_list (Sys.readdir dir)
+    |> List.filter (fun f -> Filename.check_suffix f suffix)
+    |> List.map (fun f -> hex_decode (Filename.chop_suffix f suffix))
+    |> List.sort String.compare
+
+let do_streams () = List (List.map (fun s -> String s) (list_dir_suffix (streams_dir ()) ".seq"))
+
+(* drop events with seq <= n; the .seq high-water counter is untouched. *)
+let do_truncate stream n =
+  let p = stream_log stream in
+  if Sys.file_exists p then begin
+    let evs = match do_read stream with List l -> l | _ -> [] in
+    let kept = List.filter (fun ev -> event_seq ev > n) evs in
+    let body = String.concat "" (List.map (fun ev -> serialize ev ^ "\n") kept) in
+    write_file_atomic p body
+  end
+
+let do_kv_get key =
+  let p = kv_path key in
+  if Sys.file_exists p then deserialize (read_file p) else Nil
+
+let do_kv_put key v =
+  ensure_dir (kv_dir ());
+  write_file_atomic (kv_path key) (serialize v)
+
+let do_kv_delete key =
+  let p = kv_path key in
+  if Sys.file_exists p then (try Sys.remove p with _ -> ())
+
+let do_kv_has key = Bool (Sys.file_exists (kv_path key))
+
+let do_kv_keys () =
+  if not (Sys.file_exists (kv_dir ())) then List []
+  else
+    List (
+      Array.to_list (Sys.readdir (kv_dir ()))
+      |> List.map hex_decode
+      |> List.sort String.compare
+      |> List.map (fun s -> String s))
+
+(* ---- blob store (content-addressed) ------------------------------------ *)
+(* Same pattern as the persist ops, but a SEPARATE adapter: large objects live
+   in a content-addressed directory keyed by a CIDv1 (raw codec, sha2-256).
+   persist only ever stores the returned ref ({:cid :size :mime}), never bytes.
+   blob/put is idempotent — identical bytes hash to the same cid + same file. *)
+
+let codec_raw = 0x55
+
+let blob_cid bytes =
+  let digest = Sx_cid.unhex (Sx_sha2.sha256_hex bytes) in
+  Sx_cid.cidv1 codec_raw (Sx_cid.multihash Sx_cid.mh_sha2_256 digest)
+
+let blob_path cid = Filename.concat (blobs_dir ()) cid
+
+let do_blob_put bytes =
+  let cid = blob_cid bytes in
+  let p = blob_path cid in
+  if not (Sys.file_exists p) then write_file_atomic p bytes;
+  String cid
+
+let do_blob_get cid =
+  let p = blob_path cid in
+  if Sys.file_exists p then String (read_file p) else Nil
+
+let do_blob_has cid = Bool (Sys.file_exists (blob_path cid))
+
+(* ---- dispatch ---------------------------------------------------------- *)
+
+let arglist = function
+  | List l | ListRef { contents = l } -> l
+  | Nil -> []
+  | v -> [v]
+
+(* Returns Some response if op is a persist op this store owns, None otherwise. *)
+let handle_op op args =
+  let a = arglist args in
+  let str = function String s -> s | v -> value_to_string v in
+  match op with
+  | "persist/append" ->
+    (match a with stream :: ev :: _ -> do_append (str stream) ev | _ -> ()); Some Nil
+  | "persist/read" ->
+    (match a with stream :: _ -> Some (do_read (str stream)) | _ -> Some (List []))
+  | "persist/last-seq" ->
+    (match a with stream :: _ -> Some (do_last_seq (str stream)) | _ -> Some (Number 0.0))
+  | "persist/streams" -> Some (do_streams ())
+  | "persist/truncate" ->
+    (match a with stream :: n :: _ -> do_truncate (str stream) (value_to_int n) | _ -> ()); Some Nil
+  | "persist/kv-get" ->
+    (match a with key :: _ -> Some (do_kv_get (str key)) | _ -> Some Nil)
+  | "persist/kv-put" ->
+    (match a with key :: v :: _ -> do_kv_put (str key) v | _ -> ()); Some Nil
+  | "persist/kv-delete" ->
+    (match a with key :: _ -> do_kv_delete (str key) | _ -> ()); Some Nil
+  | "persist/kv-has?" ->
+    (match a with key :: _ -> Some (do_kv_has (str key)) | _ -> Some (Bool false))
+  | "persist/kv-keys" -> Some (do_kv_keys ())
+  | "blob/put" ->
+    (match a with bytes :: _ -> Some (do_blob_put (str bytes)) | _ -> Some Nil)
+  | "blob/get" ->
+    (match a with cid :: _ -> Some (do_blob_get (str cid)) | _ -> Some Nil)
+  | "blob/has?" ->
+    (match a with cid :: _ -> Some (do_blob_has (str cid)) | _ -> Some (Bool false))
+  | _ -> None

hosts/ocaml/test/persist_durable_test.sh

@@ -0,0 +1,144 @@
+#!/usr/bin/env bash
+# hosts/ocaml/test/persist_durable_test.sh
+# Acceptance test for the host durable-storage adapter (Sx_persist_store).
+#
+# Exercises `persist/durable-backend` (REAL `perform`, not the mock) under the
+# WORKTREE-built sx_server.exe, and asserts:
+#   1. durable: writes land on disk and read back (the silent-data-loss repro
+#      from plans/persist-on-sx.md now returns correct values).
+#   2. last-seq is monotonic across truncate (compaction never reassigns a seq).
+#   3. kv ops round-trip and delete.
+#   4. recovery: a REAL process restart (write, exit, fresh process, replay)
+#      recovers state from disk.
+#
+# Run from repo root or anywhere; locates the worktree binary relative to itself.
+set -uo pipefail
+
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+ROOT="$(cd "$HERE/../../.." && pwd)"        # repo/worktree root
+cd "$ROOT"
+
+SX="hosts/ocaml/_build/default/bin/sx_server.exe"
+if [ ! -x "$SX" ]; then
+  echo "ERROR: worktree binary not found at $SX — build it first:" >&2
+  echo "  (cd hosts/ocaml && dune build bin/sx_server.exe)" >&2
+  exit 1
+fi
+
+DATADIR="$(mktemp -d)"
+trap 'rm -rf "$DATADIR"' EXIT
+
+PASS=0
+FAIL=0
+check() { # check <label> <got> <expected>
+  if [ "$2" = "$3" ]; then
+    PASS=$((PASS + 1)); printf '  ok   %-40s => %s\n' "$1" "$2"
+  else
+    FAIL=$((FAIL + 1)); printf '  FAIL %-40s got [%s] want [%s]\n' "$1" "$2" "$3"
+  fi
+}
+
+PRELUDE='(epoch 1)
+(load "spec/stdlib.sx")
+(load "lib/r7rs.sx")
+(load "lib/persist/event.sx")
+(load "lib/persist/backend.sx")
+(load "lib/persist/log.sx")
+(load "lib/persist/kv.sx")
+(load "lib/persist/durable.sx")
+(load "lib/persist/blob.sx")
+(epoch 2)'
+
+# run_eval <sx-expr-string>: prints the final (ok-len 2 ...) payload line.
+run_eval() {
+  local expr="$1"
+  printf '%s\n(eval %s)\n' "$PRELUDE" "$expr" \
+    | SX_PERSIST_DIR="$DATADIR" timeout 60 "$SX" 2>/dev/null \
+    | awk '/^\(ok-len 2 / {getline; print; exit}'
+}
+
+# escape an SX program into a single-line double-quoted SX string literal for
+# (eval "..."). The REPL reads one command per physical line, so newlines in the
+# program are collapsed to spaces.
+q() { printf '"%s"' "$(printf '%s' "$1" | tr '\n' ' ' | sed 's/\\/\\\\/g; s/"/\\"/g')"; }
+
+echo "== durable: append/read/last-seq round-trip on disk =="
+GOT=$(run_eval "$(q '(let ((b (persist/durable-backend)))
+  (begin
+    (persist/append b "s" "x" 0 {:v 1})
+    (persist/append b "s" "x" 0 {:v 2})
+    (list (persist/event-seq (persist/append b "s" "x" 0 {:v 3}))
+          (persist/count b "s")
+          (len (persist/read b "s")))))')")
+check "append/count/read" "$GOT" "(3 3 3)"
+
+echo "== last-seq monotonic across truncate =="
+GOT=$(run_eval "$(q '(let ((b (persist/durable-backend)))
+  (begin
+    (persist/append b "t" "x" 0 {})
+    (persist/append b "t" "x" 0 {})
+    (persist/append b "t" "x" 0 {})
+    (persist/truncate b "t" 2)
+    (list (persist/last-seq b "t") (persist/count b "t"))))')")
+check "last-seq survives truncate" "$GOT" "(3 1)"
+
+echo "== streams set survives compaction =="
+GOT=$(run_eval "$(q '(let ((b (persist/durable-backend)))
+  (sort ((get b "streams"))))')")
+check "streams" "$GOT" '("s" "t")'
+
+echo "== kv round-trip + delete =="
+GOT=$(run_eval "$(q '(let ((b (persist/durable-backend)))
+  (begin
+    (persist/kv-put b "k" {:a 1 :b "two"})
+    (persist/kv-put b "gone" 9)
+    (persist/kv-delete b "gone")
+    (list (get (persist/kv-get b "k") :b)
+          (persist/kv-has? b "k")
+          (persist/kv-has? b "gone"))))')")
+check "kv get/has/delete" "$GOT" '("two" true false)'
+
+echo "== recovery: state survives a REAL process restart =="
+# write in process A then let it exit; the next run is a brand-new process.
+run_eval "$(q '(let ((b (persist/durable-backend)))
+  (begin
+    (persist/append b "r" "ev" 0 {:n 1})
+    (persist/append b "r" "ev" 0 {:n 2})
+    (persist/kv-put b "survive" "yes")
+    (persist/count b "r")))')" >/dev/null
+# fresh process, same SX_PERSIST_DIR — must replay from disk.
+GOT=$(run_eval "$(q '(let ((b (persist/durable-backend)))
+  (list (persist/count b "r")
+        (persist/last-seq b "r")
+        (get (get (nth (persist/read b "r") 1) :data) :n)
+        (persist/kv-get b "survive")))')")
+check "recovered after restart" "$GOT" '(2 2 2 "yes")'
+
+echo "== blob: content-addressed put/get/has? round-trip =="
+GOT=$(run_eval "$(q '(let ((bs (persist/blob-store-backend)))
+  (let ((r (persist/blob-store bs "hello world" "text/plain")))
+    (list (persist/blob-size r)
+          (persist/blob-mime r)
+          (persist/blob-fetch bs r)
+          (persist/blob-exists? bs r))))')")
+check "blob size/mime/fetch/exists" "$GOT" '(11 "text/plain" "hello world" true)'
+
+echo "== blob: put is content-addressed (idempotent cid) =="
+GOT=$(run_eval "$(q '(let ((bs (persist/blob-store-backend)))
+  (equal? (persist/blob-cid (persist/blob-store bs "same bytes" "x"))
+          (persist/blob-cid (persist/blob-store bs "same bytes" "x"))))')")
+check "same bytes -> same cid" "$GOT" "true"
+
+echo "== blob: bytes + ref-in-kv survive a REAL restart =="
+# process A: store a blob, keep only its ref in the durable kv.
+run_eval "$(q '(let ((b (persist/durable-backend)) (bs (persist/blob-store-backend)))
+  (begin (persist/kv-put b "logo" (persist/blob-store bs "PNGDATA" "image/png")) nil))')" >/dev/null
+# fresh process: read the ref from kv, fetch the bytes from the blob store.
+GOT=$(run_eval "$(q '(let ((b (persist/durable-backend)) (bs (persist/blob-store-backend)))
+  (let ((r (persist/kv-get b "logo")))
+    (list (persist/blob-fetch bs r) (persist/blob-exists? bs r) (persist/blob-mime r))))')")
+check "blob recovered via ref after restart" "$GOT" '("PNGDATA" true "image/png")'
+
+echo
+echo "durable adapter: $PASS passed, $FAIL failed"
+[ "$FAIL" -eq 0 ]

lib/acl/api.sx

@@ -1,45 +0,0 @@
-;; lib/acl/api.sx — public ACL surface over an implicit current db.
-;;
-;; Callers load a fact set once, then issue decisions without threading the db
-;; through every call. The current db is module state; (acl/load! facts) rebuilds
-;; it. This is the boundary the rest of rose-ash imports.
-
-(define acl-current-db nil)
-
-;; Replace the current fact base. Rebuilds the Datalog db under the active
-;; ruleset (see lib/acl/engine.sx).
-(define
-  acl/load!
-  (fn
-    (facts)
-    (do (set! acl-current-db (acl-build-db facts)) acl-current-db)))
-
-;; Ensure a db exists, building an empty one on first use.
-(define
-  acl-ensure-db!
-  (fn
-    ()
-    (do
-      (when
-        (= acl-current-db nil)
-        (set! acl-current-db (acl-build-db (list))))
-      acl-current-db)))
-
-;; Public decision against the current db (pure, no logging).
-(define
-  acl/permit?
-  (fn (subj act res) (acl-permit? (acl-ensure-db!) subj act res)))
-
-;; Decision-with-proof against the current db. See lib/acl/explain.sx.
-(define
-  acl/explain
-  (fn (subj act res) (acl-explain (acl-ensure-db!) subj act res)))
-
-;; Audited decision: logs the outcome to the append-only audit log and returns
-;; the boolean. See lib/acl/audit.sx.
-(define
-  acl/audit
-  (fn (subj act res) (acl-audit-decide! (acl-ensure-db!) subj act res)))
-
-;; Recent audited decisions (chronological).
-(define acl/audit-tail (fn (n) (acl-audit-tail n)))

lib/acl/audit.sx

@@ -1,110 +0,0 @@
-;; lib/acl/audit.sx — append-only decision log.
-;;
-;; Every decision routed through acl-audit-decide! is appended to an in-memory
-;; log with a monotonic sequence number (no wall-clock — deterministic and
-;; testable; a host can stamp time at the serializer boundary). The log is
-;; append-only: there is no mutate or delete, only append, tail, clear,
-;; snapshot/restore, and serialize-for-disk.
-
-(define acl-audit-log (list))
-(define acl-audit-seq 0)
-
-;; Copy a list into a fresh, append!-able list. `map`/`rest`-derived lists are
-;; NOT extensible by append! in this runtime (it silently no-ops), so the live
-;; log must always be a list built with `list` + `append!`.
-(define
-  acl-audit-copy
-  (fn
-    (xs)
-    (let
-      ((fresh (list)))
-      (do (for-each (fn (e) (append! fresh e)) xs) fresh))))
-
-(define
-  acl-audit-clear!
-  (fn
-    ()
-    (do (set! acl-audit-log (list)) (set! acl-audit-seq 0) nil)))
-
-;; Append a decision record. Returns the record.
-(define
-  acl-audit-record!
-  (fn
-    (subj act res allowed?)
-    (let
-      ((entry {:allowed? allowed? :act act :subj subj :res res :seq acl-audit-seq}))
-      (do
-        (set! acl-audit-seq (+ acl-audit-seq 1))
-        (append! acl-audit-log entry)
-        entry))))
-
-;; Decide against db, log the outcome, and return the boolean. This is the
-;; audited path; acl-permit? remains the pure, side-effect-free decision.
-(define
-  acl-audit-decide!
-  (fn
-    (db subj act res)
-    (let
-      ((allowed? (acl-permit? db subj act res)))
-      (do (acl-audit-record! subj act res allowed?) allowed?))))
-
-(define acl-audit-count (fn () (len acl-audit-log)))
-
-;; Most recent n entries (in chronological order). n >= log size returns all.
-(define
-  acl-audit-tail
-  (fn
-    (n)
-    (let
-      ((total (len acl-audit-log)))
-      (if
-        (<= total n)
-        acl-audit-log
-        (acl-audit-drop acl-audit-log (- total n))))))
-
-(define
-  acl-audit-drop
-  (fn
-    (xs k)
-    (if (<= k 0) xs (acl-audit-drop (rest xs) (- k 1)))))
-
-;; Structured snapshot for save/restore — a {:seq :entries} value carrying a
-;; copy of the log (so later appends don't mutate a held snapshot).
-(define acl-audit-snapshot (fn () {:seq acl-audit-seq :entries (acl-audit-copy acl-audit-log)}))
-
-;; Replace the live log from a snapshot. Restores both entries and the seq
-;; counter so subsequent records continue numbering correctly. The log is
-;; rebuilt as a fresh append!-able list (see acl-audit-copy).
-(define
-  acl-audit-restore!
-  (fn
-    (snap)
-    (do
-      (set! acl-audit-log (acl-audit-copy (get snap :entries)))
-      (set! acl-audit-seq (get snap :seq))
-      nil)))
-
-;; Serialize the whole log to a disk-ready string: one record per line,
-;; "seq\tsubj\tact\tres\tallowed?". A host writes this; structured reload is via
-;; snapshot/restore.
-(define
-  acl-audit-serialize
-  (fn
-    ()
-    (reduce
-      (fn
-        (acc e)
-        (str
-          acc
-          (get e :seq)
-          "\t"
-          (get e :subj)
-          "\t"
-          (get e :act)
-          "\t"
-          (get e :res)
-          "\t"
-          (get e :allowed?)
-          "\n"))
-      ""
-      acl-audit-log)))

lib/acl/conformance.conf

@@ -1,32 +0,0 @@
-# ACL conformance config — sourced by lib/guest/conformance.sh.
-
-LANG_NAME=acl
-MODE=dict
-
-PRELOADS=(
-  lib/datalog/tokenizer.sx
-  lib/datalog/parser.sx
-  lib/datalog/unify.sx
-  lib/datalog/db.sx
-  lib/datalog/builtins.sx
-  lib/datalog/aggregates.sx
-  lib/datalog/strata.sx
-  lib/datalog/eval.sx
-  lib/datalog/api.sx
-  lib/datalog/magic.sx
-  lib/acl/schema.sx
-  lib/acl/facts.sx
-  lib/acl/engine.sx
-  lib/acl/explain.sx
-  lib/acl/audit.sx
-  lib/acl/federation.sx
-  lib/acl/api.sx
-)
-
-SUITES=(
-  "direct:lib/acl/tests/direct.sx:(acl-direct-tests-run!)"
-  "inherit:lib/acl/tests/inherit.sx:(acl-inherit-tests-run!)"
-  "explain:lib/acl/tests/explain.sx:(acl-explain-tests-run!)"
-  "fed:lib/acl/tests/fed.sx:(acl-fed-tests-run!)"
-  "harden:lib/acl/tests/harden.sx:(acl-harden-tests-run!)"
-)

lib/acl/conformance.sh

@@ -1,3 +0,0 @@
-#!/usr/bin/env bash
-# Thin wrapper — see lib/guest/conformance.sh and lib/acl/conformance.conf.
-exec bash "$(dirname "$0")/../guest/conformance.sh" "$(dirname "$0")/conformance.conf" "$@"

lib/acl/engine.sx

@@ -1,72 +0,0 @@
-;; lib/acl/engine.sx — ACL ruleset + decision reducer over lib/datalog/.
-;;
-;; The engine is a thin layer: it owns the permit ruleset (SX data rules) and
-;; reduces a (subject, action, resource) decision to a Datalog query against a
-;; db built from EDB facts. The rule engine itself is Datalog's.
-;;
-;; Policy — inheritance + federation with deny-overrides:
-;;
-;;   eff_grant(S,A,R) :- grant(S,A,R).                         ; direct
-;;   eff_grant(S,A,R) :- member_of(S,G), eff_grant(G,A,R).     ; group/role chain
-;;   eff_grant(S,A,R) :- child_of(R,P), eff_grant(S,A,P).      ; resource tree
-;;   eff_grant(S,A,R) :- member_of(S,Role), role_grant(Role,A,R). ; role expansion
-;;   eff_grant(S,A,R) :- delegate(Peer,S,A,R),                 ; federated grant
-;;                       trust(Peer,L), level_covers(L,A).
-;;
-;;   eff_deny(S,A,R)  :- deny(S,A,R).                          ; direct
-;;   eff_deny(S,A,R)  :- member_of(S,G), eff_deny(G,A,R).      ; group chain
-;;   eff_deny(S,A,R)  :- child_of(R,P), eff_deny(S,A,P).       ; resource tree
-;;
-;;   permit(S,A,R)    :- eff_grant(S,A,R), not eff_deny(S,A,R).
-;;
-;; DENY-OVERRIDES: an effective deny anywhere in the inheritance closure of
-;; (S,A,R) defeats any effective grant — including federated grants. Deny
-;; inherits through the *same* group and resource chains as grant, so a
-;; group-level or ancestor-resource deny is authoritative for members/
-;; descendants. This is the principled, fail-safe reading of "deny wins".
-;;
-;; FEDERATION — non-transitive trust: a peer's `delegate` fact only grants if a
-;; *local* `trust(Peer, L)` exists AND that level `level_covers` the action.
-;; Trust is re-checked on every query (it is a body literal), never baked in at
-;; fact-ingestion time, so revoking trust or narrowing a level takes effect
-;; immediately on the next decision.
-;;
-;; Termination & stratification:
-;;   - eff_grant/eff_deny recurse only over member_of and child_of, which are
-;;     EDB relations with no function symbols, so the closure is finite (cyclic
-;;     membership/containment just reaches a fixpoint, never loops). The
-;;     federation rule is non-recursive.
-;;   - permit negates eff_deny; neither eff_grant nor eff_deny depends on
-;;     permit, so the program is stratifiable (permit sits in a higher stratum).
-
-(define
-  acl-rules
-  (quote
-    ((eff_grant S A R <- (grant S A R))
-      (eff_grant S A R <- (member_of S G) (eff_grant G A R))
-      (eff_grant S A R <- (child_of R P) (eff_grant S A P))
-      (eff_grant S A R <- (member_of S Role) (role_grant Role A R))
-      (eff_grant
-        S
-        A
-        R
-        <-
-        (delegate Peer S A R)
-        (trust Peer L)
-        (level_covers L A))
-      (eff_deny S A R <- (deny S A R))
-      (eff_deny S A R <- (member_of S G) (eff_deny G A R))
-      (eff_deny S A R <- (child_of R P) (eff_deny S A P))
-      (permit S A R <- (eff_grant S A R) {:neg (eff_deny S A R)}))))
-
-;; Build a Datalog db from a list of EDB facts under the ACL ruleset.
-(define acl-build-db (fn (facts) (dl-program-data facts acl-rules)))
-
-;; Core decision: does the db permit subject S to perform action A on
-;; resource R? Reduces to a ground Datalog query on the derived `permit`
-;; relation — non-empty result means permitted.
-(define
-  acl-permit?
-  (fn
-    (db subj act res)
-    (> (len (dl-query db (list (quote permit) subj act res))) 0)))

lib/acl/explain.sx

@@ -1,125 +0,0 @@
-;; lib/acl/explain.sx — proof-tree reconstruction over the saturated db.
-;;
-;; lib/datalog/ records derived facts but not their provenance, so the proof is
-;; reconstructed here by goal-directed search over the *saturated* db: for a
-;; ground goal we find the first ACL rule (in rule order) whose body holds, take
-;; the first solution binding its remaining variables, and recurse on each body
-;; literal. Negated literals are recorded as verified `:neg-ok` leaves.
-;;
-;; CANONICAL DERIVATION: the Datalog derivation graph is a DAG (a fact may hold
-;; many ways). We pick ONE canonical proof — first matching rule, first solution
-;; — matching the rule order in lib/acl/engine.sx (direct/EDB rules first). A
-;; depth cap guards against pathological cyclic data producing unbounded search.
-;;
-;; A proof node is one of:
-;;   {:fact <lit> :via "edb"}                       — base EDB fact
-;;   {:fact <lit> :rule <head> :body (<node|negleaf> ...)}  — derived
-;;   {:neg-ok <lit>}                                — negation verified to fail
-;;   {:fact <lit> :truncated true}                  — depth cap hit
-
-(define acl-proof-max-depth 64)
-
-;; Substitute a body literal, descending into {:neg ...} dicts (dl-apply-subst
-;; does not recurse into dicts, which would leak the neg's free vars).
-(define
-  acl-subst-lit
-  (fn
-    (lit s)
-    (if
-      (and (dict? lit) (has-key? lit :neg))
-      {:neg (dl-apply-subst (get lit :neg) s)}
-      (dl-apply-subst lit s))))
-
-(define
-  acl-lit-edb?
-  (fn
-    (lit)
-    (and
-      (list? lit)
-      (> (len lit) 0)
-      (symbol? (first lit))
-      (has-key? acl-edb-arity (symbol->string (first lit))))))
-
-(define
-  acl-subst-zip!
-  (fn
-    (d ks vs)
-    (when
-      (> (len ks) 0)
-      (do
-        (dict-set! d (symbol->string (first ks)) (first vs))
-        (acl-subst-zip! d (rest ks) (rest vs))))))
-
-;; Bind a rule head's variables to a ground goal's arguments (positional).
-(define
-  acl-bind-head
-  (fn
-    (head goal)
-    (let
-      ((d {}))
-      (do (acl-subst-zip! d (rest head) (rest goal)) d))))
-
-(define
-  acl-subst-union
-  (fn
-    (a b)
-    (let
-      ((d {}))
-      (do
-        (for-each (fn (k) (dict-set! d k (get a k))) (keys a))
-        (for-each (fn (k) (dict-set! d k (get b k))) (keys b))
-        d))))
-
-(define acl-prove (fn (db goal) (acl-prove-d db goal 0)))
-
-(define
-  acl-prove-d
-  (fn
-    (db goal depth)
-    (cond
-      ((> depth acl-proof-max-depth) {:truncated true :fact goal})
-      ((acl-lit-edb? goal)
-        (if (> (len (dl-query db goal)) 0) {:via "edb" :fact goal} nil))
-      (else (acl-prove-rules db goal acl-rules depth)))))
-
-(define
-  acl-prove-rules
-  (fn
-    (db goal rules depth)
-    (if
-      (= (len rules) 0)
-      nil
-      (let
-        ((p (dl-rule-from-list (first rules))))
-        (if
-          (= (first (get p :head)) (first goal))
-          (let
-            ((hs (acl-bind-head (get p :head) goal)))
-            (let
-              ((qbody (map (fn (l) (acl-subst-lit l hs)) (get p :body))))
-              (let
-                ((sols (dl-query db qbody)))
-                (if
-                  (> (len sols) 0)
-                  (acl-prove-build db goal p hs (first sols) depth)
-                  (acl-prove-rules db goal (rest rules) depth)))))
-          (acl-prove-rules db goal (rest rules) depth))))))
-
-(define
-  acl-prove-build
-  (fn
-    (db goal p hs sol depth)
-    (let ((full (acl-subst-union hs sol))) {:body (map (fn (l) (let ((g (acl-subst-lit l full))) (if (and (dict? g) (has-key? g :neg)) {:neg-ok (get g :neg)} (acl-prove-d db g (+ depth 1))))) (get p :body)) :rule (get p :head) :fact goal})))
-
-;; Public decision-with-proof. Returns:
-;;   {:allowed? <bool> :proof <node|nil> :reason <eff_deny proof|nil>}
-;; When permitted, :proof is the permit derivation. When denied, :proof is nil
-;; and :reason carries the blocking eff_deny proof if one exists (an explicit or
-;; inherited deny), else nil (simply no grant).
-(define
-  acl-explain
-  (fn
-    (db subj act res)
-    (let
-      ((proof (acl-prove db (list (quote permit) subj act res))))
-      (if (= proof nil) {:allowed? false :proof nil :reason (acl-prove db (list (quote eff_deny) subj act res))} {:allowed? true :proof proof :reason nil}))))

lib/acl/facts.sx

@@ -1,47 +0,0 @@
-;; lib/acl/facts.sx — EDB fact constructors.
-;;
-;; Each constructor returns a Datalog fact tuple (a list whose head is the
-;; predicate symbol). These are the only shapes lib/acl/engine.sx feeds to
-;; lib/datalog/.
-;;   Phase 1: actor/resource/grant/deny.
-;;   Phase 2: member_of (subject -> group/role), child_of (resource -> parent),
-;;            role_grant (role -> action,resource capability).
-;;   Phase 4: peer/trust/delegate/level_covers (federation).
-
-(define acl-actor (fn (id kind) (list (quote actor) id kind)))
-
-(define acl-resource-fact (fn (id kind) (list (quote resource) id kind)))
-
-(define acl-grant (fn (subj act res) (list (quote grant) subj act res)))
-
-(define acl-deny (fn (subj act res) (list (quote deny) subj act res)))
-
-;; subject S is a member of group/role G (one hop; transitivity is derived).
-(define acl-member-of (fn (subj grp) (list (quote member_of) subj grp)))
-
-;; resource R is a child of parent P (one hop; transitivity is derived).
-(define acl-child-of (fn (res parent) (list (quote child_of) res parent)))
-
-;; role confers capability (act on res) to every member of the role.
-(define
-  acl-role-grant
-  (fn (role act res) (list (quote role_grant) role act res)))
-
-;; --- federation ---
-
-;; a known peer instance at addr, of some kind (e.g. peer).
-(define acl-peer (fn (addr kind) (list (quote peer) addr kind)))
-
-;; local trust in a peer at a named level. Gates delegated grants at query time.
-(define acl-trust (fn (peer level) (list (quote trust) peer level)))
-
-;; a peer asserts that subject S may A on R. Only takes effect if local trust in
-;; that peer covers action A (see level_covers).
-(define
-  acl-delegate
-  (fn (peer subj act res) (list (quote delegate) peer subj act res)))
-
-;; local policy: trust `level` authorises delegated grants for action `act`.
-(define
-  acl-level-covers
-  (fn (level act) (list (quote level_covers) level act)))

lib/acl/federation.sx

@@ -1,61 +0,0 @@
-;; lib/acl/federation.sx — cross-instance ACL facts + revocation.
-;;
-;; fed-sx replicates ACL facts between instances; this module models the local
-;; side. A peer's authority arrives as `delegate(Peer, S, A, R)` facts, which
-;; only take effect when a local `trust(Peer, L)` and `level_covers(L, A)`
-;; authorise them (enforced by the engine rule, re-checked every query). The
-;; actual network transport is fed-sx's job and is mocked in tests as a dict.
-;;
-;; Trust is NOT transitive: trusting peer α does not extend to peers α trusts.
-;; Only delegate facts that α itself asserts, and that local trust covers, flow.
-
-;; Mock fed-sx pull: `transport` is a dict mapping a peer address (its string
-;; name) to the list of delegate facts that peer asserts. Returns the facts for
-;; `addr`, or an empty list if the peer is unknown / unreachable.
-(define
-  acl-fed-fetch
-  (fn
-    (transport addr)
-    (let
-      ((k (if (symbol? addr) (symbol->string addr) addr)))
-      (if (has-key? transport k) (get transport k) (list)))))
-
-;; Gather delegate facts from every peer in `addrs` via the transport.
-(define
-  acl-fed-collect
-  (fn
-    (transport addrs)
-    (let
-      ((acc (list)))
-      (do
-        (for-each
-          (fn
-            (addr)
-            (for-each
-              (fn (f) (append! acc f))
-              (acl-fed-fetch transport addr)))
-          addrs)
-        acc))))
-
-;; Build a db from local facts plus delegate facts pulled from `peers`. Local
-;; facts must include the `trust`/`level_covers` policy; replicated delegate
-;; facts are gated against it by the engine rule at query time.
-(define
-  acl-fed-build-db
-  (fn
-    (local-facts transport peers)
-    (let
-      ((all (list)))
-      (do
-        (for-each (fn (f) (append! all f)) local-facts)
-        (for-each
-          (fn (f) (append! all f))
-          (acl-fed-collect transport peers))
-        (acl-build-db all)))))
-
-;; Propagated revocation: retract a replicated fact (e.g. a peer's delegate, or
-;; local trust) from a live db. The next decision re-saturates and reflects it.
-(define acl-revoke! (fn (db fact) (do (dl-retract! db fact) db)))
-
-;; Propagated assertion: ingest a newly replicated fact into a live db.
-(define acl-fed-assert! (fn (db fact) (do (dl-assert! db fact) db)))

lib/acl/schema.sx

@@ -1,71 +0,0 @@
-;; lib/acl/schema.sx — ACL sorts and EDB predicate vocabulary.
-;;
-;; Datalog is untyped; this module is the schema-as-data layer. It declares
-;; the subject/resource/action sorts and the arity of every EDB predicate the
-;; ACL engine recognises, plus light validators. Facts that pass these checks
-;; are well-formed inputs to lib/acl/engine.sx.
-
-(define acl-subject-kinds (quote (user group role service)))
-(define acl-resource-kinds (quote (page post thread peer)))
-
-;; Actions are open-ended (a grant may name any action symbol), but these are
-;; the platform's well-known verbs.
-(define acl-actions (quote (read edit comment moderate federate)))
-
-;; EDB predicate name -> arity.
-;;   Phase 1: actor/resource/grant/deny.
-;;   Phase 2: member_of (subject->group/role), child_of (resource->parent),
-;;            role_grant (role->action,resource).
-;;   Phase 4: peer (addr->kind), trust (peer->level),
-;;            delegate (peer->subj,action,resource), level_covers (level->action).
-(define acl-edb-arity {:role_grant 3 :child_of 2 :trust 2 :peer 2 :actor 2 :level_covers 2 :delegate 4 :member_of 2 :deny 3 :grant 3 :resource 2})
-
-(define
-  acl-member?
-  (fn
-    (x xs)
-    (cond
-      ((= (len xs) 0) false)
-      ((= (first xs) x) true)
-      (else (acl-member? x (rest xs))))))
-
-(define acl-subject-kind? (fn (k) (acl-member? k acl-subject-kinds)))
-
-(define acl-resource-kind? (fn (k) (acl-member? k acl-resource-kinds)))
-
-(define acl-known-action? (fn (a) (acl-member? a acl-actions)))
-
-;; A fact is a list whose head is a predicate symbol. Valid when the predicate
-;; is known and the argument count matches the declared arity.
-(define
-  acl-fact-valid?
-  (fn
-    (f)
-    (and
-      (list? f)
-      (> (len f) 0)
-      (symbol? (first f))
-      (let
-        ((pred (symbol->string (first f))))
-        (and
-          (has-key? acl-edb-arity pred)
-          (= (- (len f) 1) (get acl-edb-arity pred)))))))
-
-;; Return the sublist of facts that fail acl-fact-valid?. Empty list means the
-;; whole set is well-formed. acl-build-db stays lenient (Datalog accepts any
-;; tuple, and custom action symbols are allowed); callers opt in to checking.
-(define
-  acl-validate-facts
-  (fn
-    (facts)
-    (let
-      ((bad (list)))
-      (do
-        (for-each
-          (fn (f) (when (not (acl-fact-valid? f)) (append! bad f)))
-          facts)
-        bad))))
-
-(define
-  acl-facts-valid?
-  (fn (facts) (= (len (acl-validate-facts facts)) 0)))

lib/acl/scoreboard.json

@@ -1,14 +0,0 @@
-{
-  "lang": "acl",
-  "total_passed": 145,
-  "total_failed": 0,
-  "total": 145,
-  "suites": [
-    {"name":"direct","passed":24,"failed":0,"total":24},
-    {"name":"inherit","passed":30,"failed":0,"total":30},
-    {"name":"explain","passed":35,"failed":0,"total":35},
-    {"name":"fed","passed":31,"failed":0,"total":31},
-    {"name":"harden","passed":25,"failed":0,"total":25}
-  ],
-  "generated": "2026-06-06T22:43:27+00:00"
-}

lib/acl/scoreboard.md

@@ -1,11 +0,0 @@
-# acl scoreboard
-
-**145 / 145 passing** (0 failure(s)).
-
-| Suite | Passed | Total | Status |
-|-------|--------|-------|--------|
-| direct | 24 | 24 | ok |
-| inherit | 30 | 30 | ok |
-| explain | 35 | 35 | ok |
-| fed | 31 | 31 | ok |
-| harden | 25 | 25 | ok |

lib/acl/tests/direct.sx

@@ -1,170 +0,0 @@
-;; lib/acl/tests/direct.sx — Phase 1: direct grants + deny-overrides.
-
-(define acl-dt-pass 0)
-(define acl-dt-fail 0)
-(define acl-dt-failures (list))
-
-(define
-  acl-dt-check!
-  (fn
-    (name got expected)
-    (if
-      (= got expected)
-      (set! acl-dt-pass (+ acl-dt-pass 1))
-      (do
-        (set! acl-dt-fail (+ acl-dt-fail 1))
-        (append!
-          acl-dt-failures
-          (str name "\n    expected: " expected "\n    got:      " got))))))
-
-;; A small fixture used by most cases: alice can read page1, is denied edit on
-;; page1, and a service may federate peer1.
-(define
-  acl-dt-fixture
-  (fn
-    ()
-    (acl-build-db
-      (list
-        (acl-actor (quote alice) (quote user))
-        (acl-actor (quote svc1) (quote service))
-        (acl-resource-fact (quote page1) (quote page))
-        (acl-resource-fact (quote peer1) (quote peer))
-        (acl-grant (quote alice) (quote read) (quote page1))
-        (acl-grant (quote alice) (quote edit) (quote page1))
-        (acl-deny (quote alice) (quote edit) (quote page1))
-        (acl-grant (quote svc1) (quote federate) (quote peer1))))))
-
-(define
-  acl-dt-run-all!
-  (fn
-    ()
-    (let
-      ((db (acl-dt-fixture)))
-      (do
-        (acl-dt-check!
-          "direct grant permits"
-          (acl-permit? db (quote alice) (quote read) (quote page1))
-          true)
-        (acl-dt-check!
-          "service grant permits federate"
-          (acl-permit? db (quote svc1) (quote federate) (quote peer1))
-          true)
-        (acl-dt-check!
-          "missing action denied"
-          (acl-permit? db (quote alice) (quote comment) (quote page1))
-          false)
-        (acl-dt-check!
-          "missing resource denied"
-          (acl-permit? db (quote alice) (quote read) (quote page2))
-          false)
-        (acl-dt-check!
-          "missing subject denied"
-          (acl-permit? db (quote bob) (quote read) (quote page1))
-          false)
-        (acl-dt-check!
-          "wrong subject for service grant denied"
-          (acl-permit? db (quote alice) (quote federate) (quote peer1))
-          false)
-        (acl-dt-check!
-          "grant plus deny -> deny wins"
-          (acl-permit? db (quote alice) (quote edit) (quote page1))
-          false)
-        (acl-dt-check!
-          "deny alone still denies"
-          (acl-permit?
-            (acl-build-db
-              (list (acl-deny (quote alice) (quote read) (quote page1))))
-            (quote alice)
-            (quote read)
-            (quote page1))
-          false)
-        (acl-dt-check!
-          "deny on edit does not block read"
-          (acl-permit? db (quote alice) (quote read) (quote page1))
-          true)
-        (acl-dt-check!
-          "empty db denies"
-          (acl-permit?
-            (acl-build-db (list))
-            (quote alice)
-            (quote read)
-            (quote page1))
-          false)
-        (let
-          ((db2 (acl-build-db (list (acl-grant (quote a) (quote read) (quote r)) (acl-grant (quote b) (quote read) (quote r)) (acl-deny (quote b) (quote read) (quote r))))))
-          (do
-            (acl-dt-check!
-              "subject a allowed"
-              (acl-permit? db2 (quote a) (quote read) (quote r))
-              true)
-            (acl-dt-check!
-              "subject b denied by override"
-              (acl-permit? db2 (quote b) (quote read) (quote r))
-              false)))
-        (let
-          ((db3 (acl-build-db (list (acl-actor (quote editors) (quote role)) (acl-grant (quote editors) (quote edit) (quote post1))))))
-          (acl-dt-check!
-            "role subject direct grant"
-            (acl-permit? db3 (quote editors) (quote edit) (quote post1))
-            true))
-        (do
-          (acl/load!
-            (list
-              (acl-grant (quote carol) (quote moderate) (quote thread1))))
-          (acl-dt-check!
-            "api permit via current db"
-            (acl/permit? (quote carol) (quote moderate) (quote thread1))
-            true)
-          (acl-dt-check!
-            "api deny via current db"
-            (acl/permit? (quote carol) (quote read) (quote thread1))
-            false))
-        (do
-          (acl/load! (list))
-          (acl-dt-check!
-            "api reload clears prior grants"
-            (acl/permit? (quote carol) (quote moderate) (quote thread1))
-            false))
-        (acl-dt-check!
-          "schema grant arity valid"
-          (acl-fact-valid? (acl-grant (quote x) (quote read) (quote y)))
-          true)
-        (acl-dt-check!
-          "schema bad arity invalid"
-          (acl-fact-valid? (list (quote grant) (quote x)))
-          false)
-        (acl-dt-check!
-          "schema unknown predicate invalid"
-          (acl-fact-valid? (list (quote frobnicate) (quote x)))
-          false)
-        (acl-dt-check!
-          "schema subject kind known"
-          (acl-subject-kind? (quote service))
-          true)
-        (acl-dt-check!
-          "schema resource kind unknown"
-          (acl-resource-kind? (quote galaxy))
-          false)
-        (acl-dt-check!
-          "schema known action"
-          (acl-known-action? (quote moderate))
-          true)
-        (acl-dt-check!
-          "grant constructor shape"
-          (acl-grant (quote u) (quote read) (quote p))
-          (list (quote grant) (quote u) (quote read) (quote p)))
-        (acl-dt-check!
-          "actor constructor shape"
-          (acl-actor (quote u) (quote user))
-          (list (quote actor) (quote u) (quote user)))))))
-
-(define
-  acl-direct-tests-run!
-  (fn
-    ()
-    (do
-      (set! acl-dt-pass 0)
-      (set! acl-dt-fail 0)
-      (set! acl-dt-failures (list))
-      (acl-dt-run-all!)
-      {:failures acl-dt-failures :total (+ acl-dt-pass acl-dt-fail) :passed acl-dt-pass :failed acl-dt-fail})))

lib/acl/tests/explain.sx

@@ -1,316 +0,0 @@
-;; lib/acl/tests/explain.sx — Phase 3: proof correctness + audit completeness.
-
-(define acl-et-pass 0)
-(define acl-et-fail 0)
-(define acl-et-failures (list))
-
-;; Name-based deep equality. The host `=` compares symbols by interned
-;; identity, which is unstable across substitution/saturation; comparing by
-;; name (as the datalog suite does) makes structural assertions deterministic.
-(define
-  acl-et-eq?
-  (fn
-    (a b)
-    (cond
-      ((and (list? a) (list? b))
-        (and (= (len a) (len b)) (acl-et-eq-l? a b 0)))
-      ((and (dict? a) (dict? b))
-        (let
-          ((ka (keys a)) (kb (keys b)))
-          (and (= (len ka) (len kb)) (acl-et-eq-d? a b ka 0))))
-      ((and (symbol? a) (symbol? b))
-        (= (symbol->string a) (symbol->string b)))
-      (else (= a b)))))
-
-(define
-  acl-et-eq-l?
-  (fn
-    (a b i)
-    (cond
-      ((>= i (len a)) true)
-      ((not (acl-et-eq? (nth a i) (nth b i))) false)
-      (else (acl-et-eq-l? a b (+ i 1))))))
-
-(define
-  acl-et-eq-d?
-  (fn
-    (a b ka i)
-    (cond
-      ((>= i (len ka)) true)
-      ((let ((k (nth ka i))) (not (acl-et-eq? (get a k) (get b k))))
-        false)
-      (else (acl-et-eq-d? a b ka (+ i 1))))))
-
-(define
-  acl-et-check!
-  (fn
-    (name got expected)
-    (if
-      (acl-et-eq? got expected)
-      (set! acl-et-pass (+ acl-et-pass 1))
-      (do
-        (set! acl-et-fail (+ acl-et-fail 1))
-        (append!
-          acl-et-failures
-          (str name "\n    expected: " expected "\n    got:      " got))))))
-
-;; --- proof-tree walkers ---
-
-;; True if EDB fact `target` appears as a base leaf anywhere in the proof.
-(define
-  acl-et-has-leaf?
-  (fn
-    (node target)
-    (cond
-      ((= node nil) false)
-      ((and (dict? node) (has-key? node :via))
-        (acl-et-eq? (get node :fact) target))
-      ((and (dict? node) (has-key? node :body))
-        (acl-et-any-leaf? (get node :body) target))
-      (else false))))
-
-(define
-  acl-et-any-leaf?
-  (fn
-    (nodes target)
-    (cond
-      ((= (len nodes) 0) false)
-      ((acl-et-has-leaf? (first nodes) target) true)
-      (else (acl-et-any-leaf? (rest nodes) target)))))
-
-;; True if the proof records a verified negation (deny did not fire).
-(define
-  acl-et-has-negok?
-  (fn
-    (node)
-    (cond
-      ((= node nil) false)
-      ((and (dict? node) (has-key? node :neg-ok)) true)
-      ((and (dict? node) (has-key? node :body))
-        (acl-et-any-negok? (get node :body)))
-      (else false))))
-
-(define
-  acl-et-any-negok?
-  (fn
-    (nodes)
-    (cond
-      ((= (len nodes) 0) false)
-      ((acl-et-has-negok? (first nodes)) true)
-      (else (acl-et-any-negok? (rest nodes))))))
-
-(define
-  acl-et-run-all!
-  (fn
-    ()
-    (do
-      (let
-        ((db (acl-build-db (list (acl-grant (quote u) (quote read) (quote p))))))
-        (let
-          ((e (acl-explain db (quote u) (quote read) (quote p))))
-          (do
-            (acl-et-check! "direct: allowed?" (get e :allowed?) true)
-            (acl-et-check!
-              "direct: proof root fact"
-              (get (get e :proof) :fact)
-              (list (quote permit) (quote u) (quote read) (quote p)))
-            (acl-et-check!
-              "direct: grant leaf present"
-              (acl-et-has-leaf?
-                (get e :proof)
-                (list (quote grant) (quote u) (quote read) (quote p)))
-              true)
-            (acl-et-check!
-              "direct: negation verified"
-              (acl-et-has-negok? (get e :proof))
-              true)
-            (acl-et-check!
-              "direct: reason nil when allowed"
-              (get e :reason)
-              nil))))
-      (let
-        ((db (acl-build-db (list (acl-member-of (quote alice) (quote team)) (acl-member-of (quote team) (quote org)) (acl-grant (quote org) (quote read) (quote doc))))))
-        (let
-          ((e (acl-explain db (quote alice) (quote read) (quote doc))))
-          (do
-            (acl-et-check! "group: allowed?" (get e :allowed?) true)
-            (acl-et-check!
-              "group: member_of alice leaf"
-              (acl-et-has-leaf?
-                (get e :proof)
-                (list (quote member_of) (quote alice) (quote team)))
-              true)
-            (acl-et-check!
-              "group: member_of team leaf"
-              (acl-et-has-leaf?
-                (get e :proof)
-                (list (quote member_of) (quote team) (quote org)))
-              true)
-            (acl-et-check!
-              "group: grant org leaf at base"
-              (acl-et-has-leaf?
-                (get e :proof)
-                (list (quote grant) (quote org) (quote read) (quote doc)))
-              true))))
-      (let
-        ((db (acl-build-db (list (acl-child-of (quote sec) (quote book)) (acl-grant (quote u) (quote read) (quote book))))))
-        (let
-          ((e (acl-explain db (quote u) (quote read) (quote sec))))
-          (do
-            (acl-et-check! "resource: allowed?" (get e :allowed?) true)
-            (acl-et-check!
-              "resource: child_of leaf"
-              (acl-et-has-leaf?
-                (get e :proof)
-                (list (quote child_of) (quote sec) (quote book)))
-              true)
-            (acl-et-check!
-              "resource: grant on parent leaf"
-              (acl-et-has-leaf?
-                (get e :proof)
-                (list (quote grant) (quote u) (quote read) (quote book)))
-              true))))
-      (let
-        ((db (acl-build-db (list (acl-member-of (quote bob) (quote editor)) (acl-role-grant (quote editor) (quote edit) (quote page1))))))
-        (let
-          ((e (acl-explain db (quote bob) (quote edit) (quote page1))))
-          (do
-            (acl-et-check! "role: allowed?" (get e :allowed?) true)
-            (acl-et-check!
-              "role: member_of leaf"
-              (acl-et-has-leaf?
-                (get e :proof)
-                (list (quote member_of) (quote bob) (quote editor)))
-              true)
-            (acl-et-check!
-              "role: role_grant leaf"
-              (acl-et-has-leaf?
-                (get e :proof)
-                (list
-                  (quote role_grant)
-                  (quote editor)
-                  (quote edit)
-                  (quote page1)))
-              true))))
-      (let
-        ((db (acl-build-db (list (acl-grant (quote u) (quote edit) (quote p)) (acl-deny (quote u) (quote edit) (quote p))))))
-        (let
-          ((e (acl-explain db (quote u) (quote edit) (quote p))))
-          (do
-            (acl-et-check! "deny: not allowed" (get e :allowed?) false)
-            (acl-et-check! "deny: no proof" (get e :proof) nil)
-            (acl-et-check!
-              "deny: reason root is eff_deny"
-              (get (get e :reason) :fact)
-              (list (quote eff_deny) (quote u) (quote edit) (quote p)))
-            (acl-et-check!
-              "deny: reason has deny leaf"
-              (acl-et-has-leaf?
-                (get e :reason)
-                (list (quote deny) (quote u) (quote edit) (quote p)))
-              true))))
-      (let
-        ((db (acl-build-db (list (acl-member-of (quote alice) (quote team)) (acl-grant (quote alice) (quote read) (quote doc)) (acl-deny (quote team) (quote read) (quote doc))))))
-        (let
-          ((e (acl-explain db (quote alice) (quote read) (quote doc))))
-          (do
-            (acl-et-check!
-              "inherited deny: not allowed"
-              (get e :allowed?)
-              false)
-            (acl-et-check!
-              "inherited deny: reason has member_of leaf"
-              (acl-et-has-leaf?
-                (get e :reason)
-                (list (quote member_of) (quote alice) (quote team)))
-              true)
-            (acl-et-check!
-              "inherited deny: reason has group deny leaf"
-              (acl-et-has-leaf?
-                (get e :reason)
-                (list (quote deny) (quote team) (quote read) (quote doc)))
-              true))))
-      (let
-        ((db (acl-build-db (list))))
-        (let
-          ((e (acl-explain db (quote u) (quote read) (quote p))))
-          (do
-            (acl-et-check! "no grant: not allowed" (get e :allowed?) false)
-            (acl-et-check! "no grant: proof nil" (get e :proof) nil)
-            (acl-et-check! "no grant: reason nil" (get e :reason) nil))))
-      (let
-        ((db (acl-build-db (list (acl-grant (quote u) (quote read) (quote p)) (acl-deny (quote u) (quote edit) (quote p))))))
-        (do
-          (acl-audit-clear!)
-          (acl-et-check! "audit: starts empty" (acl-audit-count) 0)
-          (acl-et-check!
-            "audit decide allowed returns true"
-            (acl-audit-decide! db (quote u) (quote read) (quote p))
-            true)
-          (acl-et-check!
-            "audit decide denied returns false"
-            (acl-audit-decide! db (quote u) (quote edit) (quote p))
-            false)
-          (acl-audit-decide! db (quote u) (quote comment) (quote p))
-          (acl-et-check!
-            "audit: count after three decisions"
-            (acl-audit-count)
-            3)
-          (acl-et-check!
-            "audit: tail size respects n"
-            (len (acl-audit-tail 2))
-            2)
-          (acl-et-check!
-            "audit: tail returns most recent"
-            (get (first (acl-audit-tail 1)) :act)
-            (quote comment))
-          (acl-et-check!
-            "audit: first record seq is 0"
-            (get (first (acl-audit-tail 3)) :seq)
-            0)
-          (acl-et-check!
-            "audit: allowed flag recorded"
-            (get (first (acl-audit-tail 3)) :allowed?)
-            true)
-          (acl-et-check!
-            "audit: serialize line count"
-            (len (acl-et-lines (acl-audit-serialize)))
-            3)
-          (acl-audit-clear!)
-          (acl-et-check!
-            "audit: clear resets count"
-            (acl-audit-count)
-            0))))))
-
-;; count newline-terminated lines in a serialized log
-(define acl-et-lines (fn (s) (acl-et-count-nl s 0 0)))
-(define
-  acl-et-count-nl
-  (fn
-    (s i n)
-    (if
-      (>= i (len s))
-      (if (= n 0) (list) (acl-et-rangelist n))
-      (acl-et-count-nl
-        s
-        (+ i 1)
-        (if (= (slice s i (+ i 1)) "\n") (+ n 1) n)))))
-(define
-  acl-et-rangelist
-  (fn
-    (n)
-    (if
-      (<= n 0)
-      (list)
-      (cons n (acl-et-rangelist (- n 1))))))
-
-(define
-  acl-explain-tests-run!
-  (fn
-    ()
-    (do
-      (set! acl-et-pass 0)
-      (set! acl-et-fail 0)
-      (set! acl-et-failures (list))
-      (acl-et-run-all!)
-      {:failures acl-et-failures :total (+ acl-et-pass acl-et-fail) :passed acl-et-pass :failed acl-et-fail})))

lib/acl/tests/fed.sx

@@ -1,273 +0,0 @@
-;; lib/acl/tests/fed.sx — Phase 4: federation (peer trust, delegation,
-;; cross-instance chains, revocation). fed-sx transport is mocked as a dict.
-
-(define acl-ft-pass 0)
-(define acl-ft-fail 0)
-(define acl-ft-failures (list))
-
-;; Name-based deep equality (host `=` compares symbols by unstable interned
-;; identity; see lib/acl/tests/explain.sx).
-(define
-  acl-ft-eq?
-  (fn
-    (a b)
-    (cond
-      ((and (list? a) (list? b))
-        (and (= (len a) (len b)) (acl-ft-eq-l? a b 0)))
-      ((and (symbol? a) (symbol? b))
-        (= (symbol->string a) (symbol->string b)))
-      (else (= a b)))))
-(define
-  acl-ft-eq-l?
-  (fn
-    (a b i)
-    (cond
-      ((>= i (len a)) true)
-      ((not (acl-ft-eq? (nth a i) (nth b i))) false)
-      (else (acl-ft-eq-l? a b (+ i 1))))))
-
-(define
-  acl-ft-check!
-  (fn
-    (name got expected)
-    (if
-      (acl-ft-eq? got expected)
-      (set! acl-ft-pass (+ acl-ft-pass 1))
-      (do
-        (set! acl-ft-fail (+ acl-ft-fail 1))
-        (append!
-          acl-ft-failures
-          (str name "\n    expected: " expected "\n    got:      " got))))))
-
-;; proof leaf walker (federated proofs reconstruct through the engine rule).
-(define
-  acl-ft-has-leaf?
-  (fn
-    (node target)
-    (cond
-      ((= node nil) false)
-      ((and (dict? node) (has-key? node :via))
-        (acl-ft-eq? (get node :fact) target))
-      ((and (dict? node) (has-key? node :body))
-        (acl-ft-any-leaf? (get node :body) target))
-      (else false))))
-(define
-  acl-ft-any-leaf?
-  (fn
-    (nodes target)
-    (cond
-      ((= (len nodes) 0) false)
-      ((acl-ft-has-leaf? (first nodes) target) true)
-      (else (acl-ft-any-leaf? (rest nodes) target)))))
-
-(define acl-ft-p? (fn (db s a r) (acl-permit? db s a r)))
-
-;; A standard federation fixture: local trusts peer alpha at "readonly", which
-;; covers read+comment. alpha delegates several capabilities to alice.
-(define
-  acl-ft-fixture
-  (fn
-    ()
-    (acl-build-db
-      (list
-        (acl-trust (quote alpha) (quote readonly))
-        (acl-level-covers (quote readonly) (quote read))
-        (acl-level-covers (quote readonly) (quote comment))
-        (acl-delegate (quote alpha) (quote alice) (quote read) (quote doc))
-        (acl-delegate (quote alpha) (quote alice) (quote edit) (quote doc))))))
-
-(define
-  acl-ft-run-all!
-  (fn
-    ()
-    (do
-      (let
-        ((db (acl-ft-fixture)))
-        (do
-          (acl-ft-check!
-            "trusted delegate, level covers action -> permit"
-            (acl-ft-p? db (quote alice) (quote read) (quote doc))
-            true)
-          (acl-ft-check!
-            "trusted delegate, level does NOT cover action -> deny"
-            (acl-ft-p? db (quote alice) (quote edit) (quote doc))
-            false)
-          (acl-ft-check!
-            "delegated but action class uncovered (comment has no delegate)"
-            (acl-ft-p? db (quote alice) (quote comment) (quote doc))
-            false)))
-      (let
-        ((db (acl-build-db (list (acl-level-covers (quote readonly) (quote read)) (acl-delegate (quote beta) (quote bob) (quote read) (quote doc))))))
-        (acl-ft-check!
-          "untrusted peer delegate -> deny"
-          (acl-ft-p? db (quote bob) (quote read) (quote doc))
-          false))
-      (let
-        ((db (acl-build-db (list (acl-trust (quote alpha) (quote readonly)) (acl-delegate (quote alpha) (quote alice) (quote read) (quote doc))))))
-        (acl-ft-check!
-          "trust but no level_covers -> deny"
-          (acl-ft-p? db (quote alice) (quote read) (quote doc))
-          false))
-      (let
-        ((db (acl-build-db (list (acl-trust (quote alpha) (quote full)) (acl-level-covers (quote full) (quote read)) (acl-delegate (quote alpha) (quote alice) (quote read) (quote doc)) (acl-delegate (quote beta) (quote bob) (quote read) (quote doc))))))
-        (do
-          (acl-ft-check!
-            "trust is per-peer: alpha's delegate applies"
-            (acl-ft-p? db (quote alice) (quote read) (quote doc))
-            true)
-          (acl-ft-check!
-            "trust not transitive: beta's delegate does not apply"
-            (acl-ft-p? db (quote bob) (quote read) (quote doc))
-            false)))
-      (let
-        ((db (acl-build-db (list (acl-trust (quote alpha) (quote full)) (acl-level-covers (quote full) (quote read)) (acl-delegate (quote alpha) (quote alice) (quote read) (quote doc)) (acl-deny (quote alice) (quote read) (quote doc))))))
-        (acl-ft-check!
-          "local deny overrides federated grant"
-          (acl-ft-p? db (quote alice) (quote read) (quote doc))
-          false))
-      (let
-        ((db (acl-build-db (list (acl-trust (quote alpha) (quote full)) (acl-level-covers (quote full) (quote read)) (acl-member-of (quote alice) (quote team)) (acl-delegate (quote alpha) (quote team) (quote read) (quote doc))))))
-        (acl-ft-check!
-          "federated grant to group reaches member"
-          (acl-ft-p? db (quote alice) (quote read) (quote doc))
-          true))
-      (let
-        ((db (acl-build-db (list (acl-trust (quote alpha) (quote full)) (acl-level-covers (quote full) (quote read)) (acl-child-of (quote sec) (quote book)) (acl-delegate (quote alpha) (quote u) (quote read) (quote book))))))
-        (acl-ft-check!
-          "federated grant on parent resource reaches child"
-          (acl-ft-p? db (quote u) (quote read) (quote sec))
-          true))
-      (let
-        ((transport {:gamma (list (acl-delegate (quote gamma) (quote carol) (quote read) (quote post))) :alpha (list (acl-delegate (quote alpha) (quote alice) (quote read) (quote doc)))}))
-        (do
-          (acl-ft-check!
-            "fetch known peer returns its delegates"
-            (len (acl-fed-fetch transport (quote alpha)))
-            1)
-          (acl-ft-check!
-            "fetch unknown peer returns empty"
-            (len (acl-fed-fetch transport (quote delta)))
-            0)
-          (acl-ft-check!
-            "collect across peers"
-            (len
-              (acl-fed-collect transport (list (quote alpha) (quote gamma))))
-            2)
-          (let
-            ((db (acl-fed-build-db (list (acl-trust (quote alpha) (quote readonly)) (acl-trust (quote gamma) (quote readonly)) (acl-level-covers (quote readonly) (quote read))) transport (list (quote alpha) (quote gamma)))))
-            (do
-              (acl-ft-check!
-                "fed-build-db: alpha delegate permits"
-                (acl-ft-p? db (quote alice) (quote read) (quote doc))
-                true)
-              (acl-ft-check!
-                "fed-build-db: gamma delegate permits"
-                (acl-ft-p? db (quote carol) (quote read) (quote post))
-                true)
-              (acl-ft-check!
-                "fed-build-db: untrusted action still denied"
-                (acl-ft-p? db (quote alice) (quote edit) (quote doc))
-                false)))))
-      (let
-        ((db (acl-build-db (list (acl-trust (quote alpha) (quote full)) (acl-level-covers (quote full) (quote read)) (acl-delegate (quote alpha) (quote alice) (quote read) (quote doc))))))
-        (do
-          (acl-ft-check!
-            "before revoke: permitted"
-            (acl-ft-p? db (quote alice) (quote read) (quote doc))
-            true)
-          (acl-revoke!
-            db
-            (acl-delegate
-              (quote alpha)
-              (quote alice)
-              (quote read)
-              (quote doc)))
-          (acl-ft-check!
-            "after delegate revoked: denied"
-            (acl-ft-p? db (quote alice) (quote read) (quote doc))
-            false)))
-      (let
-        ((db (acl-build-db (list (acl-trust (quote alpha) (quote full)) (acl-level-covers (quote full) (quote read)) (acl-delegate (quote alpha) (quote alice) (quote read) (quote doc))))))
-        (do
-          (acl-ft-check!
-            "before trust revoke: permitted"
-            (acl-ft-p? db (quote alice) (quote read) (quote doc))
-            true)
-          (acl-revoke! db (acl-trust (quote alpha) (quote full)))
-          (acl-ft-check!
-            "after trust revoked: denied"
-            (acl-ft-p? db (quote alice) (quote read) (quote doc))
-            false)))
-      (let
-        ((db (acl-build-db (list (acl-level-covers (quote full) (quote read)) (acl-delegate (quote alpha) (quote alice) (quote read) (quote doc))))))
-        (do
-          (acl-ft-check!
-            "delegate without trust: denied"
-            (acl-ft-p? db (quote alice) (quote read) (quote doc))
-            false)
-          (acl-fed-assert! db (acl-trust (quote alpha) (quote full)))
-          (acl-ft-check!
-            "trust ingested then re-checked: permitted"
-            (acl-ft-p? db (quote alice) (quote read) (quote doc))
-            true)))
-      (let
-        ((db (acl-ft-fixture)))
-        (let
-          ((e (acl-explain db (quote alice) (quote read) (quote doc))))
-          (do
-            (acl-ft-check! "federated proof allowed?" (get e :allowed?) true)
-            (acl-ft-check!
-              "federated proof has delegate leaf"
-              (acl-ft-has-leaf?
-                (get e :proof)
-                (list
-                  (quote delegate)
-                  (quote alpha)
-                  (quote alice)
-                  (quote read)
-                  (quote doc)))
-              true)
-            (acl-ft-check!
-              "federated proof has trust leaf"
-              (acl-ft-has-leaf?
-                (get e :proof)
-                (list (quote trust) (quote alpha) (quote readonly)))
-              true)
-            (acl-ft-check!
-              "federated proof has level_covers leaf"
-              (acl-ft-has-leaf?
-                (get e :proof)
-                (list (quote level_covers) (quote readonly) (quote read)))
-              true))))
-      (acl-ft-check!
-        "schema delegate arity valid"
-        (acl-fact-valid?
-          (acl-delegate (quote p) (quote s) (quote a) (quote r)))
-        true)
-      (acl-ft-check!
-        "schema trust arity valid"
-        (acl-fact-valid? (acl-trust (quote p) (quote l)))
-        true)
-      (acl-ft-check!
-        "schema peer arity valid"
-        (acl-fact-valid? (acl-peer (quote p) (quote peer)))
-        true)
-      (acl-ft-check!
-        "schema level_covers arity valid"
-        (acl-fact-valid? (acl-level-covers (quote l) (quote read)))
-        true)
-      (acl-ft-check!
-        "schema delegate bad arity invalid"
-        (acl-fact-valid? (list (quote delegate) (quote p) (quote s)))
-        false))))
-
-(define
-  acl-fed-tests-run!
-  (fn
-    ()
-    (do
-      (set! acl-ft-pass 0)
-      (set! acl-ft-fail 0)
-      (set! acl-ft-failures (list))
-      (acl-ft-run-all!)
-      {:failures acl-ft-failures :total (+ acl-ft-pass acl-ft-fail) :passed acl-ft-pass :failed acl-ft-fail})))

lib/acl/tests/harden.sx

@@ -1,228 +0,0 @@
-;; lib/acl/tests/harden.sx — adversarial / cross-phase hardening.
-;;
-;; Diamond hierarchies, conflict resolution where deny must win through every
-;; path, chain inheritance, cycle termination, multi-peer delegation, fact
-;; validation, and audit save/restore.
-;;
-;; PROVER-FREE BY DESIGN: this suite calls only acl-permit? (which runs in
-;; compiled Datalog, safe at any depth) plus pure data ops — never acl-explain /
-;; acl-prove-d. The SX-side proof reconstructor recurses, and once the kernel
-;; JIT-compiles it (after the explain/fed suites warm the process) it loops on
-;; chains deeper than ~3 (substrate JIT bug — see plan Blockers). Proof
-;; reconstruction is covered by tests/explain.sx (and federated proofs by
-;; tests/fed.sx), both of which stay under the warm-process depth threshold.
-
-(define acl-hd-pass 0)
-(define acl-hd-fail 0)
-(define acl-hd-failures (list))
-
-(define
-  acl-hd-check!
-  (fn
-    (name got expected)
-    (if
-      (= got expected)
-      (set! acl-hd-pass (+ acl-hd-pass 1))
-      (do
-        (set! acl-hd-fail (+ acl-hd-fail 1))
-        (append!
-          acl-hd-failures
-          (str name "\n    expected: " expected "\n    got:      " got))))))
-
-(define acl-hd-p? (fn (db s a r) (acl-permit? db s a r)))
-
-(define
-  acl-hd-run-all!
-  (fn
-    ()
-    (do
-      (let
-        ((grant-deny (acl-build-db (list (acl-child-of (quote r) (quote p1)) (acl-child-of (quote r) (quote p2)) (acl-grant (quote u) (quote read) (quote p1)) (acl-deny (quote u) (quote read) (quote p2)))))
-          (both-grant
-            (acl-build-db
-              (list
-                (acl-child-of (quote r) (quote p1))
-                (acl-child-of (quote r) (quote p2))
-                (acl-grant (quote u) (quote read) (quote p1))
-                (acl-grant (quote u) (quote read) (quote p2))))))
-        (do
-          (acl-hd-check!
-            "diamond resource: grant+deny parents -> deny wins"
-            (acl-hd-p? grant-deny (quote u) (quote read) (quote r))
-            false)
-          (acl-hd-check!
-            "diamond resource: both grant -> permit"
-            (acl-hd-p? both-grant (quote u) (quote read) (quote r))
-            true)
-          (acl-hd-check!
-            "diamond resource: deny does not leak to other parent"
-            (acl-hd-p? grant-deny (quote u) (quote read) (quote p1))
-            true)))
-      (let
-        ((grant-deny (acl-build-db (list (acl-member-of (quote alice) (quote g1)) (acl-member-of (quote alice) (quote g2)) (acl-grant (quote g1) (quote read) (quote doc)) (acl-deny (quote g2) (quote read) (quote doc)))))
-          (both-grant
-            (acl-build-db
-              (list
-                (acl-member-of (quote alice) (quote g1))
-                (acl-member-of (quote alice) (quote g2))
-                (acl-grant (quote g1) (quote read) (quote doc))
-                (acl-grant (quote g2) (quote read) (quote doc))))))
-        (do
-          (acl-hd-check!
-            "diamond group: grant+deny groups -> deny wins"
-            (acl-hd-p? grant-deny (quote alice) (quote read) (quote doc))
-            false)
-          (acl-hd-check!
-            "diamond group: both grant -> permit"
-            (acl-hd-p? both-grant (quote alice) (quote read) (quote doc))
-            true)))
-      (let
-        ((chain (acl-build-db (list (acl-member-of (quote a0) (quote a1)) (acl-member-of (quote a1) (quote a2)) (acl-member-of (quote a2) (quote a3)) (acl-member-of (quote a3) (quote a4)) (acl-grant (quote a4) (quote read) (quote res)))))
-          (chain-deny
-            (acl-build-db
-              (list
-                (acl-member-of (quote a0) (quote a1))
-                (acl-member-of (quote a1) (quote a2))
-                (acl-member-of (quote a2) (quote a3))
-                (acl-member-of (quote a3) (quote a4))
-                (acl-grant (quote a4) (quote read) (quote res))
-                (acl-deny (quote a0) (quote read) (quote res))))))
-        (do
-          (acl-hd-check!
-            "chain: top-group grant reaches leaf member"
-            (acl-hd-p? chain (quote a0) (quote read) (quote res))
-            true)
-          (acl-hd-check!
-            "chain: intermediate also covered"
-            (acl-hd-p? chain (quote a2) (quote read) (quote res))
-            true)
-          (acl-hd-check!
-            "chain: leaf-member deny overrides top grant"
-            (acl-hd-p? chain-deny (quote a0) (quote read) (quote res))
-            false)
-          (acl-hd-check!
-            "chain: deny on leaf does not block sibling level"
-            (acl-hd-p? chain-deny (quote a1) (quote read) (quote res))
-            true)))
-      (let
-        ((self-member (acl-build-db (list (acl-member-of (quote a) (quote a)) (acl-grant (quote a) (quote read) (quote r)))))
-          (self-child
-            (acl-build-db
-              (list
-                (acl-child-of (quote r) (quote r))
-                (acl-grant (quote u) (quote read) (quote r)))))
-          (two-cycle
-            (acl-build-db
-              (list
-                (acl-member-of (quote x) (quote y))
-                (acl-member-of (quote y) (quote x))
-                (acl-grant (quote y) (quote read) (quote r))))))
-        (do
-          (acl-hd-check!
-            "self-membership cycle terminates and grants"
-            (acl-hd-p? self-member (quote a) (quote read) (quote r))
-            true)
-          (acl-hd-check!
-            "self-child cycle terminates and grants"
-            (acl-hd-p? self-child (quote u) (quote read) (quote r))
-            true)
-          (acl-hd-check!
-            "two-node membership cycle terminates"
-            (acl-hd-p? two-cycle (quote x) (quote read) (quote r))
-            true)))
-      (let
-        ((db (acl-build-db (list (acl-trust (quote alpha) (quote full)) (acl-level-covers (quote full) (quote read)) (acl-member-of (quote alice) (quote team)) (acl-delegate (quote alpha) (quote team) (quote read) (quote doc)) (acl-deny (quote alice) (quote read) (quote doc))))))
-        (acl-hd-check!
-          "federated group grant, local member deny -> deny wins"
-          (acl-hd-p? db (quote alice) (quote read) (quote doc))
-          false))
-      (let
-        ((db (acl-build-db (list (acl-trust (quote alpha) (quote full)) (acl-level-covers (quote full) (quote read)) (acl-delegate (quote alpha) (quote bob) (quote read) (quote doc)) (acl-delegate (quote beta) (quote bob) (quote read) (quote doc))))))
-        (acl-hd-check!
-          "two peers delegate, one trusted -> permit"
-          (acl-hd-p? db (quote bob) (quote read) (quote doc))
-          true))
-      (let
-        ((db (acl-build-db (list (acl-trust (quote alpha) (quote full)) (acl-trust (quote beta) (quote full)) (acl-level-covers (quote full) (quote read)) (acl-delegate (quote alpha) (quote bob) (quote read) (quote doc)) (acl-delegate (quote beta) (quote bob) (quote read) (quote doc))))))
-        (acl-hd-check!
-          "two peers both trusted -> permit"
-          (acl-hd-p? db (quote bob) (quote read) (quote doc))
-          true))
-      (let
-        ((empty (acl-build-db (list))))
-        (acl-hd-check!
-          "empty db: nothing permitted"
-          (acl-hd-p? empty (quote u) (quote read) (quote r))
-          false))
-      (do
-        (acl-hd-check!
-          "validate: clean set has no bad facts"
-          (len
-            (acl-validate-facts
-              (list
-                (acl-grant (quote u) (quote read) (quote p))
-                (acl-member-of (quote u) (quote g))
-                (acl-delegate (quote pe) (quote u) (quote read) (quote p)))))
-          0)
-        (acl-hd-check!
-          "validate: facts-valid? true on clean set"
-          (acl-facts-valid?
-            (list (acl-grant (quote u) (quote read) (quote p))))
-          true)
-        (acl-hd-check!
-          "validate: surfaces wrong-arity and unknown predicate"
-          (len
-            (acl-validate-facts
-              (list
-                (acl-grant (quote u) (quote read) (quote p))
-                (list (quote grant) (quote u))
-                (list (quote bogus) (quote x) (quote y)))))
-          2)
-        (acl-hd-check!
-          "validate: empty set is valid"
-          (acl-facts-valid? (list))
-          true))
-      (let
-        ((db (acl-build-db (list (acl-grant (quote u) (quote read) (quote p)) (acl-deny (quote u) (quote edit) (quote p))))))
-        (do
-          (acl-audit-clear!)
-          (acl-audit-decide! db (quote u) (quote read) (quote p))
-          (acl-audit-decide! db (quote u) (quote edit) (quote p))
-          (let
-            ((snap (acl-audit-snapshot)))
-            (do
-              (acl-audit-clear!)
-              (acl-hd-check!
-                "audit: cleared count is 0"
-                (acl-audit-count)
-                0)
-              (acl-audit-restore! snap)
-              (acl-hd-check!
-                "audit: restored count"
-                (acl-audit-count)
-                2)
-              (acl-hd-check!
-                "audit: restored last act"
-                (get (first (acl-audit-tail 1)) :act)
-                (quote edit))
-              (acl-audit-decide! db (quote u) (quote comment) (quote p))
-              (acl-hd-check!
-                "audit: seq continues after restore"
-                (get (first (acl-audit-tail 1)) :seq)
-                2)
-              (acl-hd-check!
-                "audit: snapshot is an immutable copy"
-                (len (get snap :entries))
-                2)
-              (acl-audit-clear!))))))))
-
-(define
-  acl-harden-tests-run!
-  (fn
-    ()
-    (do
-      (set! acl-hd-pass 0)
-      (set! acl-hd-fail 0)
-      (set! acl-hd-failures (list))
-      (acl-hd-run-all!)
-      {:failures acl-hd-failures :total (+ acl-hd-pass acl-hd-fail) :passed acl-hd-pass :failed acl-hd-fail})))

lib/acl/tests/inherit.sx

@@ -1,202 +0,0 @@
-;; lib/acl/tests/inherit.sx — Phase 2: inheritance (groups, resource trees,
-;; role expansion) with deny-overrides.
-
-(define acl-it-pass 0)
-(define acl-it-fail 0)
-(define acl-it-failures (list))
-
-(define
-  acl-it-check!
-  (fn
-    (name got expected)
-    (if
-      (= got expected)
-      (set! acl-it-pass (+ acl-it-pass 1))
-      (do
-        (set! acl-it-fail (+ acl-it-fail 1))
-        (append!
-          acl-it-failures
-          (str name "\n    expected: " expected "\n    got:      " got))))))
-
-(define acl-it-p? (fn (db s a r) (acl-permit? db s a r)))
-
-(define
-  acl-it-run-all!
-  (fn
-    ()
-    (do
-      (let
-        ((db (acl-build-db (list (acl-member-of (quote alice) (quote team)) (acl-grant (quote team) (quote read) (quote doc))))))
-        (do
-          (acl-it-check!
-            "group grant reaches member"
-            (acl-it-p? db (quote alice) (quote read) (quote doc))
-            true)
-          (acl-it-check!
-            "group grant: non-member excluded"
-            (acl-it-p? db (quote bob) (quote read) (quote doc))
-            false)
-          (acl-it-check!
-            "group grant: wrong action"
-            (acl-it-p? db (quote alice) (quote edit) (quote doc))
-            false)))
-      (let
-        ((db (acl-build-db (list (acl-member-of (quote alice) (quote team)) (acl-member-of (quote team) (quote org)) (acl-member-of (quote org) (quote company)) (acl-grant (quote company) (quote read) (quote doc))))))
-        (do
-          (acl-it-check!
-            "deep nested group grant reaches leaf member"
-            (acl-it-p? db (quote alice) (quote read) (quote doc))
-            true)
-          (acl-it-check!
-            "intermediate group also covered"
-            (acl-it-p? db (quote team) (quote read) (quote doc))
-            true)
-          (acl-it-check!
-            "mid group org covered"
-            (acl-it-p? db (quote org) (quote read) (quote doc))
-            true)))
-      (let
-        ((db (acl-build-db (list (acl-member-of (quote a) (quote b)) (acl-member-of (quote b) (quote a)) (acl-grant (quote b) (quote read) (quote r))))))
-        (do
-          (acl-it-check!
-            "cyclic membership terminates and grants"
-            (acl-it-p? db (quote a) (quote read) (quote r))
-            true)
-          (acl-it-check!
-            "cyclic membership covers both"
-            (acl-it-p? db (quote b) (quote read) (quote r))
-            true)))
-      (let
-        ((db (acl-build-db (list (acl-child-of (quote sec) (quote chap)) (acl-child-of (quote chap) (quote book)) (acl-grant (quote u) (quote read) (quote book))))))
-        (do
-          (acl-it-check!
-            "parent grant reaches direct child"
-            (acl-it-p? db (quote u) (quote read) (quote chap))
-            true)
-          (acl-it-check!
-            "parent grant reaches deep descendant"
-            (acl-it-p? db (quote u) (quote read) (quote sec))
-            true)
-          (acl-it-check!
-            "parent grant covers parent itself"
-            (acl-it-p? db (quote u) (quote read) (quote book))
-            true)
-          (acl-it-check!
-            "child grant does not climb to parent"
-            (acl-it-p?
-              (acl-build-db
-                (list
-                  (acl-child-of (quote sec) (quote book))
-                  (acl-grant (quote u) (quote read) (quote sec))))
-              (quote u)
-              (quote read)
-              (quote book))
-            false)))
-      (let
-        ((db (acl-build-db (list (acl-member-of (quote alice) (quote team)) (acl-child-of (quote post1) (quote board)) (acl-grant (quote team) (quote comment) (quote board))))))
-        (do
-          (acl-it-check!
-            "group + resource: member on child resource"
-            (acl-it-p? db (quote alice) (quote comment) (quote post1))
-            true)
-          (acl-it-check!
-            "group + resource: member on parent resource"
-            (acl-it-p? db (quote alice) (quote comment) (quote board))
-            true)))
-      (let
-        ((db (acl-build-db (list (acl-member-of (quote bob) (quote editor)) (acl-role-grant (quote editor) (quote edit) (quote page1)) (acl-role-grant (quote editor) (quote read) (quote page1))))))
-        (do
-          (acl-it-check!
-            "role confers edit to member"
-            (acl-it-p? db (quote bob) (quote edit) (quote page1))
-            true)
-          (acl-it-check!
-            "role confers read to member"
-            (acl-it-p? db (quote bob) (quote read) (quote page1))
-            true)
-          (acl-it-check!
-            "role: capability not in tuple denied"
-            (acl-it-p? db (quote bob) (quote moderate) (quote page1))
-            false)
-          (acl-it-check!
-            "role: non-member excluded"
-            (acl-it-p? db (quote eve) (quote edit) (quote page1))
-            false)))
-      (let
-        ((db (acl-build-db (list (acl-member-of (quote bob) (quote editor)) (acl-child-of (quote draft) (quote page1)) (acl-role-grant (quote editor) (quote edit) (quote page1))))))
-        (acl-it-check!
-          "role grant flows to child resource"
-          (acl-it-p? db (quote bob) (quote edit) (quote draft))
-          true))
-      (let
-        ((db (acl-build-db (list (acl-member-of (quote alice) (quote team)) (acl-grant (quote team) (quote read) (quote doc)) (acl-deny (quote alice) (quote read) (quote doc))))))
-        (acl-it-check!
-          "explicit deny beats inherited group allow"
-          (acl-it-p? db (quote alice) (quote read) (quote doc))
-          false))
-      (let
-        ((db (acl-build-db (list (acl-member-of (quote alice) (quote team)) (acl-grant (quote alice) (quote read) (quote doc)) (acl-deny (quote team) (quote read) (quote doc))))))
-        (do
-          (acl-it-check!
-            "group deny inherits and overrides direct grant"
-            (acl-it-p? db (quote alice) (quote read) (quote doc))
-            false)
-          (acl-it-check!
-            "group deny: another member also blocked"
-            (acl-it-p? db (quote team) (quote read) (quote doc))
-            false)))
-      (let
-        ((db (acl-build-db (list (acl-child-of (quote sec) (quote book)) (acl-grant (quote u) (quote read) (quote sec)) (acl-deny (quote u) (quote read) (quote book))))))
-        (acl-it-check!
-          "ancestor deny overrides descendant grant"
-          (acl-it-p? db (quote u) (quote read) (quote sec))
-          false))
-      (let
-        ((db (acl-build-db (list (acl-member-of (quote alice) (quote team)) (acl-grant (quote team) (quote read) (quote doc)) (acl-grant (quote team) (quote edit) (quote doc)) (acl-deny (quote alice) (quote edit) (quote doc))))))
-        (do
-          (acl-it-check!
-            "deny on edit leaves inherited read intact"
-            (acl-it-p? db (quote alice) (quote read) (quote doc))
-            true)
-          (acl-it-check!
-            "deny on edit blocks edit"
-            (acl-it-p? db (quote alice) (quote edit) (quote doc))
-            false)))
-      (let
-        ((db (acl-build-db (list (acl-member-of (quote alice) (quote team)) (acl-deny (quote team) (quote read) (quote doc))))))
-        (acl-it-check!
-          "inherited deny, no grant: denied"
-          (acl-it-p? db (quote alice) (quote read) (quote doc))
-          false))
-      (let
-        ((db (acl-build-db (list (acl-child-of (quote a) (quote root)) (acl-child-of (quote b) (quote root)) (acl-grant (quote u) (quote read) (quote root)) (acl-deny (quote u) (quote read) (quote a))))))
-        (do
-          (acl-it-check!
-            "deny on sibling a blocks a"
-            (acl-it-p? db (quote u) (quote read) (quote a))
-            false)
-          (acl-it-check!
-            "deny on sibling a leaves b permitted"
-            (acl-it-p? db (quote u) (quote read) (quote b))
-            true)
-          (acl-it-check!
-            "root itself still permitted"
-            (acl-it-p? db (quote u) (quote read) (quote root))
-            true)))
-      (let
-        ((db (acl-build-db (list (acl-grant (quote x) (quote read) (quote y))))))
-        (acl-it-check!
-          "direct grant under inheritance ruleset"
-          (acl-it-p? db (quote x) (quote read) (quote y))
-          true)))))
-
-(define
-  acl-inherit-tests-run!
-  (fn
-    ()
-    (do
-      (set! acl-it-pass 0)
-      (set! acl-it-fail 0)
-      (set! acl-it-failures (list))
-      (acl-it-run-all!)
-      {:failures acl-it-failures :total (+ acl-it-pass acl-it-fail) :passed acl-it-pass :failed acl-it-fail})))

lib/apl/conformance.conf

@@ -1,63 +0,0 @@
-# APL conformance config — sourced by lib/guest/conformance.sh.
-
-LANG_NAME=apl
-MODE=counters
-COUNTERS_PASS=apl-test-pass
-COUNTERS_FAIL=apl-test-fail
-TIMEOUT_PER_SUITE=300
-
-PRELOADS=(
-  spec/stdlib.sx
-  lib/r7rs.sx
-  lib/apl/runtime.sx
-  lib/apl/tokenizer.sx
-  lib/apl/parser.sx
-  lib/apl/transpile.sx
-  lib/apl/test-harness.sx
-)
-
-SUITES=(
-  "structural:lib/apl/tests/structural.sx"
-  "operators:lib/apl/tests/operators.sx"
-  "dfn:lib/apl/tests/dfn.sx"
-  "tradfn:lib/apl/tests/tradfn.sx"
-  "valence:lib/apl/tests/valence.sx"
-  "programs:lib/apl/tests/programs.sx"
-  "system:lib/apl/tests/system.sx"
-  "idioms:lib/apl/tests/idioms.sx"
-  "eval-ops:lib/apl/tests/eval-ops.sx"
-  "pipeline:lib/apl/tests/pipeline.sx"
-)
-
-emit_scoreboard_json() {
-  local n=${#GC_NAMES[@]} i sep
-  printf '{\n'
-  printf '  "suites": {\n'
-  for ((i=0; i<n; i++)); do
-    sep=","; [ $i -eq $((n-1)) ] && sep=""
-    printf '    "%s": {"pass": %d, "fail": %d}%s\n' \
-      "${GC_NAMES[$i]}" "${GC_PASS[$i]}" "${GC_FAIL[$i]}" "$sep"
-  done
-  printf '  },\n'
-  printf '  "total_pass": %d,\n' "$GC_TOTAL_PASS"
-  printf '  "total_fail": %d,\n' "$GC_TOTAL_FAIL"
-  printf '  "total": %d\n' "$GC_TOTAL"
-  printf '}\n'
-}
-
-emit_scoreboard_md() {
-  local n=${#GC_NAMES[@]} i
-  printf '# APL Conformance Scoreboard\n\n'
-  printf '_Generated by `lib/apl/conformance.sh`_\n\n'
-  printf '| Suite | Pass | Fail | Total |\n'
-  printf '|-------|-----:|-----:|------:|\n'
-  for ((i=0; i<n; i++)); do
-    printf '| %s | %d | %d | %d |\n' \
-      "${GC_NAMES[$i]}" "${GC_PASS[$i]}" "${GC_FAIL[$i]}" "${GC_TOTAL_S[$i]}"
-  done
-  printf '| **Total** | **%d** | **%d** | **%d** |\n' "$GC_TOTAL_PASS" "$GC_TOTAL_FAIL" "$GC_TOTAL"
-  printf '\n'
-  printf '## Notes\n\n'
-  printf '%s\n' '- Suites use the standard `apl-test name got expected` framework loaded against `lib/apl/runtime.sx` + `lib/apl/transpile.sx`.'
-  printf '%s\n' '- `lib/apl/tests/parse.sx` and `lib/apl/tests/scalar.sx` use their own self-contained frameworks and are excluded from this scoreboard.'
-}

lib/apl/conformance.sh

@@ -1,5 +1,116 @@
 #!/usr/bin/env bash
-# lib/apl/conformance.sh — APL conformance via the shared guest driver.
+# lib/apl/conformance.sh — run APL test suites, emit scoreboard.json + scoreboard.md.
-# Config lives in lib/apl/conformance.conf (MODE=counters). Override the binary
+
-# with SX_SERVER=path/to/sx_server.exe bash lib/apl/conformance.sh
+set -uo pipefail
-exec bash "$(dirname "$0")/../guest/conformance.sh" "$(dirname "$0")/conformance.conf" "$@"
+cd "$(git rev-parse --show-toplevel)"
+
+SX_SERVER="${SX_SERVER:-/root/rose-ash/hosts/ocaml/_build/default/bin/sx_server.exe}"
+if [ ! -x "$SX_SERVER" ]; then
+  SX_SERVER="hosts/ocaml/_build/default/bin/sx_server.exe"
+fi
+if [ ! -x "$SX_SERVER" ]; then
+  echo "ERROR: sx_server.exe not found." >&2
+  exit 1
+fi
+
+SUITES=(structural operators dfn tradfn valence programs system idioms eval-ops pipeline)
+
+OUT_JSON="lib/apl/scoreboard.json"
+OUT_MD="lib/apl/scoreboard.md"
+
+run_suite() {
+  local suite=$1
+  local file="lib/apl/tests/${suite}.sx"
+  local TMP
+  TMP=$(mktemp)
+  cat > "$TMP" << EPOCHS
+(epoch 1)
+(load "spec/stdlib.sx")
+(load "lib/r7rs.sx")
+(load "lib/apl/runtime.sx")
+(load "lib/apl/tokenizer.sx")
+(load "lib/apl/parser.sx")
+(load "lib/apl/transpile.sx")
+(epoch 2)
+(eval "(define apl-test-pass 0)")
+(eval "(define apl-test-fail 0)")
+(eval "(define apl-test (fn (name got expected) (if (= got expected) (set! apl-test-pass (+ apl-test-pass 1)) (set! apl-test-fail (+ apl-test-fail 1)))))")
+(epoch 3)
+(load "${file}")
+(epoch 4)
+(eval "(list apl-test-pass apl-test-fail)")
+EPOCHS
+
+  local OUTPUT
+  OUTPUT=$(timeout 300 "$SX_SERVER" < "$TMP" 2>/dev/null)
+  rm -f "$TMP"
+
+  local LINE
+  LINE=$(echo "$OUTPUT" | awk '/^\(ok-len 4 / {getline; print; exit}')
+  if [ -z "$LINE" ]; then
+    LINE=$(echo "$OUTPUT" | grep -E '^\(ok 4 \([0-9]+ [0-9]+\)\)' | tail -1 \
+            | sed -E 's/^\(ok 4 //; s/\)$//')
+  fi
+
+  local P F
+  P=$(echo "$LINE" | sed -E 's/^\(([0-9]+) ([0-9]+)\).*/\1/')
+  F=$(echo "$LINE" | sed -E 's/^\(([0-9]+) ([0-9]+)\).*/\2/')
+  P=${P:-0}
+  F=${F:-0}
+  echo "${P} ${F}"
+}
+
+declare -A SUITE_PASS
+declare -A SUITE_FAIL
+TOTAL_PASS=0
+TOTAL_FAIL=0
+
+echo "Running APL conformance suite..." >&2
+for s in "${SUITES[@]}"; do
+  read -r p f < <(run_suite "$s")
+  SUITE_PASS[$s]=$p
+  SUITE_FAIL[$s]=$f
+  TOTAL_PASS=$((TOTAL_PASS + p))
+  TOTAL_FAIL=$((TOTAL_FAIL + f))
+  printf "  %-12s %d/%d\n" "$s" "$p" "$((p+f))" >&2
+done
+
+# scoreboard.json
+{
+  printf '{\n'
+  printf '  "suites": {\n'
+  first=1
+  for s in "${SUITES[@]}"; do
+    if [ $first -eq 0 ]; then printf ',\n'; fi
+    printf '    "%s": {"pass": %d, "fail": %d}' "$s" "${SUITE_PASS[$s]}" "${SUITE_FAIL[$s]}"
+    first=0
+  done
+  printf '\n  },\n'
+  printf '  "total_pass": %d,\n' "$TOTAL_PASS"
+  printf '  "total_fail": %d,\n' "$TOTAL_FAIL"
+  printf '  "total": %d\n' "$((TOTAL_PASS + TOTAL_FAIL))"
+  printf '}\n'
+} > "$OUT_JSON"
+
+# scoreboard.md
+{
+  printf '# APL Conformance Scoreboard\n\n'
+  printf '_Generated by `lib/apl/conformance.sh`_\n\n'
+  printf '| Suite | Pass | Fail | Total |\n'
+  printf '|-------|-----:|-----:|------:|\n'
+  for s in "${SUITES[@]}"; do
+    p=${SUITE_PASS[$s]}
+    f=${SUITE_FAIL[$s]}
+    printf '| %s | %d | %d | %d |\n' "$s" "$p" "$f" "$((p+f))"
+  done
+  printf '| **Total** | **%d** | **%d** | **%d** |\n' "$TOTAL_PASS" "$TOTAL_FAIL" "$((TOTAL_PASS + TOTAL_FAIL))"
+  printf '\n'
+  printf '## Notes\n\n'
+  printf '%s\n' '- Suites use the standard `apl-test name got expected` framework loaded against `lib/apl/runtime.sx` + `lib/apl/transpile.sx`.'
+  printf '%s\n' '- `lib/apl/tests/parse.sx` and `lib/apl/tests/scalar.sx` use their own self-contained frameworks and are excluded from this scoreboard.'
+} > "$OUT_MD"
+
+echo "Wrote $OUT_JSON and $OUT_MD" >&2
+echo "Total: $TOTAL_PASS pass, $TOTAL_FAIL fail" >&2
+
+[ "$TOTAL_FAIL" -eq 0 ]

lib/apl/scoreboard.json

@@ -9,9 +9,9 @@
     "system": {"pass": 13, "fail": 0},
     "idioms": {"pass": 64, "fail": 0},
     "eval-ops": {"pass": 14, "fail": 0},
-    "pipeline": {"pass": 152, "fail": 0}
+    "pipeline": {"pass": 40, "fail": 0}
   },
-  "total_pass": 562,
+  "total_pass": 450,
   "total_fail": 0,
-  "total": 562
+  "total": 450
 }

lib/apl/scoreboard.md

@@ -13,8 +13,8 @@ _Generated by `lib/apl/conformance.sh`_
 | system | 13 | 0 | 13 |
 | idioms | 64 | 0 | 64 |
 | eval-ops | 14 | 0 | 14 |
-| pipeline | 152 | 0 | 152 |
+| pipeline | 40 | 0 | 40 |
-| **Total** | **562** | **0** | **562** |
+| **Total** | **450** | **0** | **450** |
 
 ## Notes
 

lib/apl/test-harness.sx

@@ -1,15 +0,0 @@
-; lib/apl/test-harness.sx — counters + assertion fn for the shared conformance
-; driver (lib/guest/conformance.sh, MODE=counters). Loaded as a PRELOAD so each
-; suite starts from a fresh 0/0; suites call (apl-test name got expected).
-
-(define apl-test-pass 0)
-(define apl-test-fail 0)
-
-(define
-  apl-test
-  (fn
-    (name got expected)
-    (if
-      (= got expected)
-      (set! apl-test-pass (+ apl-test-pass 1))
-      (set! apl-test-fail (+ apl-test-fail 1)))))

lib/commerce/api.sx

@@ -1,56 +0,0 @@
-;; lib/commerce/api.sx — public commerce surface.
-;;
-;; A session bundles a pricing context with a cart: {:ctx CTX :cart CART}.
-;; All operations are pure and return a new session. The total and the
-;; per-line breakdown are deterministic functions of (ctx, cart).
-;;
-;; commerce-checkout is a Phase-3 stub — the order lifecycle is a durable
-;; flow that suspends at the SumUp payment boundary.
-
-(define commerce-session (fn (ctx) {:cart empty-cart :ctx ctx}))
-
-(define commerce-ctx (fn (sess) (get sess :ctx)))
-(define commerce-cart (fn (sess) (get sess :cart)))
-(define commerce-lines (fn (sess) (cart-lines (get sess :cart))))
-(define commerce-count (fn (sess) (cart-count (get sess :cart))))
-
-(define
-  commerce-add
-  (fn
-    (sess sku variant qty)
-    (assoc sess :cart (cart-add (get sess :cart) sku variant qty))))
-
-(define
-  commerce-remove
-  (fn
-    (sess sku variant)
-    (assoc sess :cart (cart-remove (get sess :cart) sku variant))))
-
-(define
-  commerce-set-qty
-  (fn
-    (sess sku variant qty)
-    (assoc sess :cart (cart-set-qty (get sess :cart) sku variant qty))))
-
-;; True when the sku exists in the session's catalog snapshot.
-(define
-  commerce-can-add?
-  (fn (sess sku) (catalog-has? (ctx-catalog (get sess :ctx)) sku)))
-
-(define
-  commerce-total
-  (fn (sess) (cart-total (get sess :ctx) (get sess :cart))))
-
-;; Per-line audit breakdown — the "which line contributed what" view.
-(define
-  line-detail
-  (fn (ctx line) (let ((cat (ctx-catalog ctx))) {:sku (line-sku line) :unit (line-unit-price cat (line-sku line) (line-variant line)) :qty (line-qty line) :variant (line-variant line) :extended (line-extended cat line) :tax (line-tax ctx line)})))
-
-(define
-  commerce-explain
-  (fn
-    (sess)
-    (map (fn (l) (line-detail (get sess :ctx) l)) (get sess :cart))))
-
-;; Phase 3 — order lifecycle flow (reserve -> pay -> fulfil) lands here.
-(define commerce-checkout (fn (sess) {:note "order lifecycle flow lands in Phase 3" :phase 3 :status :not-implemented}))

lib/commerce/attribution.sx

@@ -1,100 +0,0 @@
-;; lib/commerce/attribution.sx — line-level discount attribution.
-;;
-;; The briefing's marquee backward query: "which line item triggered this
-;; discount?". promo.sx computes discount amounts at the class/order level;
-;; this layer answers the *scope* question relationally and in both directions:
-;;   forward  — which lines does code C touch?   (lines-for-code)
-;;   backward — which codes touch this line?     (codes-for-line)
-;; Both are the same relation promo-toucheso run with different vars bound.
-;;
-;; A :fixed promo is order-level (touches no single line); query those with
-;; order-level-codes. Only promos that actually apply (amount > 0) touch lines.
-
-;; Lines whose sku is in product-class `cls`.
-(define
-  class-lines
-  (fn
-    (ctx cart cls)
-    (filter
-      (fn (l) (= (catalog-class (ctx-catalog ctx) (line-sku l)) cls))
-      cart)))
-
-;; The lines a promo applies to (its scope). :fixed is order-level → no lines.
-(define
-  promo-lines
-  (fn
-    (ctx cart p)
-    (let
-      ((k (promo-kind p)))
-      (cond
-        ((= k :percent) (class-lines ctx cart (nth p 2)))
-        ((= k :member)
-          (if
-            (= (get ctx :customer) :member)
-            (class-lines ctx cart (nth p 2))
-            (list)))
-        ((= k :bundle)
-          (filter (fn (l) (= (line-sku l) (nth p 2))) cart))
-        (:else (list))))))
-
-;; Relation: promo `code` touches `line`. Only applying promos (amount > 0)
-;; touch anything, so an inapplicable promo contributes no pairs.
-(define
-  promo-toucheso
-  (fn
-    (ctx cart ruleset code line)
-    (fresh
-      (p)
-      (membero p ruleset)
-      (project
-        (p)
-        (if
-          (> (promo-amount ctx cart p) 0)
-          (mk-conj
-            (== code (promo-code p))
-            (membero line (promo-lines ctx cart p)))
-          fail)))))
-
-;; --- query helpers ---
-
-(define
-  lines-for-code
-  (fn
-    (ctx cart ruleset code)
-    (run* line (promo-toucheso ctx cart ruleset code line))))
-
-(define
-  codes-for-line
-  (fn
-    (ctx cart ruleset line)
-    (run* code (promo-toucheso ctx cart ruleset code line))))
-
-(define
-  line-touched-by?
-  (fn
-    (ctx cart ruleset code line)
-    (not
-      (empty?
-        (run
-          1
-          c
-          (mk-conj (promo-toucheso ctx cart ruleset code line) (== c true)))))))
-
-;; Applying order-level (:fixed) promos — discounts with no single line.
-(define
-  order-level-codes
-  (fn
-    (ctx cart ruleset)
-    (run*
-      code
-      (fresh
-        (p)
-        (membero p ruleset)
-        (project
-          (p)
-          (if
-            (and
-              (> (promo-amount ctx cart p) 0)
-              (= (promo-kind p) :fixed))
-            (== code (promo-code p))
-            fail))))))

lib/commerce/cart.sx

@@ -1,86 +0,0 @@
-;; lib/commerce/cart.sx — cart as an ordered list of line items.
-;;
-;; A cart is a native list of lines; a line is (list sku variant qty).
-;; All operations are pure: they return a new cart, never mutate. Line
-;; order is insertion order (stable) so totals are reproducible.
-;;
-;; cart-lineo is the relational view — because a line *is* a (sku variant qty)
-;; tuple, membero queries the cart directly, forward or backward.
-
-(define empty-cart (list))
-
-(define make-line (fn (sku variant qty) (list sku variant qty)))
-(define line-sku (fn (l) (nth l 0)))
-(define line-variant (fn (l) (nth l 1)))
-(define line-qty (fn (l) (nth l 2)))
-
-(define
-  same-line?
-  (fn
-    (l sku variant)
-    (and (= (line-sku l) sku) (= (line-variant l) variant))))
-
-(define
-  cart-qty
-  (fn
-    (cart sku variant)
-    (let
-      ((m (filter (fn (l) (same-line? l sku variant)) cart)))
-      (if (empty? m) 0 (line-qty (first m))))))
-
-(define
-  cart-remove
-  (fn
-    (cart sku variant)
-    (filter (fn (l) (not (same-line? l sku variant))) cart)))
-
-;; Add qty units; merges into an existing (sku,variant) line in place,
-;; otherwise appends a new line at the end.
-(define
-  cart-add
-  (fn
-    (cart sku variant qty)
-    (let
-      ((existing (cart-qty cart sku variant)))
-      (if
-        (= existing 0)
-        (append cart (list (make-line sku variant qty)))
-        (map
-          (fn
-            (l)
-            (if
-              (same-line? l sku variant)
-              (make-line sku variant (+ existing qty))
-              l))
-          cart)))))
-
-;; Set the absolute quantity; qty <= 0 removes the line.
-(define
-  cart-set-qty
-  (fn
-    (cart sku variant qty)
-    (if
-      (<= qty 0)
-      (cart-remove cart sku variant)
-      (if
-        (= (cart-qty cart sku variant) 0)
-        (append cart (list (make-line sku variant qty)))
-        (map
-          (fn
-            (l)
-            (if (same-line? l sku variant) (make-line sku variant qty) l))
-          cart)))))
-
-(define cart-empty? (fn (cart) (empty? cart)))
-(define cart-lines (fn (cart) cart))
-(define cart-skus (fn (cart) (map line-sku cart)))
-
-;; Total number of units across all lines.
-(define
-  cart-count
-  (fn (cart) (reduce (fn (acc l) (+ acc (line-qty l))) 0 cart)))
-
-;; Relational view of cart lines.
-(define
-  cart-lineo
-  (fn (cart sku variant qty) (membero (list sku variant qty) cart)))

lib/commerce/catalog.sx

@@ -1,83 +0,0 @@
-;; lib/commerce/catalog.sx — catalog snapshot + relational accessors.
-;;
-;; A catalog snapshot is an immutable dict:
-;;   {:products (list (list sku price class) ...)
-;;    :variants (list (list sku variant delta) ...)
-;;    :stock    (list (list sku variant qty) ...)}
-;;
-;; Money is integer minor units (pence/cents). class is a keyword product
-;; class consumed later by tax and promotion relations. delta is a signed
-;; price adjustment for a variant; qty is on-hand stock for (sku,variant).
-;;
-;; Accessor relations take the snapshot as the first argument and are fully
-;; multidirectional: (producto cat "widget" p c) binds p,c forward;
-;; (producto cat s 1000 c) enumerates every sku priced 1000 backward.
-
-(define empty-catalog {:products (list) :stock (list) :variants (list)})
-
-(define make-catalog (fn (products variants stock) {:products products :stock stock :variants variants}))
-
-(define cat-products (fn (cat) (get cat :products)))
-(define cat-variants (fn (cat) (get cat :variants)))
-(define cat-stock (fn (cat) (get cat :stock)))
-
-;; --- core fact relations ---
-
-(define
-  producto
-  (fn
-    (cat sku price class)
-    (membero (list sku price class) (get cat :products))))
-
-(define
-  varianto
-  (fn
-    (cat sku variant delta)
-    (membero (list sku variant delta) (get cat :variants))))
-
-(define
-  stocko
-  (fn
-    (cat sku variant qty)
-    (membero (list sku variant qty) (get cat :stock))))
-
-;; --- derived relations ---
-
-(define
-  priceo
-  (fn (cat sku price) (fresh (c) (producto cat sku price c))))
-
-(define
-  classo
-  (fn (cat sku class) (fresh (p) (producto cat sku p class))))
-
-;; Effective unit price of a (sku,variant): base + variant delta.
-(define
-  unit-priceo
-  (fn
-    (cat sku variant price)
-    (fresh
-      (base delta)
-      (priceo cat sku base)
-      (varianto cat sku variant delta)
-      (pluso-i base delta price))))
-
-;; --- deterministic lookups (first solution under fixed fact order) ---
-
-(define
-  catalog-price
-  (fn
-    (cat sku)
-    (let
-      ((rs (run 1 p (priceo cat sku p))))
-      (if (empty? rs) nil (first rs)))))
-
-(define
-  catalog-class
-  (fn
-    (cat sku)
-    (let
-      ((rs (run 1 c (classo cat sku c))))
-      (if (empty? rs) nil (first rs)))))
-
-(define catalog-has? (fn (cat sku) (not (nil? (catalog-price cat sku)))))

lib/commerce/conformance.sh

@@ -1,153 +0,0 @@
-#!/usr/bin/env bash
-# lib/commerce/conformance.sh — run commerce test suites in one sx_server
-# process per suite, emit scoreboard.json + scoreboard.md.
-#
-# commerce-on-sx builds pricing/promotion as miniKanren relations, so every
-# suite loads the miniKanren stack first, then the commerce modules.
-
-set -uo pipefail
-cd "$(git rev-parse --show-toplevel)"
-
-SX_SERVER="${SX_SERVER:-/root/rose-ash/hosts/ocaml/_build/default/bin/sx_server.exe}"
-if [ ! -x "$SX_SERVER" ]; then
-  SX_SERVER="hosts/ocaml/_build/default/bin/sx_server.exe"
-fi
-if [ ! -x "$SX_SERVER" ]; then
-  echo "ERROR: sx_server.exe not found." >&2
-  exit 1
-fi
-
-SUITES=(catalog cart price api promo stack quote ledger order recon federation attribution payment window nettax stock refund integration)
-
-OUT_JSON="lib/commerce/scoreboard.json"
-OUT_MD="lib/commerce/scoreboard.md"
-
-run_suite() {
-  local suite=$1
-  local file="lib/commerce/tests/${suite}.sx"
-  local TMP
-  TMP=$(mktemp)
-  cat > "$TMP" << EPOCHS
-(epoch 1)
-(load "spec/stdlib.sx")
-(load "lib/r7rs.sx")
-(load "lib/guest/match.sx")
-(load "lib/minikanren/unify.sx")
-(load "lib/minikanren/stream.sx")
-(load "lib/minikanren/goals.sx")
-(load "lib/minikanren/fresh.sx")
-(load "lib/minikanren/conde.sx")
-(load "lib/minikanren/run.sx")
-(load "lib/minikanren/relations.sx")
-(load "lib/minikanren/project.sx")
-(load "lib/minikanren/intarith.sx")
-(load "lib/minikanren/matche.sx")
-(load "lib/minikanren/defrel.sx")
-(load "lib/persist/event.sx")
-(load "lib/persist/backend.sx")
-(load "lib/persist/log.sx")
-(load "lib/persist/kv.sx")
-(load "lib/persist/idempotency.sx")
-(load "lib/guest/lex.sx")
-(load "lib/guest/reflective/env.sx")
-(load "lib/guest/reflective/quoting.sx")
-(load "lib/scheme/parser.sx")
-(load "lib/scheme/eval.sx")
-(load "lib/scheme/runtime.sx")
-(load "lib/flow/spec.sx")
-(load "lib/flow/store.sx")
-(load "lib/flow/remote.sx")
-(load "lib/flow/host.sx")
-(load "lib/flow/api.sx")
-(load "lib/commerce/catalog.sx")
-(load "lib/commerce/cart.sx")
-(load "lib/commerce/price.sx")
-(load "lib/commerce/api.sx")
-(load "lib/commerce/promo.sx")
-(load "lib/commerce/stack.sx")
-(load "lib/commerce/quote.sx")
-(load "lib/commerce/window.sx")
-(load "lib/commerce/nettax.sx")
-(load "lib/commerce/stock.sx")
-(load "lib/commerce/ledger.sx")
-(load "lib/commerce/order.sx")
-(load "lib/commerce/refund.sx")
-(load "lib/commerce/payment.sx")
-(load "lib/commerce/recon.sx")
-(load "lib/commerce/federation.sx")
-(load "lib/commerce/attribution.sx")
-(epoch 2)
-(eval "(define ct-pass 0)")
-(eval "(define ct-fail 0)")
-(eval "(define ct-fails (list))")
-(eval "(define commerce-test (fn (name got expected) (if (= got expected) (set! ct-pass (+ ct-pass 1)) (begin (set! ct-fail (+ ct-fail 1)) (append! ct-fails name)))))")
-(epoch 3)
-(load "${file}")
-(epoch 4)
-(eval "(list ct-pass ct-fail)")
-(eval "ct-fails")
-EPOCHS
-
-  local OUTPUT
-  OUTPUT=$(timeout 560 "$SX_SERVER" < "$TMP" 2>/dev/null)
-  rm -f "$TMP"
-
-  # The (list ct-pass ct-fail) result follows its (ok-len 2 N) ack line.
-  local LINE
-  LINE=$(echo "$OUTPUT" | grep -oE '^\([0-9]+ [0-9]+\)$' | tail -1)
-  local P F
-  P=$(echo "$LINE" | sed -E 's/^\(([0-9]+) ([0-9]+)\)$/\1/')
-  F=$(echo "$LINE" | sed -E 's/^\(([0-9]+) ([0-9]+)\)$/\2/')
-  P=${P:-0}
-  F=${F:-0}
-  echo "${P} ${F}"
-}
-
-declare -A SUITE_PASS
-declare -A SUITE_FAIL
-TOTAL_PASS=0
-TOTAL_FAIL=0
-
-echo "Running commerce conformance suite..." >&2
-for s in "${SUITES[@]}"; do
-  read -r p f < <(run_suite "$s")
-  SUITE_PASS[$s]=$p
-  SUITE_FAIL[$s]=$f
-  TOTAL_PASS=$((TOTAL_PASS + p))
-  TOTAL_FAIL=$((TOTAL_FAIL + f))
-  printf "  %-12s %d/%d\n" "$s" "$p" "$((p+f))" >&2
-done
-
-{
-  printf '{\n'
-  printf '  "suites": {\n'
-  first=1
-  for s in "${SUITES[@]}"; do
-    if [ $first -eq 0 ]; then printf ',\n'; fi
-    printf '    "%s": {"pass": %d, "fail": %d}' "$s" "${SUITE_PASS[$s]}" "${SUITE_FAIL[$s]}"
-    first=0
-  done
-  printf '\n  },\n'
-  printf '  "total_pass": %d,\n' "$TOTAL_PASS"
-  printf '  "total_fail": %d,\n' "$TOTAL_FAIL"
-  printf '  "total": %d\n' "$((TOTAL_PASS + TOTAL_FAIL))"
-  printf '}\n'
-} > "$OUT_JSON"
-
-{
-  printf '# commerce Conformance Scoreboard\n\n'
-  printf '_Generated by `lib/commerce/conformance.sh`_\n\n'
-  printf '| Suite | Pass | Fail | Total |\n'
-  printf '|-------|-----:|-----:|------:|\n'
-  for s in "${SUITES[@]}"; do
-    p=${SUITE_PASS[$s]}
-    f=${SUITE_FAIL[$s]}
-    printf '| %s | %d | %d | %d |\n' "$s" "$p" "$f" "$((p+f))"
-  done
-  printf '| **Total** | **%d** | **%d** | **%d** |\n' "$TOTAL_PASS" "$TOTAL_FAIL" "$((TOTAL_PASS + TOTAL_FAIL))"
-} > "$OUT_MD"
-
-echo "Wrote $OUT_JSON and $OUT_MD" >&2
-echo "Total: $TOTAL_PASS pass, $TOTAL_FAIL fail" >&2
-
-[ "$TOTAL_FAIL" -eq 0 ]

lib/commerce/federation.sx

@@ -1,86 +0,0 @@
-;; lib/commerce/federation.sx — cross-instance catalog (federated marketplace).
-;;
-;; STUB: instances are registered in-process; there is no real network or
-;; ActivityPub transport here (that lives in the federation service). The point
-;; is the relational model: a federated catalog is just the UNION of each
-;; instance's product facts, tagged with origin, so the same miniKanren
-;; relations answer cross-instance questions — "which instances sell this sku?",
-;; "which is cheapest?" — as backward queries, no new query engine.
-
-(define federation-stub? true)
-
-(define make-federation (fn (instance cat) {:instances (list (list instance cat))}))
-
-(define
-  federation-add
-  (fn
-    (fed instance cat)
-    (assoc
-      fed
-      :instances (append (get fed :instances) (list (list instance cat))))))
-
-(define federation-instances (fn (fed) (map first (get fed :instances))))
-
-;; Flatten to (instance sku price class) origin-tagged tuples.
-(define
-  fed-products
-  (fn
-    (fed)
-    (reduce
-      (fn
-        (acc pair)
-        (let
-          ((instance (first pair)) (cat (nth pair 1)))
-          (append
-            acc
-            (map (fn (p) (cons instance p)) (get cat :products)))))
-      (list)
-      (get fed :instances))))
-
-;; --- relations over the federated catalog (multidirectional) ---
-
-(define
-  fed-producto
-  (fn
-    (fed instance sku price class)
-    (membero (list instance sku price class) (fed-products fed))))
-
-(define
-  fed-priceo
-  (fn
-    (fed instance sku price)
-    (fresh (c) (fed-producto fed instance sku price c))))
-
-;; --- query helpers ---
-
-;; Which instances carry a sku? (backward query)
-(define
-  instances-with-sku
-  (fn (fed sku) (run* inst (fresh (p c) (fed-producto fed inst sku p c)))))
-
-;; All (price instance) offers for a sku, in federation order.
-(define
-  sku-offers
-  (fn
-    (fed sku)
-    (run*
-      pair
-      (fresh
-        (inst p c)
-        (fed-producto fed inst sku p c)
-        (== pair (list p inst))))))
-
-;; Cheapest (price instance) for a sku — the deterministic selection layer.
-(define
-  cheapest-offer
-  (fn
-    (fed sku)
-    (let
-      ((offers (sku-offers fed sku)))
-      (if
-        (empty? offers)
-        nil
-        (reduce
-          (fn (best x) (if (< (first x) (first best)) x best))
-          (first offers)
-          offers)))))

lib/commerce/ledger.sx

@@ -1,176 +0,0 @@
-;; lib/commerce/ledger.sx — the order ledger as a persist event stream.
-;;
-;; Each order is an append-only stream "order/<id>" in a persist backend.
-;; Order state is never stored directly — it is a projection (fold) over the
-;; events, so the ledger is the single source of truth and replays identically.
-;;
-;; Lifecycle events:
-;;   :created   quote snapshot {:subtotal :discount :tax :total :codes ...}
-;;   :reserved  stock reserved
-;;   :paid      {:amount :ref}  — recorded idempotently on the payment ref
-;;   :fulfilled order shipped/delivered
-;;   :cancelled / :refunded
-;;
-;; Idempotency: the SumUp webhook can fire twice for one payment. order-pay
-;; uses persist/append-once keyed by the payment ref, so a replayed webhook
-;; yields the SAME :paid event without double-recording. Reconciliation then
-;; detects genuine mismatches (paid != ordered) across the whole ledger.
-
-(define order-stream (fn (order-id) (str "order/" order-id)))
-
-;; --- writes ---
-
-(define
-  order-create
-  (fn
-    (b order-id at quote)
-    (persist/append b (order-stream order-id) :created at quote)))
-
-(define
-  order-reserve
-  (fn
-    (b order-id at data)
-    (persist/append b (order-stream order-id) :reserved at data)))
-
-;; Idempotent on payment ref — a replayed webhook does not double-record.
-(define
-  order-pay
-  (fn
-    (b order-id ref at amount)
-    (persist/append-once b (order-stream order-id) ref :paid at {:amount amount :ref ref})))
-
-(define
-  order-fulfil
-  (fn
-    (b order-id at data)
-    (persist/append b (order-stream order-id) :fulfilled at data)))
-
-(define
-  order-cancel
-  (fn
-    (b order-id at reason)
-    (persist/append b (order-stream order-id) :cancelled at {:reason reason})))
-
-(define
-  order-refund
-  (fn
-    (b order-id ref at amount)
-    (persist/append-once
-      b
-      (order-stream order-id)
-      (str "refund/" ref)
-      :refunded at
-      {:amount amount :ref ref})))
-
-;; --- reads ---
-
-(define
-  order-events
-  (fn (b order-id) (persist/read b (order-stream order-id))))
-
-;; --- projections over an event list ---
-
-(define
-  order-status-of
-  (fn
-    (events)
-    (reduce
-      (fn
-        (st e)
-        (let
-          ((t (persist/event-type e)))
-          (cond
-            ((= t :created) :pending)
-            ((= t :reserved) :reserved)
-            ((= t :paid) :paid)
-            ((= t :fulfilled) :fulfilled)
-            ((= t :cancelled) :cancelled)
-            ((= t :refunded) :refunded)
-            (:else st))))
-      :new events)))
-
-(define
-  order-total-of
-  (fn
-    (events)
-    (let
-      ((created (filter (fn (e) (= (persist/event-type e) :created)) events)))
-      (if
-        (empty? created)
-        0
-        (get (persist/event-data (first created)) :total)))))
-
-(define
-  order-paid-amount-of
-  (fn
-    (events)
-    (reduce
-      (fn
-        (acc e)
-        (if
-          (= (persist/event-type e) :paid)
-          (+ acc (get (persist/event-data e) :amount))
-          acc))
-      0
-      events)))
-
-(define
-  order-refunded-amount-of
-  (fn
-    (events)
-    (reduce
-      (fn
-        (acc e)
-        (if
-          (= (persist/event-type e) :refunded)
-          (+ acc (get (persist/event-data e) :amount))
-          acc))
-      0
-      events)))
-
-;; Net settled = paid - refunded. Reconciliation compares this to the order
-;; total, but only once a payment exists.
-(define
-  order-recon-of
-  (fn
-    (events)
-    (let
-      ((net (- (order-paid-amount-of events) (order-refunded-amount-of events)))
-        (total (order-total-of events))
-        (has-paid (some (fn (e) (= (persist/event-type e) :paid)) events)))
-      (cond
-        ((not has-paid) :unpaid)
-        ((= net total) :ok)
-        ((< net total) :underpaid)
-        (:else :overpaid)))))
-
-;; --- backend-level helpers ---
-
-(define
-  order-status
-  (fn (b order-id) (order-status-of (order-events b order-id))))
-(define
-  order-total
-  (fn (b order-id) (order-total-of (order-events b order-id))))
-(define
-  order-paid
-  (fn (b order-id) (order-paid-amount-of (order-events b order-id))))
-(define
-  order-recon
-  (fn (b order-id) (order-recon-of (order-events b order-id))))
-
-(define order-ids (fn (b) (persist/backend-streams b)))
-
-;; Streams whose net payment does not match the order total (true mismatches,
-;; excluding orders that are simply not yet paid).
-(define
-  ledger-mismatches
-  (fn
-    (b)
-    (filter
-      (fn
-        (s)
-        (let
-          ((r (order-recon-of (persist/read b s))))
-          (or (= r :underpaid) (= r :overpaid))))
-      (persist/backend-streams b))))

lib/commerce/nettax.sx

@@ -1,80 +0,0 @@
-;; lib/commerce/nettax.sx — discount-aware tax (alternative policy).
-;;
-;; price.sx / quote.sx tax the GROSS per-line amounts (discount reduces payable
-;; but not the tax base). This module is the alternative explicit policy: tax the
-;; NET (post-discount) base. The basket-level discount is allocated across lines
-;; in proportion to each line's extended price, with a deterministic
-;; largest-remainder pass so per-line shares sum EXACTLY to the discount; tax is
-;; then charged on each line's net at its class rate.
-;;
-;; Both policies are reproducible from (ctx, cart, ruleset, exclusions); pick the
-;; one the jurisdiction requires. cart-quote-net mirrors cart-quote's shape.
-
-(define ct-sum (fn (xs) (reduce (fn (a x) (+ a x)) 0 xs)))
-
-;; Add 1 to the first `rem` elements (deterministic remainder distribution).
-(define
-  ct-add-rem
-  (fn
-    (xs rem)
-    (cond
-      ((empty? xs) (list))
-      ((> rem 0)
-        (cons
-          (+ (first xs) 1)
-          (ct-add-rem (rest xs) (- rem 1))))
-      (:else xs))))
-
-;; Per-line discount allocation (parallel to cart), summing exactly to
-;; total-discount, proportional to line-extended share.
-(define
-  allocate-discount
-  (fn
-    (cat cart total-discount)
-    (let
-      ((sub (cart-subtotal cat cart)))
-      (if
-        (= sub 0)
-        (map (fn (l) 0) cart)
-        (let
-          ((floors (map (fn (l) (quotient (* total-discount (line-extended cat l)) sub)) cart)))
-          (ct-add-rem floors (- total-discount (ct-sum floors))))))))
-
-;; Tax on one line's net (extended - allocated discount), clamped at 0.
-(define
-  net-line-tax
-  (fn
-    (ctx line alloc)
-    (let
-      ((cat (ctx-catalog ctx)))
-      (let
-        ((net (- (line-extended cat line) alloc)))
-        (apply-bps
-          (if (< net 0) 0 net)
-          (rate-bps
-            (get ctx :tax-rules)
-            (get ctx :jurisdiction)
-            (catalog-class cat (line-sku line))
-            (get ctx :customer)))))))
-
-(define
-  net-tax
-  (fn
-    (ctx cart allocations)
-    (ct-sum
-      (map (fn (line alloc) (net-line-tax ctx line alloc)) cart allocations))))
-
-;; Discount-aware quote: tax computed on the net (post-discount) base.
-(define
-  cart-quote-net
-  (fn
-    (ctx cart ruleset exclusions)
-    (let
-      ((cat (ctx-catalog ctx)))
-      (let
-        ((sub (cart-subtotal cat cart))
-          (disc (best-promo-discount ctx cart ruleset exclusions))
-          (codes (best-promo-codes ctx cart ruleset exclusions)))
-        (let
-          ((tax (net-tax ctx cart (allocate-discount cat cart disc))))
-          {:codes codes :subtotal sub :discount disc :total (+ (- sub disc) tax) :tax tax})))))

lib/commerce/order.sx

@@ -1,119 +0,0 @@
-;; lib/commerce/order.sx — order lifecycle as a durable flow-on-sx flow.
-;;
-;; The lifecycle (reserve -> await payment -> fulfil) is a Scheme flow running
-;; in the flow-on-sx guest (lib/flow). The flow is PURE ORCHESTRATION: it
-;; carries only the order-id and enforces step ordering + the suspension at the
-;; payment IO boundary. All IO/state lives in SX: the SX driver here services
-;; each flow request by appending to the persist ledger (ledger.sx).
-;;
-;;   reserve  -> SX appends :reserved, resumes  (synchronous host effect)
-;;   payment  -> flow stays SUSPENDED until the SumUp webhook resumes it
-;;   fulfil   -> SX appends :fulfilled, resumes (synchronous host effect)
-;;
-;; Durability: the flow's replay log is plain data (flow-store-export), so a
-;; suspended order survives a process restart — order-flow-restart! simulates
-;; that entirely Scheme-side. Idempotency: order-settle! only resumes a flow
-;; still waiting on payment, so a replayed webhook is a no-op at the flow level,
-;; and order-pay is idempotent at the ledger level.
-
-;; The flow definition (Scheme source). oid is in scope throughout the begin.
-(define
-  order-flow-src
-  "(defflow order-lifecycle (lambda (oid) (begin (request (quote reserve) oid) (request (quote payment) oid) (request (quote fulfil) oid))))")
-
-;; Build a flow env with the order flow registered. Never returns the env from
-;; an eval boundary (the env is large/cyclic — serializing it hangs).
-(define
-  order-make-env
-  (fn
-    ()
-    (let
-      ((env (flow-make-env)))
-      (begin (flow-run-in env order-flow-src) env))))
-
-;; --- thin Scheme bridge (string-interpolated flow ops) ---
-
-(define
-  order-flow-start
-  (fn
-    (env oid)
-    (flow-run-in env (str "(flow/start order-lifecycle \"" oid "\")"))))
-
-(define
-  order-flow-resume
-  (fn
-    (env id sym)
-    (flow-run-in env (str "(flow/resume " id " (quote " sym "))"))))
-
-(define
-  order-flow-status
-  (fn (env id) (flow-run-in env (str "(flow/status " id ")"))))
-(define
-  order-flow-result
-  (fn (env id) (flow-run-in env (str "(flow/result " id ")"))))
-
-;; The request kind the flow with this id is waiting on, or nil if it is not
-;; suspended on a host request (done / cancelled / unknown).
-(define
-  order-flow-waiting
-  (fn
-    (env id)
-    (let
-      ((reqs (flow-run-in env "(flow-host-requests)")))
-      (let
-        ((mine (filter (fn (r) (= (first r) id)) reqs)))
-        (if (empty? mine) nil (nth (first mine) 1))))))
-
-;; Id out of a (flow-suspended id tag) start/resume result.
-(define order-susp-id (fn (susp) (nth susp 1)))
-
-;; --- high-level lifecycle (flow + ledger composed) ---
-
-;; Create the order, start the flow, service the reserve step, and leave the
-;; flow suspended at payment. Returns the flow id (needed to settle later).
-(define
-  order-begin!
-  (fn
-    (env b oid at quote)
-    (begin
-      (order-create b oid at quote)
-      (let
-        ((id (order-susp-id (order-flow-start env oid))))
-        (begin
-          (order-reserve b oid (+ at 1) {})
-          (order-flow-resume env id :reserved)
-          id)))))
-
-;; Settle a payment: record it, resume the flow past payment, service fulfil.
-;; Idempotent — only acts when the flow is still waiting on payment, so a
-;; replayed webhook returns :already-settled without double-charging.
-(define
-  order-settle!
-  (fn
-    (env b id oid ref at amount)
-    (if
-      (= (order-flow-waiting env id) "payment")
-      (begin
-        (order-pay b oid ref at amount)
-        (order-flow-resume env id :paid)
-        (order-fulfil b oid (+ at 1) {})
-        (order-flow-resume env id :fulfilled)
-        :settled)
-      :already-settled)))
-
-;; Simulate a process restart: export the flow store, reset the runtime, reload
-;; the flow definition, reimport the store. Done entirely Scheme-side so the
-;; (large) store is never marshalled across the boundary. The persist ledger is
-;; a separate store and is unaffected. Suspended flows resume afterwards.
-(define
-  order-flow-restart!
-  (fn
-    (env)
-    (flow-run-in
-      env
-      (str
-        "(begin (define _saved (flow-store-export)) "
-        flow-reset-src
-        " "
-        order-flow-src
-        " (flow-store-import! _saved) #t)"))))

lib/commerce/payment.sx

@@ -1,41 +0,0 @@
-;; lib/commerce/payment.sx — provider-neutral payment-request envelope.
-;;
-;; The order flow (order.sx) suspends on `(request 'payment oid)` — it carries
-;; ONLY the order-id and calls no provider. This layer materialises, at the IO
-;; edge, the envelope a provider adapter needs to initiate payment:
-;;
-;;   {:order oid :amount <ledger total> :currency C :return-url U}
-;;
-;; amount comes from the ledger (the :created quote total); currency + return-url
-;; are host/provider config (legitimately host-supplied). The engine stays
-;; vendor-agnostic: SumUp/Stripe/etc. adapters consume this envelope, and
-;; order-settle!(ref, amount) is the vendor-neutral resume seam. No provider
-;; SDK, HTTP, or webhook parsing lives here — that is the orders service's job.
-
-(define payment-request (fn (b oid currency return-url) {:order oid :amount (order-total b oid) :return-url return-url :currency currency}))
-
-(define payment-request-order (fn (pr) (get pr :order)))
-(define payment-request-amount (fn (pr) (get pr :amount)))
-(define payment-request-currency (fn (pr) (get pr :currency)))
-(define payment-request-return-url (fn (pr) (get pr :return-url)))
-
-;; A Scheme string carried as a flow payload round-trips back to SX wrapped as
-;; {:scm-string "..."}; unwrap it to the bare order-id.
-(define
-  scm->string
-  (fn
-    (v)
-    (if (and (dict? v) (has-key? v :scm-string)) (get v :scm-string) v)))
-
-;; Host poller seam: every order currently suspended awaiting payment, each with
-;; its envelope. A provider adapter iterates these, initiates payment, and later
-;; calls order-settle! when the webhook arrives. Needs the flow env.
-(define
-  pending-payments
-  (fn
-    (env b currency return-url)
-    (let
-      ((reqs (flow-run-in env "(flow-host-requests)")))
-      (map
-        (fn (r) {:id (first r) :request (payment-request b (scm->string (nth r 2)) currency return-url)})
-        (filter (fn (r) (= (nth r 1) "payment")) reqs)))))

lib/commerce/price.sx

@@ -1,110 +0,0 @@
-;; lib/commerce/price.sx — deterministic subtotal + jurisdiction-relational tax.
-;;
-;; A pricing context bundles the inputs that make a total reproducible:
-;;   {:catalog CAT :tax-rules RULES :jurisdiction J :customer C}
-;; Same context + same cart => identical total, every run.
-;;
-;; Tax is NOT a hardcoded VAT rate. Rules are facts indexed by
-;;   (jurisdiction, product-class, customer-class) -> rate-bps
-;; where rate-bps is an integer in basis points (2000 = 20%). taxo queries
-;; them multidirectionally. Money stays in integer minor units; rounding is
-;; half-up per line via integer arithmetic only — never floats.
-
-(define
-  make-pricing-context
-  (fn (catalog tax-rules jurisdiction customer) {:customer customer :jurisdiction jurisdiction :catalog catalog :tax-rules tax-rules}))
-
-(define ctx-catalog (fn (ctx) (get ctx :catalog)))
-
-;; --- unit + line pricing ---
-
-;; Variant delta, defaulting to 0 when the (sku,variant) has no variant fact.
-(define
-  variant-delta
-  (fn
-    (cat sku variant)
-    (let
-      ((rs (run 1 d (varianto cat sku variant d))))
-      (if (empty? rs) 0 (first rs)))))
-
-;; Effective unit price = base price + variant delta. nil if sku unknown.
-(define
-  line-unit-price
-  (fn
-    (cat sku variant)
-    (let
-      ((base (catalog-price cat sku)))
-      (if (nil? base) nil (+ base (variant-delta cat sku variant))))))
-
-;; Extended (line) price = unit price * quantity.
-(define
-  line-extended
-  (fn
-    (cat line)
-    (*
-      (line-unit-price cat (line-sku line) (line-variant line))
-      (line-qty line))))
-
-(define
-  cart-subtotal
-  (fn
-    (cat cart)
-    (reduce (fn (acc l) (+ acc (line-extended cat l))) 0 cart)))
-
-;; --- tax (jurisdiction-relational) ---
-
-;; rules: (list (list jurisdiction class customer bps) ...)
-(define
-  taxo
-  (fn
-    (rules juris class cust bps)
-    (membero (list juris class cust bps) rules)))
-
-;; Deterministic rate lookup; 0 when no rule matches.
-(define
-  rate-bps
-  (fn
-    (rules juris class cust)
-    (let
-      ((rs (run 1 b (taxo rules juris class cust b))))
-      (if (empty? rs) 0 (first rs)))))
-
-;; Apply a basis-point rate to an integer amount, rounding half up.
-(define
-  apply-bps
-  (fn (amount bps) (quotient (+ (* amount bps) 5000) 10000)))
-
-(define
-  line-tax
-  (fn
-    (ctx line)
-    (let
-      ((cat (ctx-catalog ctx)))
-      (let
-        ((class (catalog-class cat (line-sku line))))
-        (apply-bps
-          (line-extended cat line)
-          (rate-bps
-            (get ctx :tax-rules)
-            (get ctx :jurisdiction)
-            class
-            (get ctx :customer)))))))
-
-(define
-  cart-tax
-  (fn
-    (ctx cart)
-    (reduce (fn (acc l) (+ acc (line-tax ctx l))) 0 cart)))
-
-;; --- total ---
-
-;; Returns {:subtotal :discounts :tax :total}. discounts is 0 until Phase 2.
-(define
-  cart-total
-  (fn
-    (ctx cart)
-    (let
-      ((cat (ctx-catalog ctx)))
-      (let
-        ((sub (cart-subtotal cat cart)) (tax (cart-tax ctx cart)))
-        {:subtotal sub :discounts 0 :total (+ sub tax) :tax tax}))))

lib/commerce/promo.sx

@@ -1,153 +0,0 @@
-;; lib/commerce/promo.sx — promotions as relations over the cart + catalog.
-;;
-;; A promo is a tagged tuple; the second field is always its code:
-;;   (:percent code class pct-bps)   pct-bps off every line of product-class
-;;   (:fixed   code threshold amount) amount off when subtotal >= threshold
-;;   (:bundle  code sku n)            every nth unit of sku is free
-;;   (:member  code class pct-bps)    like :percent, members only
-;;
-;; A ruleset is a list of promo tuples. The discount a promo yields on a
-;; given cart is a pure integer computation (minor units); the *enumeration*
-;; of which promos apply is relational, so promo-applieso runs forward
-;; ("which codes apply and for how much?") and backward ("which code yields
-;; this discount?"). Stacking precedence is a separate layer (stack.sx).
-
-(define promo-kind (fn (p) (nth p 0)))
-(define promo-code (fn (p) (nth p 1)))
-
-;; Extended price of all lines whose sku is in product-class `class`.
-(define
-  class-extended
-  (fn
-    (ctx cart class)
-    (let
-      ((cat (ctx-catalog ctx)))
-      (reduce
-        (fn
-          (acc l)
-          (if
-            (= (catalog-class cat (line-sku l)) class)
-            (+ acc (line-extended cat l))
-            acc))
-        0
-        cart))))
-
-(define
-  sku-qty
-  (fn
-    (cart sku)
-    (reduce
-      (fn (acc l) (if (= (line-sku l) sku) (+ acc (line-qty l)) acc))
-      0
-      cart)))
-
-;; --- per-type discount amounts (pure, integer minor units) ---
-
-(define
-  percent-amount
-  (fn
-    (ctx cart p)
-    (apply-bps
-      (class-extended ctx cart (nth p 2))
-      (nth p 3))))
-
-(define
-  fixed-amount
-  (fn
-    (ctx cart p)
-    (let
-      ((sub (cart-subtotal (ctx-catalog ctx) cart)))
-      (if
-        (>= sub (nth p 2))
-        (min (nth p 3) sub)
-        0))))
-
-(define
-  bundle-amount
-  (fn
-    (ctx cart p)
-    (let
-      ((sku (nth p 2)) (n (nth p 3)))
-      (let
-        ((free (quotient (sku-qty cart sku) n)))
-        (* free (catalog-price (ctx-catalog ctx) sku))))))
-
-(define
-  member-amount
-  (fn
-    (ctx cart p)
-    (if
-      (= (get ctx :customer) :member)
-      (apply-bps
-        (class-extended ctx cart (nth p 2))
-        (nth p 3))
-      0)))
-
-;; Discount this promo yields on this cart (0 if it does not apply).
-(define
-  promo-amount
-  (fn
-    (ctx cart p)
-    (let
-      ((k (promo-kind p)))
-      (cond
-        ((= k :percent) (percent-amount ctx cart p))
-        ((= k :fixed) (fixed-amount ctx cart p))
-        ((= k :bundle) (bundle-amount ctx cart p))
-        ((= k :member) (member-amount ctx cart p))
-        (:else 0)))))
-
-;; --- relational enumeration ---
-
-;; (code, amount) for every promo in the ruleset (amount may be 0).
-(define
-  promo-discounto
-  (fn
-    (ctx cart ruleset code amount)
-    (fresh
-      (p)
-      (membero p ruleset)
-      (project
-        (p)
-        (== code (promo-code p))
-        (== amount (promo-amount ctx cart p))))))
-
-;; (code, amount) restricted to promos that actually apply (amount > 0).
-(define
-  promo-applieso
-  (fn
-    (ctx cart ruleset code amount)
-    (fresh
-      (p)
-      (membero p ruleset)
-      (project
-        (p)
-        (if
-          (> (promo-amount ctx cart p) 0)
-          (mk-conj
-            (== code (promo-code p))
-            (== amount (promo-amount ctx cart p)))
-          fail)))))
-
-;; --- deterministic helpers ---
-
-;; List of (list code amount) for applicable promos, in ruleset order.
-(define
-  applicable-promos
-  (fn
-    (ctx cart ruleset)
-    (run*
-      pair
-      (fresh
-        (code amount)
-        (promo-applieso ctx cart ruleset code amount)
-        (== pair (list code amount))))))
-
-;; Discount for one code (0 if absent / inapplicable).
-(define
-  promo-amount-for
-  (fn
-    (ctx cart ruleset code)
-    (let
-      ((rs (run 1 a (promo-applieso ctx cart ruleset code a))))
-      (if (empty? rs) 0 (first rs)))))

lib/commerce/quote.sx

@@ -1,36 +0,0 @@
-;; lib/commerce/quote.sx — the final priced quote: price + promo + stacking.
-;;
-;; A quote is the deterministic composition of the pricing pipeline for a
-;; (context, cart, ruleset, exclusions) tuple:
-;;   {:subtotal S :discount D :tax T :total (S - D + T) :codes (...)}
-;;
-;; Tax policy (explicit, for the determinism contract): tax is computed on the
-;; GROSS per-line amounts (pre-discount), via price.sx cart-tax. The best
-;; promo stacking reduces the payable total but not the tax base. Same inputs
-;; always yield the same quote — this is the value the order flow carries.
-
-(define
-  cart-quote
-  (fn
-    (ctx cart ruleset exclusions)
-    (let
-      ((cat (ctx-catalog ctx)))
-      (let
-        ((sub (cart-subtotal cat cart))
-          (disc (best-promo-discount ctx cart ruleset exclusions))
-          (tax (cart-tax ctx cart))
-          (codes (best-promo-codes ctx cart ruleset exclusions)))
-        {:codes codes :subtotal sub :discount disc :total (+ (- sub disc) tax) :tax tax}))))
-
-(define quote-subtotal (fn (q) (get q :subtotal)))
-(define quote-discount (fn (q) (get q :discount)))
-(define quote-tax (fn (q) (get q :tax)))
-(define quote-total (fn (q) (get q :total)))
-(define quote-codes (fn (q) (get q :codes)))
-
-;; Session-level convenience (a session is {:ctx :cart}).
-(define
-  session-quote
-  (fn
-    (sess ruleset exclusions)
-    (cart-quote (get sess :ctx) (get sess :cart) ruleset exclusions)))

lib/commerce/recon.sx

@@ -1,100 +0,0 @@
-;; lib/commerce/recon.sx — reconciliation as relational queries over the ledger.
-;;
-;; The ledger (ledger.sx) is the source of truth; reconciliation projects it
-;; into per-order summary tuples and then asks miniKanren questions about them.
-;; "Which orders are overpaid?" / "which order settled to net N?" are backward
-;; queries (run*) over the same relation, not separate code paths.
-;;
-;; A summary tuple is positional:
-;;   (order-stream total paid refunded net status)
-;; net = paid - refunded; status = :unpaid|:ok|:underpaid|:overpaid.
-
-(define
-  order-summary
-  (fn
-    (b stream)
-    (let
-      ((events (persist/read b stream)))
-      (let
-        ((total (order-total-of events))
-          (paid (order-paid-amount-of events))
-          (refunded (order-refunded-amount-of events)))
-        (list
-          stream
-          total
-          paid
-          refunded
-          (- paid refunded)
-          (order-recon-of events))))))
-
-(define
-  ledger-summaries
-  (fn (b) (map (fn (s) (order-summary b s)) (persist/backend-streams b))))
-
-;; --- relations over the summary set ---
-
-(define
-  summaryo
-  (fn
-    (summaries id total paid refunded net status)
-    (membero (list id total paid refunded net status) summaries)))
-
-(define
-  recon-statuso
-  (fn
-    (summaries id status)
-    (fresh (t p r n) (summaryo summaries id t p r n status))))
-
-(define
-  neto
-  (fn
-    (summaries id net)
-    (fresh (t p r status) (summaryo summaries id t p r net status))))
-
-;; A mismatch is any order whose money does not reconcile (over or under).
-(define
-  mismatcho
-  (fn
-    (summaries id)
-    (fresh
-      (status)
-      (recon-statuso summaries id status)
-      (conde ((== status :underpaid)) ((== status :overpaid))))))
-
-;; --- deterministic query helpers (run* over the live ledger) ---
-
-(define
-  orders-with-status
-  (fn (b status) (run* id (recon-statuso (ledger-summaries b) id status))))
-
-(define overpaid-orders (fn (b) (orders-with-status b :overpaid)))
-(define underpaid-orders (fn (b) (orders-with-status b :underpaid)))
-(define settled-orders (fn (b) (orders-with-status b :ok)))
-(define unpaid-orders (fn (b) (orders-with-status b :unpaid)))
-
-(define
-  mismatched-orders
-  (fn (b) (run* id (mismatcho (ledger-summaries b) id))))
-
-;; Backward: which order(s) settled to a given net amount?
-(define
-  orders-with-net
-  (fn (b net) (run* id (neto (ledger-summaries b) id net))))
-
-;; Total signed discrepancy across the ledger (net - total over paid orders);
-;; 0 when every settled order reconciles exactly.
-(define
-  ledger-discrepancy
-  (fn
-    (b)
-    (reduce
-      (fn
-        (acc s)
-        (let
-          ((status (nth s 5)))
-          (if
-            (= status :unpaid)
-            acc
-            (+ acc (- (nth s 4) (nth s 1))))))
-      0
-      (ledger-summaries b))))

lib/commerce/refund.sx

@@ -1,97 +0,0 @@
-;; lib/commerce/refund.sx — refund lifecycle as a second flow-on-sx flow.
-;;
-;; A refund is request → approve → settle, with TWO genuine suspension points:
-;; approval (a human/policy decision) and settlement (the provider issuing the
-;; refund). Like order.sx the flow is pure orchestration carrying only the
-;; order-id; the SX driver does all ledger IO and reuses order.sx's generic flow
-;; helpers (order-flow-waiting/-resume/-status, order-susp-id).
-;;
-;;   refund-begin!   → ledger :refund-requested, flow suspends at 'approve
-;;   refund-approve! → resume past approval, flow suspends at 'settle
-;;   refund-settle!  → ledger :refunded (idempotent), flow completes
-;;   refund-reject!  → ledger :refund-rejected, flow cancelled
-;;
-;; Only :refunded moves the books (recon.sx), so a requested-but-unsettled or
-;; rejected refund leaves reconciliation unchanged.
-
-(define
-  refund-flow-src
-  "(defflow refund-lifecycle (lambda (oid) (begin (request (quote approve) oid) (request (quote settle) oid))))")
-
-(define
-  refund-make-env
-  (fn
-    ()
-    (let
-      ((env (flow-make-env)))
-      (begin (flow-run-in env refund-flow-src) env))))
-
-;; Register the refund flow into an existing (e.g. order) env.
-(define
-  refund-flow-load!
-  (fn (env) (begin (flow-run-in env refund-flow-src) env)))
-
-(define
-  refund-flow-start
-  (fn
-    (env oid)
-    (flow-run-in env (str "(flow/start refund-lifecycle \"" oid "\")"))))
-
-;; --- ledger writes ---
-
-(define
-  refund-request
-  (fn
-    (b oid ref at amount)
-    (persist/append-once
-      b
-      (order-stream oid)
-      (str "refund-req/" ref)
-      :refund-requested at
-      {:amount amount :ref ref})))
-
-;; --- lifecycle ---
-
-;; Open a refund: record the request, start the flow, suspend at approval.
-(define
-  refund-begin!
-  (fn
-    (env b oid ref at amount)
-    (begin
-      (refund-request b oid ref at amount)
-      (order-susp-id (refund-flow-start env oid)))))
-
-(define
-  refund-approve!
-  (fn
-    (env id)
-    (if
-      (= (order-flow-waiting env id) "approve")
-      (begin (order-flow-resume env id :approved) :approved)
-      :not-pending-approval)))
-
-(define
-  refund-reject!
-  (fn
-    (env b oid id at reason)
-    (if
-      (= (order-flow-waiting env id) "approve")
-      (begin
-        (persist/append b (order-stream oid) :refund-rejected at {:reason reason})
-        (flow-run-in env (str "(flow/cancel " id ")"))
-        :rejected)
-      :not-pending-approval)))
-
-;; Settle (provider issued the refund): idempotent — only acts while waiting on
-;; settle, so a replayed provider callback returns :already-settled.
-(define
-  refund-settle!
-  (fn
-    (env b id oid ref at amount)
-    (if
-      (= (order-flow-waiting env id) "settle")
-      (begin
-        (order-refund b oid ref at amount)
-        (order-flow-resume env id :settled)
-        :settled)
-      :already-settled)))

lib/commerce/scoreboard.json

@@ -1,25 +0,0 @@
-{
-  "suites": {
-    "catalog": {"pass": 16, "fail": 0},
-    "cart": {"pass": 18, "fail": 0},
-    "price": {"pass": 20, "fail": 0},
-    "api": {"pass": 12, "fail": 0},
-    "promo": {"pass": 17, "fail": 0},
-    "stack": {"pass": 16, "fail": 0},
-    "quote": {"pass": 13, "fail": 0},
-    "ledger": {"pass": 20, "fail": 0},
-    "order": {"pass": 22, "fail": 0},
-    "recon": {"pass": 20, "fail": 0},
-    "federation": {"pass": 12, "fail": 0},
-    "attribution": {"pass": 16, "fail": 0},
-    "payment": {"pass": 7, "fail": 0},
-    "window": {"pass": 19, "fail": 0},
-    "nettax": {"pass": 11, "fail": 0},
-    "stock": {"pass": 19, "fail": 0},
-    "refund": {"pass": 20, "fail": 0},
-    "integration": {"pass": 19, "fail": 0}
-  },
-  "total_pass": 297,
-  "total_fail": 0,
-  "total": 297
-}

lib/commerce/scoreboard.md

@@ -1,25 +0,0 @@
-# commerce Conformance Scoreboard
-
-_Generated by `lib/commerce/conformance.sh`_
-
-| Suite | Pass | Fail | Total |
-|-------|-----:|-----:|------:|
-| catalog | 16 | 0 | 16 |
-| cart | 18 | 0 | 18 |
-| price | 20 | 0 | 20 |
-| api | 12 | 0 | 12 |
-| promo | 17 | 0 | 17 |
-| stack | 16 | 0 | 16 |
-| quote | 13 | 0 | 13 |
-| ledger | 20 | 0 | 20 |
-| order | 22 | 0 | 22 |
-| recon | 20 | 0 | 20 |
-| federation | 12 | 0 | 12 |
-| attribution | 16 | 0 | 16 |
-| payment | 7 | 0 | 7 |
-| window | 19 | 0 | 19 |
-| nettax | 11 | 0 | 11 |
-| stock | 19 | 0 | 19 |
-| refund | 20 | 0 | 20 |
-| integration | 19 | 0 | 19 |
-| **Total** | **297** | **0** | **297** |

lib/commerce/stack.sx

@@ -1,121 +0,0 @@
-;; lib/commerce/stack.sx — promotion stacking precedence + best price.
-;;
-;; Per the miniKanren design rule, precedence is NOT encoded inside the promo
-;; rules. promo.sx enumerates which promos apply; this layer enumerates which
-;; *combinations* are legal and selects the best one by an explicit cost
-;; function (max total discount = min price).
-;;
-;; Exclusivity is a list of unordered code pairs that may not both apply:
-;;   exclusions = (list (list code-a code-b) ...)
-;; A stacking is a subset of applicable (code amount) pairs containing no
-;; excluded pair. valid-stackings enumerates them; best-stacking is the
-;; deterministic selection layer; stacking-by-totalo is the backward query
-;; ("which legal stacking yields this total discount?").
-
-(define
-  excluded-pair?
-  (fn
-    (exclusions a b)
-    (some
-      (fn
-        (p)
-        (or
-          (and (= (first p) a) (= (nth p 1) b))
-          (and (= (first p) b) (= (nth p 1) a))))
-      exclusions)))
-
-;; True when no two distinct codes in the list are mutually excluded.
-(define
-  compatible?
-  (fn
-    (exclusions codes)
-    (every?
-      (fn
-        (a)
-        (every?
-          (fn (b) (or (= a b) (not (excluded-pair? exclusions a b))))
-          codes))
-      codes)))
-
-;; All subsets of xs, preserving element order. 2^n entries.
-(define
-  powerset
-  (fn
-    (xs)
-    (if
-      (empty? xs)
-      (list (list))
-      (let
-        ((r (powerset (cdr xs))))
-        (append r (map (fn (s) (cons (first xs) s)) r))))))
-
-(define stacking-codes (fn (st) (map first st)))
-
-(define
-  stacking-total
-  (fn
-    (st)
-    (reduce (fn (acc pair) (+ acc (nth pair 1))) 0 st)))
-
-;; Every legal stacking of the applicable (code amount) pairs.
-(define
-  valid-stackings
-  (fn
-    (exclusions applicable)
-    (filter
-      (fn (st) (compatible? exclusions (stacking-codes st)))
-      (powerset applicable))))
-
-;; Deterministic selection: the legal stacking with the greatest total
-;; discount; ties keep the earlier (stable) candidate, so the result is a
-;; reproducible function of (exclusions, applicable).
-(define
-  best-stacking
-  (fn
-    (exclusions applicable)
-    (reduce
-      (fn
-        (best st)
-        (if (> (stacking-total st) (stacking-total best)) st best))
-      (list)
-      (valid-stackings exclusions applicable))))
-
-(define
-  best-discount
-  (fn
-    (exclusions applicable)
-    (stacking-total (best-stacking exclusions applicable))))
-
-(define
-  best-codes
-  (fn
-    (exclusions applicable)
-    (stacking-codes (best-stacking exclusions applicable))))
-
-;; Backward query: legal stackings (as code lists) whose total discount = D.
-(define
-  stacking-by-totalo
-  (fn
-    (stackings codes total)
-    (fresh
-      (st)
-      (membero st stackings)
-      (project
-        (st)
-        (mk-conj
-          (== codes (stacking-codes st))
-          (== total (stacking-total st)))))))
-
-;; --- top-level entry: best discount for a cart under a ruleset ---
-
-(define
-  best-promo-discount
-  (fn
-    (ctx cart ruleset exclusions)
-    (best-discount exclusions (applicable-promos ctx cart ruleset))))
-
-(define
-  best-promo-codes
-  (fn
-    (ctx cart ruleset exclusions)
-    (best-codes exclusions (applicable-promos ctx cart ruleset))))

lib/commerce/stock.sx

@@ -1,106 +0,0 @@
-;; lib/commerce/stock.sx — stock-constrained reservation.
-;;
-;; Reservation is a precondition the host checks BEFORE order-begin! (validate →
-;; begin), so the order flow stays pure orchestration. Availability is read
-;; relationally from the catalog stock facts (catalog.sx stocko); a stock view
-;; subtracts already-reserved quantities so concurrent orders can't over-reserve.
-;;
-;;   can-reserve? cat cart                  — every line fits available stock
-;;   reservation-shortfalls cat cart        — the lines that do not, with detail
-;;   effective-available cat reservations …  — availability net of reservations
-;;   sufficient-stocko cat sku variant qty  — relational "can supply qty?" query
-
-;; Deterministic on-hand stock for a (sku,variant); 0 if absent.
-(define
-  available-stock
-  (fn
-    (cat sku variant)
-    (let
-      ((rs (run 1 q (stocko cat sku variant q))))
-      (if (empty? rs) 0 (first rs)))))
-
-;; Units a line cannot fulfil from on-hand stock (0 if it fits).
-(define
-  line-shortfall
-  (fn
-    (cat line)
-    (let
-      ((short (- (line-qty line) (available-stock cat (line-sku line) (line-variant line)))))
-      (if (< short 0) 0 short))))
-
-(define
-  line-reservable?
-  (fn (cat line) (= (line-shortfall cat line) 0)))
-
-;; Lines that cannot be fully reserved, each with requested/available/short.
-(define
-  reservation-shortfalls
-  (fn
-    (cat cart)
-    (reduce
-      (fn
-        (acc line)
-        (let
-          ((short (line-shortfall cat line)))
-          (if (> short 0) (append acc (list {:requested (line-qty line) :available (available-stock cat (line-sku line) (line-variant line)) :sku (line-sku line) :variant (line-variant line) :short short})) acc)))
-      (list)
-      cart)))
-
-(define
-  can-reserve?
-  (fn (cat cart) (empty? (reservation-shortfalls cat cart))))
-
-;; Validate → reject; the host gates order-begin! on this.
-(define
-  reserve-check
-  (fn (cat cart) (if (can-reserve? cat cart) :ok {:shortfalls (reservation-shortfalls cat cart) :rejected :insufficient-stock})))
-
-;; --- reservation view (concurrent-safety) ---
-;; reservations: list of (sku variant qty) already held.
-
-(define
-  reserved-qty
-  (fn
-    (reservations sku variant)
-    (reduce
-      (fn
-        (acc r)
-        (if
-          (and (= (first r) sku) (= (nth r 1) variant))
-          (+ acc (nth r 2))
-          acc))
-      0
-      reservations)))
-
-;; On-hand minus already-reserved (clamped at 0).
-(define
-  effective-available
-  (fn
-    (cat reservations sku variant)
-    (let
-      ((eff (- (available-stock cat sku variant) (reserved-qty reservations sku variant))))
-      (if (< eff 0) 0 eff))))
-
-;; Can a line be reserved given existing reservations?
-(define
-  line-reservable-with?
-  (fn
-    (cat reservations line)
-    (<=
-      (line-qty line)
-      (effective-available
-        cat
-        reservations
-        (line-sku line)
-        (line-variant line)))))
-
-;; --- relational availability query (the showcase) ---
-
-;; Succeeds when on-hand stock for (sku,variant) covers qty. Multidirectional
-;; over the stock facts: "which variants of widget can supply 5?" is a backward
-;; query.
-(define
-  sufficient-stocko
-  (fn
-    (cat sku variant qty)
-    (fresh (avail) (stocko cat sku variant avail) (lteo-i qty avail))))

lib/commerce/tests/api.sx

@@ -1,73 +0,0 @@
-;; lib/commerce/tests/api.sx — public commerce session surface.
-;; Uses (commerce-test name got expected) provided by conformance.sh.
-
-(define
-  acat
-  (make-catalog
-    (list
-      (list "widget" 1000 :standard)
-      (list "book" 800 :zero-rated))
-    (list (list "widget" :small -200))
-    (list)))
-
-(define
-  arules
-  (list
-    (list :uk :standard :guest 2000)
-    (list :uk :zero-rated :guest 0)))
-
-(define actx (make-pricing-context acat arules :uk :guest))
-(define sess0 (commerce-session actx))
-
-;; --- empty session ---
-
-(commerce-test "new-session-empty" (commerce-cart sess0) empty-cart)
-(commerce-test "new-count" (commerce-count sess0) 0)
-(commerce-test "new-total" (commerce-total sess0) {:subtotal 0 :discounts 0 :total 0 :tax 0})
-
-;; --- add + total ---
-
-(define
-  sess1
-  (commerce-add
-    (commerce-add sess0 "widget" :small 2)
-    "book"
-    :none 1))
-
-(commerce-test "add-count" (commerce-count sess1) 3)
-(commerce-test
-  "add-lines"
-  (commerce-lines sess1)
-  (list (list "widget" :small 2) (list "book" :none 1)))
-(commerce-test "add-total" (commerce-total sess1) {:subtotal 2400 :discounts 0 :total 2720 :tax 320})
-
-;; --- mutate ---
-
-(commerce-test
-  "set-qty"
-  (commerce-lines (commerce-set-qty sess1 "widget" :small 1))
-  (list (list "widget" :small 1) (list "book" :none 1)))
-
-(commerce-test
-  "remove"
-  (commerce-lines (commerce-remove sess1 "book" :none))
-  (list (list "widget" :small 2)))
-
-;; --- validation ---
-
-(commerce-test "can-add-yes" (commerce-can-add? sess0 "widget") true)
-(commerce-test "can-add-no" (commerce-can-add? sess0 "ghost") false)
-
-;; --- audit breakdown ---
-
-(commerce-test
-  "explain"
-  (commerce-explain sess1)
-  (list {:sku "widget" :unit 800 :qty 2 :variant :small :extended 1600 :tax 320} {:sku "book" :unit 800 :qty 1 :variant :none :extended 800 :tax 0}))
-
-;; --- checkout stub ---
-
-(commerce-test
-  "checkout-stub"
-  (get (commerce-checkout sess1) :status)
-  :not-implemented)

lib/commerce/tests/attribution.sx

@@ -1,124 +0,0 @@
-;; lib/commerce/tests/attribution.sx — line-level discount attribution.
-;; Uses (commerce-test name got expected) provided by conformance.sh.
-
-(define
-  pcat
-  (make-catalog
-    (list
-      (list "widget" 1000 :standard)
-      (list "gizmo" 2000 :standard)
-      (list "book" 800 :zero-rated)
-      (list "tea" 1000 :reduced))
-    (list)
-    (list)))
-
-(define gctx (make-pricing-context pcat (list) :uk :guest))
-(define mctx (make-pricing-context pcat (list) :uk :member))
-
-(define
-  cart
-  (list
-    (list "widget" :none 2)
-    (list "gizmo" :none 1)
-    (list "book" :none 1)
-    (list "tea" :none 6)))
-
-(define
-  ruleset
-  (list
-    (list :percent "TEN" :standard 1000)
-    (list :percent "TWENTY" :standard 2000)
-    (list :bundle "B3T" "tea" 3)
-    (list :fixed "FIVE" 0 500)
-    (list :member "MEM" :standard 1500)))
-
-(define w-line (list "widget" :none 2))
-(define t-line (list "tea" :none 6))
-(define bk-line (list "book" :none 1))
-
-;; --- scope helpers ---
-
-(commerce-test
-  "class-lines-standard"
-  (class-lines gctx cart :standard)
-  (list (list "widget" :none 2) (list "gizmo" :none 1)))
-
-(commerce-test
-  "promo-lines-bundle"
-  (promo-lines gctx cart (list :bundle "B3T" "tea" 3))
-  (list (list "tea" :none 6)))
-
-(commerce-test
-  "promo-lines-fixed-none"
-  (promo-lines gctx cart (list :fixed "FIVE" 0 500))
-  (list))
-
-;; --- forward: which lines does a code touch? ---
-
-(commerce-test
-  "lines-for-ten"
-  (lines-for-code gctx cart ruleset "TEN")
-  (list (list "widget" :none 2) (list "gizmo" :none 1)))
-
-(commerce-test
-  "lines-for-bundle"
-  (lines-for-code gctx cart ruleset "B3T")
-  (list (list "tea" :none 6)))
-
-(commerce-test
-  "lines-for-fixed-empty"
-  (lines-for-code gctx cart ruleset "FIVE")
-  (list))
-(commerce-test
-  "lines-for-mem-guest-empty"
-  (lines-for-code gctx cart ruleset "MEM")
-  (list))
-
-;; --- backward: which codes touch this line? (the showcase) ---
-
-(commerce-test
-  "codes-for-widget-guest"
-  (codes-for-line gctx cart ruleset w-line)
-  (list "TEN" "TWENTY"))
-
-(commerce-test
-  "codes-for-tea"
-  (codes-for-line gctx cart ruleset t-line)
-  (list "B3T"))
-(commerce-test
-  "codes-for-book-none"
-  (codes-for-line gctx cart ruleset bk-line)
-  (list))
-
-;; member sees the member rate too
-(commerce-test
-  "codes-for-widget-member"
-  (codes-for-line mctx cart ruleset w-line)
-  (list "TEN" "TWENTY" "MEM"))
-
-(commerce-test
-  "lines-for-mem-member"
-  (lines-for-code mctx cart ruleset "MEM")
-  (list (list "widget" :none 2) (list "gizmo" :none 1)))
-
-;; --- predicate ---
-
-(commerce-test
-  "touched-yes"
-  (line-touched-by? gctx cart ruleset "TEN" w-line)
-  true)
-(commerce-test
-  "touched-no-wrong-class"
-  (line-touched-by? gctx cart ruleset "B3T" w-line)
-  false)
-(commerce-test
-  "touched-no-guest-mem"
-  (line-touched-by? gctx cart ruleset "MEM" w-line)
-  false)
-
-;; --- order-level (fixed) codes ---
-
-(commerce-test
-  "order-level"
-  (order-level-codes gctx cart ruleset)
-  (list "FIVE"))

lib/commerce/tests/cart.sx

@@ -1,103 +0,0 @@
-;; lib/commerce/tests/cart.sx — cart structure + line operations.
-;; Uses (commerce-test name got expected) provided by conformance.sh.
-
-;; --- add ---
-
-(commerce-test
-  "add-to-empty"
-  (cart-add empty-cart "widget" :small 2)
-  (list (list "widget" :small 2)))
-
-(commerce-test
-  "add-merges-same-line"
-  (cart-add
-    (cart-add empty-cart "widget" :small 2)
-    "widget"
-    :small 3)
-  (list (list "widget" :small 5)))
-
-(commerce-test
-  "add-different-variant-separate"
-  (cart-add
-    (cart-add empty-cart "widget" :small 2)
-    "widget"
-    :large 1)
-  (list (list "widget" :small 2) (list "widget" :large 1)))
-
-(commerce-test
-  "add-different-sku-separate"
-  (cart-add
-    (cart-add empty-cart "widget" :small 2)
-    "gadget"
-    :std 1)
-  (list (list "widget" :small 2) (list "gadget" :std 1)))
-
-(commerce-test
-  "add-preserves-order"
-  (cart-skus
-    (cart-add
-      (cart-add (cart-add empty-cart "a" :v 1) "b" :v 1)
-      "c"
-      :v 1))
-  (list "a" "b" "c"))
-
-;; --- qty queries ---
-
-(define
-  c2
-  (cart-add
-    (cart-add empty-cart "widget" :small 2)
-    "gadget"
-    :std 4))
-
-(commerce-test "cart-qty-found" (cart-qty c2 "widget" :small) 2)
-(commerce-test "cart-qty-missing" (cart-qty c2 "widget" :large) 0)
-(commerce-test "cart-count" (cart-count c2) 6)
-(commerce-test "cart-empty-yes" (cart-empty? empty-cart) true)
-(commerce-test "cart-empty-no" (cart-empty? c2) false)
-
-;; --- set-qty ---
-
-(commerce-test
-  "set-qty-existing"
-  (cart-set-qty c2 "widget" :small 10)
-  (list (list "widget" :small 10) (list "gadget" :std 4)))
-
-(commerce-test
-  "set-qty-new-line"
-  (cart-set-qty empty-cart "book" :std 3)
-  (list (list "book" :std 3)))
-
-(commerce-test
-  "set-qty-zero-removes"
-  (cart-set-qty c2 "widget" :small 0)
-  (list (list "gadget" :std 4)))
-
-;; --- remove ---
-
-(commerce-test
-  "remove-line"
-  (cart-remove c2 "gadget" :std)
-  (list (list "widget" :small 2)))
-
-(commerce-test
-  "remove-missing-noop"
-  (cart-remove c2 "nope" :std)
-  (list (list "widget" :small 2) (list "gadget" :std 4)))
-
-;; --- relational view ---
-
-(commerce-test
-  "cart-lineo-forward"
-  (run* q (cart-lineo c2 "gadget" :std q))
-  (list 4))
-
-(commerce-test
-  "cart-lineo-sku-by-qty-backward"
-  (run* sk (fresh (v) (cart-lineo c2 sk v 4)))
-  (list "gadget"))
-
-(commerce-test
-  "cart-lineo-all-skus"
-  (run* sk (fresh (v q) (cart-lineo c2 sk v q)))
-  (list "widget" "gadget"))

lib/commerce/tests/catalog.sx

@@ -1,93 +0,0 @@
-;; lib/commerce/tests/catalog.sx — catalog facts + relational accessors.
-;; Uses (commerce-test name got expected) provided by conformance.sh.
-;; Query vars avoid the name `s` (the run-n macro binds `s` internally).
-
-(define
-  cat
-  (make-catalog
-    (list
-      (list "widget" 1000 :standard)
-      (list "gadget" 2500 :standard)
-      (list "book" 800 :zero-rated)
-      (list "tea" 1000 :reduced))
-    (list
-      (list "widget" :small -200)
-      (list "widget" :large 500)
-      (list "gadget" :std 0))
-    (list
-      (list "widget" :small 5)
-      (list "widget" :large 0)
-      (list "gadget" :std 12))))
-
-;; --- forward lookups ---
-
-(commerce-test
-  "price-forward"
-  (run* p (priceo cat "widget" p))
-  (list 1000))
-(commerce-test
-  "class-forward"
-  (run* c (classo cat "book" c))
-  (list :zero-rated))
-(commerce-test
-  "product-forward"
-  (run* q (fresh (p c) (producto cat "gadget" p c) (== q (list p c))))
-  (list (list 2500 :standard)))
-
-;; --- backward lookups (the showcase) ---
-
-(commerce-test
-  "sku-by-price-backward"
-  (run* sk (priceo cat sk 1000))
-  (list "widget" "tea"))
-
-(commerce-test
-  "sku-by-class-backward"
-  (run* sk (classo cat sk :standard))
-  (list "widget" "gadget"))
-
-(commerce-test
-  "all-prices"
-  (run* p (fresh (sk) (priceo cat sk p)))
-  (list 1000 2500 800 1000))
-
-;; --- variants + effective unit price ---
-
-(commerce-test
-  "variant-delta-forward"
-  (run* d (varianto cat "widget" :small d))
-  (list -200))
-
-(commerce-test
-  "unit-price-small"
-  (run* p (unit-priceo cat "widget" :small p))
-  (list 800))
-
-(commerce-test
-  "unit-price-large"
-  (run* p (unit-priceo cat "widget" :large p))
-  (list 1500))
-
-(commerce-test
-  "variant-by-delta-backward"
-  (run* v (varianto cat "widget" v -200))
-  (list :small))
-
-;; --- stock ---
-
-(commerce-test
-  "stock-forward"
-  (run* q (stocko cat "widget" :small q))
-  (list 5))
-
-(commerce-test
-  "in-stock-skus-backward"
-  (run* sk (fresh (v q) (stocko cat sk v q) (lto-i 0 q)))
-  (list "widget" "gadget"))
-
-;; --- deterministic helpers ---
-
-(commerce-test "catalog-price-helper" (catalog-price cat "gadget") 2500)
-(commerce-test "catalog-class-helper" (catalog-class cat "tea") :reduced)
-(commerce-test "catalog-has-yes" (catalog-has? cat "book") true)
-(commerce-test "catalog-has-no" (catalog-has? cat "nonesuch") false)

lib/commerce/tests/federation.sx

@@ -1,88 +0,0 @@
-;; lib/commerce/tests/federation.sx — federated catalog (out-of-scope stub).
-;; Uses (commerce-test name got expected) provided by conformance.sh.
-
-(define
-  cat-a
-  (make-catalog
-    (list
-      (list "widget" 1000 :standard)
-      (list "book" 800 :zero-rated))
-    (list)
-    (list)))
-
-(define
-  cat-b
-  (make-catalog
-    (list
-      (list "widget" 900 :standard)
-      (list "tea" 1200 :reduced))
-    (list)
-    (list)))
-
-(define
-  cat-c
-  (make-catalog (list (list "widget" 1100 :standard)) (list) (list)))
-
-(define
-  fed
-  (federation-add
-    (federation-add (make-federation :alpha cat-a) :beta cat-b)
-    :gamma cat-c))
-
-;; --- structure ---
-
-(commerce-test "is-stub" federation-stub? true)
-(commerce-test
-  "instances"
-  (federation-instances fed)
-  (list :alpha :beta :gamma))
-(commerce-test "product-count" (len (fed-products fed)) 5)
-
-;; --- forward query ---
-
-(commerce-test
-  "price-at-instance"
-  (run* p (fed-priceo fed :beta "widget" p))
-  (list 900))
-
-;; --- backward queries (the showcase) ---
-
-(commerce-test
-  "instances-with-widget"
-  (instances-with-sku fed "widget")
-  (list :alpha :beta :gamma))
-
-(commerce-test
-  "instances-with-book"
-  (instances-with-sku fed "book")
-  (list :alpha))
-
-(commerce-test
-  "instances-with-tea"
-  (instances-with-sku fed "tea")
-  (list :beta))
-
-(commerce-test
-  "instance-by-price-backward"
-  (run* inst (fresh (c) (fed-producto fed inst "widget" 1100 c)))
-  (list :gamma))
-
-;; --- offers + cheapest (deterministic selection) ---
-
-(commerce-test
-  "widget-offers"
-  (sku-offers fed "widget")
-  (list
-    (list 1000 :alpha)
-    (list 900 :beta)
-    (list 1100 :gamma)))
-
-(commerce-test
-  "cheapest-widget"
-  (cheapest-offer fed "widget")
-  (list 900 :beta))
-(commerce-test
-  "cheapest-book"
-  (cheapest-offer fed "book")
-  (list 800 :alpha))
-(commerce-test "cheapest-missing" (cheapest-offer fed "ghost") nil)

lib/commerce/tests/integration.sx

@@ -1,104 +0,0 @@
-;; lib/commerce/tests/integration.sx — end-to-end composition proof.
-;; Uses (commerce-test name got expected) provided by conformance.sh.
-;;
-;; One narrative across every module: catalog → stock check → quote
-;; (promo+stack+tax) → order flow → payment envelope → settle → recon → refund.
-;; Proves the seams tie together with consistent numbers (the project's thesis:
-;; minikanren pricing + flow lifecycle + persist ledger compose).
-;; Builds one flow env with BOTH the order and refund flows.
-
-(define env (order-make-env))
-(define _rf (refund-flow-load! env))
-(define b (persist/mem-backend))
-
-(define
-  cat
-  (make-catalog
-    (list
-      (list "widget" 1000 :standard)
-      (list "book" 800 :zero-rated))
-    (list (list "widget" :small -200))
-    (list (list "widget" :small 10) (list "book" :none 5))))
-
-(define
-  rules
-  (list
-    (list :uk :standard :guest 2000)
-    (list :uk :zero-rated :guest 0)))
-
-(define ctx (make-pricing-context cat rules :uk :guest))
-
-(define
-  ruleset
-  (list
-    (list :percent "TEN" :standard 1000)
-    (list :fixed "FIVE" 0 50)))
-
-;; widget :small x2 → unit 800, extended 1600 (standard); book x1 → 800 (zero-rated)
-(define
-  cart
-  (list (list "widget" :small 2) (list "book" :none 1)))
-
-;; 1. stock gating passes (widget:small 10 >= 2)
-(commerce-test "int-can-reserve" (can-reserve? cat cart) true)
-
-;; 2. quote ties the whole pricing pipeline together
-;;    subtotal 2400; discount TEN 160 + FIVE 50 = 210; tax 1600@20% = 320;
-;;    total 2400 - 210 + 320 = 2510
-(define q (cart-quote ctx cart ruleset (list)))
-(commerce-test "int-quote-subtotal" (quote-subtotal q) 2400)
-(commerce-test "int-quote-discount" (quote-discount q) 210)
-(commerce-test "int-quote-tax" (quote-tax q) 320)
-(commerce-test "int-quote-total" (quote-total q) 2510)
-
-;; 3. attribution explains where the discount landed
-(commerce-test
-  "int-attribution"
-  (codes-for-line ctx cart ruleset (list "widget" :small 2))
-  (list "TEN"))
-(commerce-test
-  "int-order-level"
-  (order-level-codes ctx cart ruleset)
-  (list "FIVE"))
-
-;; 4. order carries the quote total into the ledger; suspends at payment
-(define oid "INT-1")
-(define id (order-begin! env b oid 1000 q))
-(commerce-test "int-order-total-from-quote" (order-total b oid) 2510)
-(commerce-test "int-waiting-payment" (order-flow-waiting env id) "payment")
-
-;; 5. the payment envelope reflects the quoted total
-(commerce-test
-  "int-payment-envelope"
-  (payment-request b oid :GBP "https://shop/return")
-  {:order "INT-1" :amount 2510 :return-url "https://shop/return" :currency :GBP})
-
-;; 6. settle the quoted amount → reconciles exactly
-(commerce-test
-  "int-settled"
-  (order-settle! env b id oid "pay-int" 1002 2510)
-  :settled)
-(commerce-test "int-status-fulfilled" (order-status b oid) :fulfilled)
-(commerce-test "int-recon-ok" (order-recon b oid) :ok)
-
-;; 7. partial refund via its own flow → recon moves to underpaid
-(define rid (refund-begin! env b oid "rf-int" 2000 510))
-(commerce-test "int-refund-approve" (refund-approve! env rid) :approved)
-(commerce-test
-  "int-refund-settle"
-  (refund-settle! env b rid oid "rf-int" 2001 510)
-  :settled)
-(commerce-test
-  "int-refunded-amount"
-  (order-refunded-amount-of (order-events b oid))
-  510)
-(commerce-test "int-recon-after-refund" (order-recon b oid) :underpaid)
-
-;; 8. ledger reconciliation flags the now-mismatched order
-(commerce-test
-  "int-mismatch"
-  (mismatched-orders b)
-  (list (order-stream "INT-1")))
-
-;; 9. distinct flow ids for the order and the refund
-(commerce-test "int-distinct-flow-ids" (not (= id rid)) true)

lib/commerce/tests/ledger.sx

@@ -1,80 +0,0 @@
-;; lib/commerce/tests/ledger.sx — order ledger on persist + idempotent recon.
-;; Uses (commerce-test name got expected) provided by conformance.sh.
-
-(define q1 {:codes (list) :subtotal 1000 :discount 0 :total 1200 :tax 200})
-
-;; --- lifecycle status projection ---
-
-(define b1 (persist/mem-backend))
-(define _c1 (order-create b1 "A1" 100 q1))
-(commerce-test "status-pending" (order-status b1 "A1") :pending)
-(define _r1 (order-reserve b1 "A1" 101 {:lines 2}))
-(commerce-test "status-reserved" (order-status b1 "A1") :reserved)
-(define _p1 (order-pay b1 "A1" "ref-1" 102 1200))
-(commerce-test "status-paid" (order-status b1 "A1") :paid)
-(define _f1 (order-fulfil b1 "A1" 103 {:carrier "post"}))
-(commerce-test "status-fulfilled" (order-status b1 "A1") :fulfilled)
-
-(commerce-test "total-projection" (order-total b1 "A1") 1200)
-(commerce-test "paid-projection" (order-paid b1 "A1") 1200)
-(commerce-test "recon-ok" (order-recon b1 "A1") :ok)
-(commerce-test "event-count" (len (order-events b1 "A1")) 4)
-
-;; --- idempotency: replayed webhook does not double-record ---
-
-(define b2 (persist/mem-backend))
-(define _c2 (order-create b2 "B1" 200 q1))
-(define _p2a (order-pay b2 "B1" "sumup-9" 201 1200))
-(define _p2b (order-pay b2 "B1" "sumup-9" 201 1200))
-(define _p2c (order-pay b2 "B1" "sumup-9" 201 1200))
-
-(commerce-test "idem-single-event" (len (order-events b2 "B1")) 2)
-(commerce-test "idem-paid-once" (order-paid b2 "B1") 1200)
-(commerce-test "idem-recon-ok" (order-recon b2 "B1") :ok)
-(commerce-test "idem-same-event" (= _p2a _p2c) true)
-
-;; --- mismatch detection ---
-
-(define bun (persist/mem-backend))
-(define _cu (order-create bun "U1" 300 q1))
-(commerce-test "unpaid-recon" (order-recon bun "U1") :unpaid)
-
-(define bup (persist/mem-backend))
-(define _cp (order-create bup "U2" 300 q1))
-(define _pp1 (order-pay bup "U2" "r-a" 301 1200))
-(define _pp2 (order-pay bup "U2" "r-b" 302 1200))
-(commerce-test "double-charge-overpaid" (order-recon bup "U2") :overpaid)
-(commerce-test "double-charge-amount" (order-paid bup "U2") 2400)
-
-(define bsh (persist/mem-backend))
-(define _cs (order-create bsh "U3" 400 q1))
-(define _ps (order-pay bsh "U3" "r-short" 401 1000))
-(commerce-test "underpaid-recon" (order-recon bsh "U3") :underpaid)
-
-;; --- refund (idempotent) reduces net ---
-
-(define brf (persist/mem-backend))
-(define _crf (order-create brf "R1" 500 q1))
-(define _prf (order-pay brf "R1" "p-1" 501 1200))
-(define _rf1 (order-refund brf "R1" "rf-1" 502 200))
-(define _rf2 (order-refund brf "R1" "rf-1" 502 200))
-(commerce-test "refund-idem-net" (order-recon brf "R1") :underpaid)
-(commerce-test "refund-idem-events" (len (order-events brf "R1")) 3)
-
-;; --- cross-ledger reconciliation ---
-
-(define bL (persist/mem-backend))
-(define _l1 (order-create bL "OK1" 600 q1))
-(define _l1p (order-pay bL "OK1" "ok-ref" 601 1200))
-(define _l2 (order-create bL "OVER1" 600 q1))
-(define _l2a (order-pay bL "OVER1" "o-a" 602 1200))
-(define _l2b (order-pay bL "OVER1" "o-b" 603 1200))
-(define _l3 (order-create bL "UNDER1" 600 q1))
-(define _l3p (order-pay bL "UNDER1" "u-ref" 604 900))
-(define _l4 (order-create bL "PENDING1" 600 q1))
-
-(commerce-test "ledger-order-count" (len (order-ids bL)) 4)
-(commerce-test
-  "ledger-mismatches"
-  (sort (ledger-mismatches bL))
-  (sort (list (order-stream "OVER1") (order-stream "UNDER1"))))

lib/commerce/tests/nettax.sx

@@ -1,92 +0,0 @@
-;; lib/commerce/tests/nettax.sx — discount-aware (net) tax policy.
-;; Uses (commerce-test name got expected) provided by conformance.sh.
-
-(define
-  pcat
-  (make-catalog
-    (list
-      (list "widget" 1000 :standard)
-      (list "tea" 1000 :reduced))
-    (list)
-    (list)))
-
-(define
-  rules
-  (list
-    (list :uk :standard :guest 2000)
-    (list :uk :reduced :guest 500)))
-
-(define gctx (make-pricing-context pcat rules :uk :guest))
-
-;; widget x3 = 3000 (standard), tea x6 = 6000 (reduced); subtotal 9000
-(define
-  cart
-  (list (list "widget" :none 3) (list "tea" :none 6)))
-
-(define ruleset (list (list :percent "TEN" :standard 1000)))
-
-;; --- allocation: proportional, sums exactly to the discount ---
-
-(commerce-test
-  "allocate-even"
-  (allocate-discount pcat cart 300)
-  (list 100 200))
-(commerce-test
-  "allocate-sums-to-discount"
-  (ct-sum (allocate-discount pcat cart 300))
-  300)
-
-;; remainder distribution: 100 over (3000,6000)/9000 = (33,66) rem 1 -> (34,66)
-(commerce-test
-  "allocate-remainder"
-  (allocate-discount pcat cart 100)
-  (list 34 66))
-(commerce-test
-  "allocate-remainder-sums"
-  (ct-sum (allocate-discount pcat cart 100))
-  100)
-
-(commerce-test
-  "allocate-zero"
-  (allocate-discount pcat cart 0)
-  (list 0 0))
-(commerce-test
-  "allocate-empty"
-  (allocate-discount pcat empty-cart 0)
-  (list))
-
-;; --- net tax vs gross tax ---
-;; discount = TEN 10% of standard 3000 = 300, allocated (100 200).
-;; net: widget 2900@20%=580, tea 5800@5%=290 -> net tax 870 (gross was 900).
-
-(commerce-test
-  "net-quote"
-  (cart-quote-net gctx cart ruleset (list))
-  {:codes (list "TEN") :subtotal 9000 :discount 300 :total 9570 :tax 870})
-
-;; same cart through the gross policy taxes 900 (the documented default)
-(commerce-test
-  "gross-quote-for-contrast"
-  (quote-tax (cart-quote gctx cart ruleset (list)))
-  900)
-
-(commerce-test
-  "net-tax-lower"
-  (quote-tax (cart-quote-net gctx cart ruleset (list)))
-  870)
-
-;; --- no discount: net policy == gross policy ---
-
-(commerce-test
-  "no-discount-net-equals-gross"
-  (=
-    (cart-quote-net gctx cart (list) (list))
-    (cart-quote gctx cart (list) (list)))
-  true)
-
-;; --- empty cart ---
-
-(commerce-test
-  "net-empty"
-  (cart-quote-net gctx empty-cart ruleset (list))
-  {:codes (list) :subtotal 0 :discount 0 :total 0 :tax 0})

lib/commerce/tests/order.sx

@@ -1,74 +0,0 @@
-;; lib/commerce/tests/order.sx — order lifecycle as a flow-on-sx flow.
-;; Uses (commerce-test name got expected) provided by conformance.sh.
-;; Builds the (expensive) flow env once; all assertions share it.
-
-(define env (order-make-env))
-(define b (persist/mem-backend))
-(define q1 {:codes (list) :subtotal 1000 :discount 0 :total 1200 :tax 200})
-
-;; --- happy path: begin suspends at payment ---
-
-(define id1 (order-begin! env b "O1" 100 q1))
-
-(commerce-test "begin-status-reserved" (order-status b "O1") :reserved)
-(commerce-test "begin-waiting-payment" (order-flow-waiting env id1) "payment")
-(commerce-test "begin-not-yet-paid" (order-paid b "O1") 0)
-
-;; --- settle: payment webhook drives fulfilment ---
-
-(define s1 (order-settle! env b id1 "O1" "ref-1" 102 1200))
-
-(commerce-test "settle-result" s1 :settled)
-(commerce-test "settle-status-fulfilled" (order-status b "O1") :fulfilled)
-(commerce-test "settle-flow-done" (order-flow-status env id1) "done")
-(commerce-test "settle-recon-ok" (order-recon b "O1") :ok)
-(commerce-test "settle-event-count" (len (order-events b "O1")) 4)
-
-;; --- webhook replay: a second settle is a no-op ---
-
-(define s1b (order-settle! env b id1 "O1" "ref-1" 102 1200))
-
-(commerce-test "replay-already-settled" s1b :already-settled)
-(commerce-test
-  "replay-no-extra-events"
-  (len (order-events b "O1"))
-  4)
-(commerce-test "replay-recon-still-ok" (order-recon b "O1") :ok)
-
-;; --- a second order gets its own flow id and suspends independently ---
-
-(define id2 (order-begin! env b "O2" 200 q1))
-
-(commerce-test "second-distinct-id" (not (= id1 id2)) true)
-(commerce-test
-  "second-waiting-payment"
-  (order-flow-waiting env id2)
-  "payment")
-(commerce-test "first-unaffected" (order-status b "O1") :fulfilled)
-
-;; --- durability: a suspended order survives a process restart ---
-
-(define id3 (order-begin! env b "O3" 300 q1))
-(commerce-test "pre-restart-waiting" (order-flow-waiting env id3) "payment")
-
-(define _restart (order-flow-restart! env))
-
-(commerce-test
-  "post-restart-still-waiting"
-  (order-flow-waiting env id3)
-  "payment")
-(commerce-test "post-restart-ledger-intact" (order-status b "O3") :reserved)
-
-(define s3 (order-settle! env b id3 "O3" "ref-3" 302 1200))
-
-(commerce-test "post-restart-settled" s3 :settled)
-(commerce-test "post-restart-status" (order-status b "O3") :fulfilled)
-(commerce-test "post-restart-recon-ok" (order-recon b "O3") :ok)
-(commerce-test "post-restart-flow-done" (order-flow-status env id3) "done")
-
-;; --- payment-request envelope (provider-neutral) for the still-suspended O2 ---
-
-(commerce-test
-  "pending-payments-lists-suspended"
-  (pending-payments env b :GBP "https://shop/return")
-  (list {:id id2 :request {:order "O2" :amount 1200 :return-url "https://shop/return" :currency :GBP}}))

lib/commerce/tests/payment.sx

@@ -1,43 +0,0 @@
-;; lib/commerce/tests/payment.sx — provider-neutral payment-request envelope.
-;; Uses (commerce-test name got expected) provided by conformance.sh.
-;; Envelope construction is ledger-only (no flow env); pending-payments (which
-;; needs the flow env) is exercised in the order suite.
-
-(define q1 {:codes (list) :subtotal 1000 :discount 0 :total 1200 :tax 200})
-(define q2 {:codes (list) :subtotal 5000 :discount 500 :total 4500 :tax 0})
-
-(define b (persist/mem-backend))
-(define _c1 (order-create b "P1" 1 q1))
-(define _c2 (order-create b "P2" 1 q2))
-
-(commerce-test
-  "envelope"
-  (payment-request b "P1" :GBP "https://shop/return")
-  {:order "P1" :amount 1200 :return-url "https://shop/return" :currency :GBP})
-
-(commerce-test
-  "envelope-amount"
-  (payment-request-amount (payment-request b "P1" :GBP "x"))
-  1200)
-(commerce-test
-  "envelope-currency"
-  (payment-request-currency (payment-request b "P1" :GBP "x"))
-  :GBP)
-(commerce-test
-  "envelope-order"
-  (payment-request-order (payment-request b "P1" :GBP "x"))
-  "P1")
-(commerce-test
-  "envelope-return-url"
-  (payment-request-return-url (payment-request b "P1" :GBP "https://r"))
-  "https://r")
-
-;; amount tracks the ledger total, currency is per-call (provider/instance config)
-(commerce-test
-  "envelope-amount-2"
-  (payment-request-amount (payment-request b "P2" :EUR "x"))
-  4500)
-(commerce-test
-  "envelope-currency-2"
-  (payment-request-currency (payment-request b "P2" :EUR "x"))
-  :EUR)

lib/commerce/tests/price.sx

@@ -1,100 +0,0 @@
-;; lib/commerce/tests/price.sx — subtotal + jurisdiction-relational tax.
-;; Uses (commerce-test name got expected) provided by conformance.sh.
-
-(define
-  pcat
-  (make-catalog
-    (list
-      (list "widget" 1000 :standard)
-      (list "book" 800 :zero-rated)
-      (list "tea" 1000 :reduced))
-    (list
-      (list "widget" :small -200)
-      (list "widget" :large 500))
-    (list)))
-
-(define
-  rules
-  (list
-    (list :uk :standard :guest 2000)
-    (list :uk :reduced :guest 500)
-    (list :uk :zero-rated :guest 0)
-    (list :uk :standard :member 1000)
-    (list :ie :standard :guest 2300)))
-
-(define gctx (make-pricing-context pcat rules :uk :guest))
-(define mctx (make-pricing-context pcat rules :uk :member))
-
-;; --- unit + line pricing ---
-
-(commerce-test
-  "unit-price-variant"
-  (line-unit-price pcat "widget" :small)
-  800)
-(commerce-test
-  "unit-price-no-variant"
-  (line-unit-price pcat "widget" :none)
-  1000)
-(commerce-test "unit-price-unknown" (line-unit-price pcat "ghost" :none) nil)
-(commerce-test
-  "line-extended"
-  (line-extended pcat (list "widget" :small 2))
-  1600)
-
-;; --- subtotal ---
-
-(define
-  cart1
-  (list (list "widget" :small 2) (list "book" :none 1)))
-
-(commerce-test "subtotal" (cart-subtotal pcat cart1) 2400)
-(commerce-test "subtotal-empty" (cart-subtotal pcat empty-cart) 0)
-
-;; --- tax rate lookup (relational, both directions) ---
-
-(commerce-test
-  "rate-forward"
-  (rate-bps rules :uk :standard :guest)
-  2000)
-(commerce-test
-  "rate-missing"
-  (rate-bps rules :fr :standard :guest)
-  0)
-(commerce-test
-  "rate-juris-by-bps-backward"
-  (run* j (fresh (cust) (taxo rules j :standard cust 2300)))
-  (list :ie))
-(commerce-test
-  "rate-customer-by-bps-backward"
-  (run* cust (taxo rules :uk :standard cust 1000))
-  (list :member))
-
-;; --- apply-bps rounding (half up, integer only) ---
-
-(commerce-test "bps-exact" (apply-bps 1600 2000) 320)
-(commerce-test "bps-round-up" (apply-bps 799 2000) 160)
-(commerce-test "bps-zero" (apply-bps 800 0) 0)
-
-;; --- line + cart tax ---
-
-(commerce-test
-  "line-tax-standard"
-  (line-tax gctx (list "widget" :small 2))
-  320)
-(commerce-test
-  "line-tax-zero-rated"
-  (line-tax gctx (list "book" :none 1))
-  0)
-(commerce-test
-  "line-tax-member"
-  (line-tax mctx (list "widget" :small 2))
-  160)
-(commerce-test "cart-tax-guest" (cart-tax gctx cart1) 320)
-
-;; --- total dict (deterministic) ---
-
-(commerce-test "total-guest" (cart-total gctx cart1) {:subtotal 2400 :discounts 0 :total 2720 :tax 320})
-
-(commerce-test "total-member" (cart-total mctx cart1) {:subtotal 2400 :discounts 0 :total 2560 :tax 160})
-
-(commerce-test "total-empty" (cart-total gctx empty-cart) {:subtotal 0 :discounts 0 :total 0 :tax 0})

lib/commerce/tests/promo.sx

@@ -1,142 +0,0 @@
-;; lib/commerce/tests/promo.sx — promo rules + relational enumeration.
-;; Uses (commerce-test name got expected) provided by conformance.sh.
-
-(define
-  pcat
-  (make-catalog
-    (list
-      (list "widget" 1000 :standard)
-      (list "book" 800 :zero-rated)
-      (list "tea" 1000 :reduced))
-    (list)
-    (list)))
-
-(define gctx (make-pricing-context pcat (list) :uk :guest))
-(define mctx (make-pricing-context pcat (list) :uk :member))
-
-(define
-  cart
-  (list
-    (list "widget" :none 3)
-    (list "book" :none 1)
-    (list "tea" :none 6)))
-
-(define
-  ruleset
-  (list
-    (list :percent "TEN" :standard 1000)
-    (list :fixed "FIVER" 5000 500)
-    (list :bundle "B3T" "tea" 3)
-    (list :member "MEM" :standard 1500)))
-
-;; --- per-type amounts ---
-
-(commerce-test
-  "percent-amount"
-  (promo-amount gctx cart (list :percent "TEN" :standard 1000))
-  300)
-
-(commerce-test
-  "fixed-amount-met"
-  (promo-amount gctx cart (list :fixed "FIVER" 5000 500))
-  500)
-
-(commerce-test
-  "fixed-amount-not-met"
-  (promo-amount
-    gctx
-    (list (list "widget" :none 1))
-    (list :fixed "FIVER" 5000 500))
-  0)
-
-(commerce-test
-  "fixed-amount-capped"
-  (promo-amount
-    gctx
-    (list (list "book" :none 1))
-    (list :fixed "BIG" 0 9999))
-  800)
-
-(commerce-test
-  "bundle-amount"
-  (promo-amount gctx cart (list :bundle "B3T" "tea" 3))
-  2000)
-
-(commerce-test
-  "member-amount-guest"
-  (promo-amount gctx cart (list :member "MEM" :standard 1500))
-  0)
-
-(commerce-test
-  "member-amount-member"
-  (promo-amount mctx cart (list :member "MEM" :standard 1500))
-  450)
-
-;; --- relational enumeration: forward ---
-
-(commerce-test
-  "discounto-all-guest"
-  (run*
-    pair
-    (fresh
-      (code amount)
-      (promo-discounto gctx cart ruleset code amount)
-      (== pair (list code amount))))
-  (list
-    (list "TEN" 300)
-    (list "FIVER" 500)
-    (list "B3T" 2000)
-    (list "MEM" 0)))
-
-(commerce-test
-  "applicable-guest"
-  (applicable-promos gctx cart ruleset)
-  (list
-    (list "TEN" 300)
-    (list "FIVER" 500)
-    (list "B3T" 2000)))
-
-(commerce-test
-  "applicable-member"
-  (applicable-promos mctx cart ruleset)
-  (list
-    (list "TEN" 300)
-    (list "FIVER" 500)
-    (list "B3T" 2000)
-    (list "MEM" 450)))
-
-;; --- relational enumeration: backward (the showcase) ---
-
-(commerce-test
-  "code-by-discount-2000"
-  (run* code (promo-applieso gctx cart ruleset code 2000))
-  (list "B3T"))
-
-(commerce-test
-  "code-by-discount-500"
-  (run* code (promo-applieso gctx cart ruleset code 500))
-  (list "FIVER"))
-
-(commerce-test
-  "code-by-discount-none"
-  (run* code (promo-applieso gctx cart ruleset code 9999))
-  (list))
-
-;; --- deterministic helpers ---
-
-(commerce-test
-  "amount-for-ten"
-  (promo-amount-for gctx cart ruleset "TEN")
-  300)
-(commerce-test
-  "amount-for-mem-guest"
-  (promo-amount-for gctx cart ruleset "MEM")
-  0)
-(commerce-test
-  "amount-for-mem-member"
-  (promo-amount-for mctx cart ruleset "MEM")
-  450)
-(commerce-test
-  "amount-for-absent"
-  (promo-amount-for gctx cart ruleset "NOPE")
-  0)

lib/commerce/tests/quote.sx

@@ -1,108 +0,0 @@
-;; lib/commerce/tests/quote.sx — composed priced quote (price+promo+stacking).
-;; Uses (commerce-test name got expected) provided by conformance.sh.
-
-(define
-  pcat
-  (make-catalog
-    (list
-      (list "widget" 1000 :standard)
-      (list "book" 800 :zero-rated)
-      (list "tea" 1000 :reduced))
-    (list)
-    (list)))
-
-(define
-  tax-rules
-  (list
-    (list :uk :standard :guest 2000)
-    (list :uk :reduced :guest 500)
-    (list :uk :zero-rated :guest 0)
-    (list :uk :standard :member 2000)
-    (list :uk :reduced :member 500)
-    (list :uk :zero-rated :member 0)))
-
-(define gctx (make-pricing-context pcat tax-rules :uk :guest))
-(define mctx (make-pricing-context pcat tax-rules :uk :member))
-
-(define
-  cart
-  (list
-    (list "widget" :none 3)
-    (list "book" :none 1)
-    (list "tea" :none 6)))
-
-(define
-  ruleset
-  (list
-    (list :percent "TEN" :standard 1000)
-    (list :percent "TWENTY" :standard 2000)
-    (list :fixed "FIVER" 5000 500)
-    (list :bundle "B3T" "tea" 3)
-    (list :member "MEM" :standard 2500)))
-
-(define
-  exclusions
-  (list (list "TEN" "TWENTY") (list "TEN" "MEM") (list "TWENTY" "MEM")))
-
-;; subtotal: 3000 + 800 + 6000 = 9800
-;; tax (gross): widget 600 + tea 300 + book 0 = 900
-;; guest discount: TWENTY 600 + FIVER 500 + B3T 2000 = 3100
-;; guest total: 9800 - 3100 + 900 = 7600
-
-(define gq (cart-quote gctx cart ruleset exclusions))
-
-(commerce-test "quote-subtotal" (quote-subtotal gq) 9800)
-(commerce-test "quote-tax" (quote-tax gq) 900)
-(commerce-test "quote-discount-guest" (quote-discount gq) 3100)
-(commerce-test "quote-total-guest" (quote-total gq) 7600)
-(commerce-test
-  "quote-codes-guest"
-  (quote-codes gq)
-  (list "TWENTY" "FIVER" "B3T"))
-
-(commerce-test "quote-full-guest" gq {:codes (list "TWENTY" "FIVER" "B3T") :subtotal 9800 :discount 3100 :total 7600 :tax 900})
-
-;; member discount: MEM 750 + FIVER 500 + B3T 2000 = 3250
-;; member total: 9800 - 3250 + 900 = 7450
-(define mq (cart-quote mctx cart ruleset exclusions))
-
-(commerce-test "quote-discount-member" (quote-discount mq) 3250)
-(commerce-test "quote-total-member" (quote-total mq) 7450)
-(commerce-test
-  "quote-codes-member"
-  (quote-codes mq)
-  (list "FIVER" "B3T" "MEM"))
-
-;; --- determinism: same inputs, identical quote ---
-
-(commerce-test
-  "quote-deterministic"
-  (=
-    (cart-quote gctx cart ruleset exclusions)
-    (cart-quote gctx cart ruleset exclusions))
-  true)
-
-;; --- no promos: discount 0, total = subtotal + tax ---
-
-(commerce-test
-  "quote-no-promos"
-  (cart-quote gctx cart (list) (list))
-  {:codes (list) :subtotal 9800 :discount 0 :total 10700 :tax 900})
-
-;; --- empty cart ---
-
-(commerce-test
-  "quote-empty"
-  (cart-quote gctx empty-cart ruleset exclusions)
-  {:codes (list) :subtotal 0 :discount 0 :total 0 :tax 0})
-
-;; --- session convenience ---
-
-(define
-  sess
-  (commerce-add (commerce-session gctx) "widget" :none 3))
-
-(commerce-test
-  "session-quote"
-  (quote-total (session-quote sess ruleset exclusions))
-  3000)

lib/commerce/tests/recon.sx

@@ -1,109 +0,0 @@
-;; lib/commerce/tests/recon.sx — reconciliation as relational ledger queries.
-;; Uses (commerce-test name got expected) provided by conformance.sh.
-
-(define q1 {:codes (list) :subtotal 1000 :discount 0 :total 1200 :tax 200})
-
-(define b (persist/mem-backend))
-
-;; OK1 — clean payment
-(define _ok (order-create b "OK1" 1 q1))
-(define _okp (order-pay b "OK1" "ok-ref" 2 1200))
-
-;; OVER1 — double charge under two different refs
-(define _ov (order-create b "OVER1" 1 q1))
-(define _ova (order-pay b "OVER1" "ov-a" 2 1200))
-(define _ovb (order-pay b "OVER1" "ov-b" 3 1200))
-
-;; UNDER1 — short payment
-(define _un (order-create b "UNDER1" 1 q1))
-(define _unp (order-pay b "UNDER1" "un-ref" 2 900))
-
-;; PART1 — paid in full, then partially refunded
-(define _pa (order-create b "PART1" 1 q1))
-(define _pap (order-pay b "PART1" "pa-ref" 2 1200))
-(define _par (order-refund b "PART1" "pa-rf" 3 200))
-
-;; REPLAY1 — webhook fires twice with the same ref (idempotent)
-(define _rp (order-create b "REPLAY1" 1 q1))
-(define _rpa (order-pay b "REPLAY1" "rp-ref" 2 1200))
-(define _rpb (order-pay b "REPLAY1" "rp-ref" 2 1200))
-
-;; PEND1 — created, not yet paid
-(define _pe (order-create b "PEND1" 1 q1))
-
-;; --- summaries ---
-
-(commerce-test "summary-count" (len (ledger-summaries b)) 6)
-(commerce-test
-  "summary-ok1"
-  (order-summary b "order/OK1")
-  (list "order/OK1" 1200 1200 0 1200 :ok))
-(commerce-test
-  "summary-part1"
-  (order-summary b "order/PART1")
-  (list "order/PART1" 1200 1200 200 1000 :underpaid))
-
-;; --- forward status query ---
-
-(commerce-test
-  "status-forward-ok"
-  (run* st (recon-statuso (ledger-summaries b) "order/OK1" st))
-  (list :ok))
-
-;; --- backward status queries (the showcase) ---
-
-(commerce-test
-  "settled"
-  (sort (settled-orders b))
-  (sort (list "order/OK1" "order/REPLAY1")))
-(commerce-test "overpaid" (overpaid-orders b) (list "order/OVER1"))
-(commerce-test
-  "underpaid"
-  (sort (underpaid-orders b))
-  (sort (list "order/UNDER1" "order/PART1")))
-(commerce-test "unpaid" (unpaid-orders b) (list "order/PEND1"))
-(commerce-test
-  "mismatched"
-  (sort (mismatched-orders b))
-  (sort (list "order/OVER1" "order/UNDER1" "order/PART1")))
-
-;; --- backward net-amount query ---
-
-(commerce-test
-  "net-1200"
-  (sort (orders-with-net b 1200))
-  (sort (list "order/OK1" "order/REPLAY1")))
-(commerce-test
-  "net-2400"
-  (orders-with-net b 2400)
-  (list "order/OVER1"))
-(commerce-test
-  "net-900"
-  (orders-with-net b 900)
-  (list "order/UNDER1"))
-
-;; --- discrepancy: +1200 (over) - 300 (under) - 200 (refund) = 700 ---
-
-(commerce-test "discrepancy" (ledger-discrepancy b) 700)
-
-;; --- double-charge guard ---
-
-(commerce-test "double-charge-detected" (order-recon b "OVER1") :overpaid)
-(commerce-test "double-charge-amount" (order-paid b "OVER1") 2400)
-
-;; --- partial refund ---
-
-(commerce-test "partial-refund-net" (order-recon b "PART1") :underpaid)
-(commerce-test
-  "partial-refund-amount"
-  (order-refunded-amount-of (order-events b "PART1"))
-  200)
-
-;; --- webhook replay: same ref twice records once ---
-
-(commerce-test
-  "replay-single-event"
-  (len (order-events b "REPLAY1"))
-  2)
-(commerce-test "replay-paid-once" (order-paid b "REPLAY1") 1200)
-(commerce-test "replay-settled" (order-recon b "REPLAY1") :ok)

lib/commerce/tests/refund.sx

@@ -1,78 +0,0 @@
-;; lib/commerce/tests/refund.sx — refund lifecycle as a flow-on-sx flow.
-;; Uses (commerce-test name got expected) provided by conformance.sh.
-;; Builds the (expensive) flow env once; all assertions share it.
-
-(define env (refund-make-env))
-(define b (persist/mem-backend))
-(define q1 {:codes (list) :subtotal 1000 :discount 0 :total 1200 :tax 200})
-
-;; a paid, fulfilled order to refund (set up directly via the ledger)
-(define _c (order-create b "O1" 1 q1))
-(define _p (order-pay b "O1" "pay-1" 2 1200))
-(commerce-test "setup-recon-ok" (order-recon b "O1") :ok)
-
-;; --- happy path: request -> approve -> settle ---
-
-(define rid (refund-begin! env b "O1" "rf-1" 10 500))
-
-(commerce-test "begin-waiting-approve" (order-flow-waiting env rid) "approve")
-(commerce-test
-  "begin-not-yet-refunded"
-  (order-refunded-amount-of (order-events b "O1"))
-  0)
-(commerce-test "begin-recon-unchanged" (order-recon b "O1") :ok)
-
-(define a1 (refund-approve! env rid))
-(commerce-test "approve-result" a1 :approved)
-(commerce-test "approve-waiting-settle" (order-flow-waiting env rid) "settle")
-
-(define s1 (refund-settle! env b rid "O1" "rf-1" 11 500))
-(commerce-test "settle-result" s1 :settled)
-(commerce-test "settle-flow-done" (order-flow-status env rid) "done")
-(commerce-test
-  "settle-refunded-amount"
-  (order-refunded-amount-of (order-events b "O1"))
-  500)
-;; net 1200 - 500 = 700 < total 1200 -> underpaid (partial refund)
-(commerce-test "settle-recon-underpaid" (order-recon b "O1") :underpaid)
-
-;; --- idempotent settle: replayed provider callback is a no-op ---
-
-(define s1b (refund-settle! env b rid "O1" "rf-1" 11 500))
-(commerce-test "replay-already-settled" s1b :already-settled)
-(commerce-test
-  "replay-refunded-once"
-  (order-refunded-amount-of (order-events b "O1"))
-  500)
-
-;; --- reject path: approval denied, books untouched ---
-
-(define _c2 (order-create b "O2" 1 q1))
-(define _p2 (order-pay b "O2" "pay-2" 2 1200))
-
-(define rid2 (refund-begin! env b "O2" "rf-2" 20 1200))
-(commerce-test
-  "reject-waiting-approve"
-  (order-flow-waiting env rid2)
-  "approve")
-
-(define j2 (refund-reject! env b "O2" rid2 21 "policy"))
-(commerce-test "reject-result" j2 :rejected)
-(commerce-test "reject-flow-not-waiting" (order-flow-waiting env rid2) nil)
-(commerce-test
-  "reject-no-refund"
-  (order-refunded-amount-of (order-events b "O2"))
-  0)
-(commerce-test "reject-recon-ok" (order-recon b "O2") :ok)
-
-;; settling a rejected/cancelled refund does nothing
-(define s2 (refund-settle! env b rid2 "O2" "rf-2" 22 1200))
-(commerce-test "reject-then-settle-noop" s2 :already-settled)
-(commerce-test
-  "reject-still-no-refund"
-  (order-refunded-amount-of (order-events b "O2"))
-  0)
-
-;; --- distinct flow ids ---
-
-(commerce-test "distinct-refund-ids" (not (= rid rid2)) true)

lib/commerce/tests/stack.sx

@@ -1,127 +0,0 @@
-;; lib/commerce/tests/stack.sx — stacking precedence, exclusivity, best price.
-;; Uses (commerce-test name got expected) provided by conformance.sh.
-
-(define
-  pcat
-  (make-catalog
-    (list
-      (list "widget" 1000 :standard)
-      (list "book" 800 :zero-rated)
-      (list "tea" 1000 :reduced))
-    (list)
-    (list)))
-
-(define gctx (make-pricing-context pcat (list) :uk :guest))
-(define mctx (make-pricing-context pcat (list) :uk :member))
-
-(define
-  cart
-  (list
-    (list "widget" :none 3)
-    (list "book" :none 1)
-    (list "tea" :none 6)))
-
-(define
-  ruleset
-  (list
-    (list :percent "TEN" :standard 1000)
-    (list :percent "TWENTY" :standard 2000)
-    (list :fixed "FIVER" 5000 500)
-    (list :bundle "B3T" "tea" 3)
-    (list :member "MEM" :standard 2500)))
-
-;; The three standard-class discounts are mutually exclusive.
-(define
-  exclusions
-  (list (list "TEN" "TWENTY") (list "TEN" "MEM") (list "TWENTY" "MEM")))
-
-;; --- exclusivity predicates ---
-
-(commerce-test
-  "excluded-pair-direct"
-  (excluded-pair? exclusions "TEN" "TWENTY")
-  true)
-(commerce-test
-  "excluded-pair-symmetric"
-  (excluded-pair? exclusions "TWENTY" "TEN")
-  true)
-(commerce-test
-  "excluded-pair-none"
-  (excluded-pair? exclusions "TEN" "FIVER")
-  false)
-(commerce-test
-  "compatible-yes"
-  (compatible? exclusions (list "FIVER" "B3T" "TWENTY"))
-  true)
-(commerce-test
-  "compatible-no"
-  (compatible? exclusions (list "TEN" "TWENTY" "B3T"))
-  false)
-
-;; --- powerset + valid stackings ---
-
-(commerce-test
-  "powerset-size"
-  (len (powerset (list 1 2 3 4)))
-  16)
-
-(define gappl (applicable-promos gctx cart ruleset))
-
-(commerce-test "applicable-guest-count" (len gappl) 4)
-
-;; 16 subsets minus the 4 containing both TEN and TWENTY = 12 legal.
-(commerce-test
-  "valid-stackings-count"
-  (len (valid-stackings exclusions gappl))
-  12)
-
-(commerce-test
-  "stacking-total"
-  (stacking-total (list (list "TWENTY" 600) (list "B3T" 2000)))
-  2600)
-
-;; --- best price (deterministic selection) ---
-
-(commerce-test
-  "best-discount-guest"
-  (best-promo-discount gctx cart ruleset exclusions)
-  3100)
-(commerce-test
-  "best-codes-guest"
-  (best-promo-codes gctx cart ruleset exclusions)
-  (list "TWENTY" "FIVER" "B3T"))
-
-;; exclusivity holds: the cheaper conflicting code is dropped.
-(commerce-test
-  "best-excludes-ten"
-  (some
-    (fn (c) (= c "TEN"))
-    (best-promo-codes gctx cart ruleset exclusions))
-  false)
-
-;; --- member vs guest ---
-
-(commerce-test
-  "best-discount-member"
-  (best-promo-discount mctx cart ruleset exclusions)
-  3250)
-(commerce-test
-  "best-codes-member"
-  (best-promo-codes mctx cart ruleset exclusions)
-  (list "FIVER" "B3T" "MEM"))
-
-;; --- best price backward query (the showcase) ---
-
-(commerce-test
-  "stacking-by-total-backward"
-  (run*
-    codes
-    (stacking-by-totalo (valid-stackings exclusions gappl) codes 3100))
-  (list (list "TWENTY" "FIVER" "B3T")))
-
-;; --- edge: no applicable promos ---
-
-(commerce-test
-  "best-empty"
-  (best-promo-discount gctx empty-cart ruleset exclusions)
-  0)

lib/commerce/tests/stock.sx

@@ -1,122 +0,0 @@
-;; lib/commerce/tests/stock.sx — stock-constrained reservation.
-;; Uses (commerce-test name got expected) provided by conformance.sh.
-
-(define
-  cat
-  (make-catalog
-    (list
-      (list "widget" 1000 :standard)
-      (list "gadget" 2500 :standard))
-    (list)
-    (list
-      (list "widget" :small 5)
-      (list "widget" :large 0)
-      (list "gadget" :std 12))))
-
-;; --- availability ---
-
-(commerce-test
-  "available-found"
-  (available-stock cat "widget" :small)
-  5)
-(commerce-test
-  "available-zero"
-  (available-stock cat "widget" :large)
-  0)
-(commerce-test
-  "available-absent"
-  (available-stock cat "widget" :none)
-  0)
-
-;; --- per-line reservability ---
-
-(commerce-test
-  "shortfall-fits"
-  (line-shortfall cat (list "widget" :small 5))
-  0)
-(commerce-test
-  "shortfall-over"
-  (line-shortfall cat (list "widget" :small 8))
-  3)
-(commerce-test
-  "reservable-yes"
-  (line-reservable? cat (list "gadget" :std 12))
-  true)
-(commerce-test
-  "reservable-no"
-  (line-reservable? cat (list "widget" :large 1))
-  false)
-
-;; --- cart-level reservation check ---
-
-(commerce-test
-  "can-reserve-yes"
-  (can-reserve?
-    cat
-    (list (list "widget" :small 5) (list "gadget" :std 2)))
-  true)
-
-(commerce-test
-  "can-reserve-no"
-  (can-reserve? cat (list (list "widget" :small 9)))
-  false)
-
-(commerce-test
-  "shortfalls-detail"
-  (reservation-shortfalls
-    cat
-    (list (list "widget" :small 9) (list "gadget" :std 2)))
-  (list {:requested 9 :available 5 :sku "widget" :variant :small :short 4}))
-
-(commerce-test
-  "reserve-check-ok"
-  (reserve-check cat (list (list "gadget" :std 1)))
-  :ok)
-
-(commerce-test
-  "reserve-check-rejected"
-  (reserve-check cat (list (list "widget" :large 1)))
-  {:shortfalls (list {:requested 1 :available 0 :sku "widget" :variant :large :short 1}) :rejected :insufficient-stock})
-
-;; --- reservation view: concurrent holds reduce availability ---
-
-(define held (list (list "widget" :small 3)))
-
-(commerce-test
-  "effective-after-hold"
-  (effective-available cat held "widget" :small)
-  2)
-(commerce-test
-  "effective-other-unaffected"
-  (effective-available cat held "gadget" :std)
-  12)
-(commerce-test
-  "reservable-with-fits"
-  (line-reservable-with? cat held (list "widget" :small 2))
-  true)
-(commerce-test
-  "reservable-with-over"
-  (line-reservable-with? cat held (list "widget" :small 3))
-  false)
-
-;; --- relational availability query (multidirectional) ---
-
-(commerce-test
-  "sufficient-forward"
-  (run*
-    x
-    (fresh () (sufficient-stocko cat "widget" :small 5) (== x true)))
-  (list true))
-
-(commerce-test
-  "sufficient-forward-over"
-  (run*
-    x
-    (fresh () (sufficient-stocko cat "widget" :small 6) (== x true)))
-  (list))
-
-;; backward: which variants of widget can supply 1 unit?
-(commerce-test
-  "variants-supplying-1"
-  (run* v (fresh (q) (stocko cat "widget" v q) (lteo-i 1 q)))
-  (list :small))

lib/commerce/tests/window.sx

@@ -1,112 +0,0 @@
-;; lib/commerce/tests/window.sx — time-windowed promotions.
-;; Uses (commerce-test name got expected) provided by conformance.sh.
-
-(define
-  pcat
-  (make-catalog (list (list "widget" 1000 :standard)) (list) (list)))
-
-(define gctx (make-pricing-context pcat (list) :uk :guest))
-(define cart (list (list "widget" :none 3)))
-
-(define ten (list :percent "TEN" :standard 1000))
-(define twenty (list :percent "TWENTY" :standard 2000))
-(define always (list :fixed "ALWAYS" 0 100))
-
-(define
-  windowed
-  (list
-    (windowed-promo ten 100 200)
-    (windowed-promo twenty 150 300)
-    (windowed-promo always nil nil)))
-
-(define exclusions (list (list "TEN" "TWENTY")))
-
-;; --- wp-active? boundaries (inclusive) ---
-
-(commerce-test
-  "active-at-from"
-  (wp-active? (windowed-promo ten 100 200) 100)
-  true)
-(commerce-test
-  "active-at-until"
-  (wp-active? (windowed-promo ten 100 200) 200)
-  true)
-(commerce-test
-  "inactive-before"
-  (wp-active? (windowed-promo ten 100 200) 99)
-  false)
-(commerce-test
-  "inactive-after"
-  (wp-active? (windowed-promo ten 100 200) 201)
-  false)
-(commerce-test
-  "open-ended-always"
-  (wp-active? (windowed-promo always nil nil) 99999)
-  true)
-(commerce-test
-  "open-lower"
-  (wp-active? (windowed-promo ten nil 200) 1)
-  true)
-(commerce-test
-  "open-upper"
-  (wp-active? (windowed-promo ten 100 nil) 99999)
-  true)
-
-;; --- active-ruleset filtering ---
-
-(commerce-test
-  "active-ruleset-120"
-  (active-ruleset windowed 120)
-  (list ten always))
-(commerce-test
-  "active-ruleset-160"
-  (active-ruleset windowed 160)
-  (list ten twenty always))
-(commerce-test
-  "active-ruleset-250"
-  (active-ruleset windowed 250)
-  (list twenty always))
-(commerce-test
-  "active-ruleset-50"
-  (active-ruleset windowed 50)
-  (list always))
-
-;; --- active-codes (backward query) ---
-
-(commerce-test
-  "active-codes-120"
-  (active-codes windowed 120)
-  (list "TEN" "ALWAYS"))
-(commerce-test
-  "active-codes-160"
-  (active-codes windowed 160)
-  (list "TEN" "TWENTY" "ALWAYS"))
-(commerce-test
-  "active-codes-50"
-  (active-codes windowed 50)
-  (list "ALWAYS"))
-
-;; --- windowed-quote: discount changes with time (deterministic) ---
-;; subtotal 3000, no tax. TEN=300, TWENTY=600, ALWAYS=100; TEN/TWENTY exclusive.
-
-(commerce-test
-  "quote-50"
-  (quote-discount (windowed-quote gctx cart windowed exclusions 50))
-  100)
-(commerce-test
-  "quote-120"
-  (quote-discount (windowed-quote gctx cart windowed exclusions 120))
-  400)
-(commerce-test
-  "quote-160"
-  (quote-discount (windowed-quote gctx cart windowed exclusions 160))
-  700)
-(commerce-test
-  "quote-250"
-  (quote-discount (windowed-quote gctx cart windowed exclusions 250))
-  700)
-
-(commerce-test
-  "quote-total-160"
-  (quote-total (windowed-quote gctx cart windowed exclusions 160))
-  2300)

lib/commerce/window.sx

@@ -1,55 +0,0 @@
-;; lib/commerce/window.sx — time-windowed promotions.
-;;
-;; A promo's validity window is kept SEPARATE from the promo tuple (so promo.sx
-;; is untouched): a windowed promo is (list promo from until) with inclusive
-;; integer timestamps (same time model as the ledger `at`). nil from = no lower
-;; bound; nil until = open-ended.
-;;
-;; `active-ruleset` filters a windowed ruleset to the plain promos live at a
-;; given time, which feeds straight into promo/stack/quote — so a datetime-aware
-;; quote is just the existing pipeline over the active set. Deterministic: the
-;; quote is a pure function of (ctx, cart, windowed-ruleset, exclusions, at).
-
-(define windowed-promo (fn (promo from until) (list promo from until)))
-
-(define wp-promo (fn (wp) (nth wp 0)))
-(define wp-from (fn (wp) (nth wp 1)))
-(define wp-until (fn (wp) (nth wp 2)))
-
-(define
-  wp-active?
-  (fn
-    (wp at)
-    (let
-      ((from (wp-from wp)) (until (wp-until wp)))
-      (and (or (nil? from) (>= at from)) (or (nil? until) (<= at until))))))
-
-;; Plain promo tuples live at time `at` — feed into cart-quote / best-promo-*.
-(define
-  active-ruleset
-  (fn
-    (windowed at)
-    (map wp-promo (filter (fn (wp) (wp-active? wp at)) windowed))))
-
-;; Relation: which promo codes are active at `at`? (backward query)
-(define
-  active-promoo
-  (fn
-    (windowed at code)
-    (fresh
-      (wp)
-      (membero wp windowed)
-      (project
-        (wp)
-        (if (wp-active? wp at) (== code (promo-code (wp-promo wp))) fail)))))
-
-(define
-  active-codes
-  (fn (windowed at) (run* code (active-promoo windowed at code))))
-
-;; Datetime-aware quote: the existing pipeline over the time-active ruleset.
-(define
-  windowed-quote
-  (fn
-    (ctx cart windowed exclusions at)
-    (cart-quote ctx cart (active-ruleset windowed at) exclusions)))

lib/flow/README.md

@@ -1,141 +0,0 @@
-# flow — durable DAG workflows on Scheme
-
-`flow` is a workflow engine for rose-ash: content pipelines (write → review →
-publish → federate), scheduled jobs, and multi-step user flows (signup, confirm,
-onboard) that **survive process restarts**. It is a thin Scheme prelude over the
-Scheme-on-SX guest (`lib/scheme/`); a flow runs *inside* the interpreter.
-
-Run the suite: `bash lib/flow/conformance.sh` → **151/151 across 10 suites**.
-
-## Model
-
-A **flow** is just a Scheme procedure of one argument — the upstream value:
-
-```
-node : input -> output
-```
-
-Combinators build composite nodes out of child nodes. A node that ignores its
-argument is effectively a thunk. There is no separate "graph" object: composition
-*is* function composition, so flows are values you can name, pass, and nest.
-
-```scheme
-(defflow publish
-  (sequence
-    (lambda (draft) (string-append draft "!"))
-    (branch (lambda (post) (>= (string-length post) 3))
-            (remote-node 'fed 'publish)
-            (flow-const 'rejected))))
-
-(flow/start publish "hello")   ; => federated, or a (flow-suspended id tag) state
-```
-
-## Building blocks (`spec.sx`)
-
-| Combinator | Meaning |
-|---|---|
-| `(flow-node f)` / `(flow-id x)` / `(flow-const v)` | leaf nodes |
-| `(sequence n ...)` | thread input left-to-right |
-| `(parallel n ...)` | fan input to every child, join results into a list (sequential eval) |
-| `(map-flow node)` | run `node` over each item of a list input, join results |
-| `(flow-while pred body max)` / `(flow-until ...)` | bounded iteration (cap `max` steps) |
-| `(defflow name body)` | bind + register a named flow (so it survives restart) |
-
-## Control flow + errors (`spec.sx`)
-
-| Combinator | Meaning |
-|---|---|
-| `(branch pred then else)` | `pred` on input selects `then`/`else` (`cond` is a Scheme special form) |
-| `(retry n node)` | re-run on a *raised exception*, up to `n` attempts |
-| `(timeout budget node)` | cooperative **step budget**: nodes call `(tick)`; the `(budget+1)`-th tick raises `flow-timeout` |
-| `(try-catch node handler)` | catch a raised exception → `(handler error)` |
-| `(fail reason)` / `(failed? x)` / `(fail-reason x)` | explicit failure *values* (flow downstream as data) |
-| `(recover node handler)` | the fail-VALUE counterpart of try-catch |
-| `(attempt n ...)` | railway sequence: stop at the first node returning a `(fail ...)` |
-| `(tap effect)` | run a side effect, return input unchanged |
-
-**Two error channels, on purpose.** Raised exceptions are for *bugs/transients*
-(caught by `retry`/`try-catch`). `(fail reason)` values are for *expected business
-outcomes* (validation rejected, declined) and compose via `attempt`/`recover`.
-
-## Suspend / resume — the durable core (`spec.sx`, `store.sx`)
-
-The guest Scheme's `call/cc` is **escape-only** — re-invoking a captured
-continuation after it returns *hangs* the runtime. So flow does **not** serialize
-continuations. Instead it uses **deterministic replay**:
-
-- `(suspend tag)` — if `tag` is already in the replay log, return its logged value;
-  otherwise escape to the driver as `(flow-suspended tag)`.
-- `resume` appends `(tag value)` to the log and **re-runs the flow from the start**.
-  Already-resolved suspends replay their values; the first unresolved one escapes
-  again (or the flow completes).
-
-The entire persisted state is the replay log — plain data. No live continuation is
-ever stored, so flows survive process restarts and even moves between instances.
-
-> **Author contract:** suspend `tag`s must be unique and deterministic across
-> replays, and **all** non-determinism / side effects must go through suspend
-> points (so their results are logged) — otherwise they re-run on every replay.
-
-### Lifecycle (`store.sx`)
-
-```scheme
-(flow/start flow input)   ; raw result if it completes, else (flow-suspended id tag)
-(flow/resume id value)    ; inject value at the waiting tag, continue
-(flow/cancel id)          ; terminate; a later resume is rejected
-```
-
-### Introspection & hygiene
-
-```scheme
-(flow/status id)   ; done | suspended | cancelled | unknown
-(flow/result id)   ; result if done, else (flow-error reason)
-(flow/list)        ; ((id status) ...)
-(flow/pending)     ; ((id waiting-tag) ...) — what each suspended flow awaits
-(flow/gc)          ; drop terminal records, keep live ones; returns count removed
-(flow/forget id)   ; drop one terminal record (refuses live flows)
-```
-
-### Crash recovery
-
-```scheme
-(flow-store-export)      ; the store as plain data (live procs nulled)
-(flow-store-import! d)   ; restore the store from exported data
-(flow-resumable-ids)     ; ids of suspended flows to wake on restart
-```
-
-On restart the flow definitions are reloaded (`defflow` re-registers names) and the
-exported store reimported; `resume` re-resolves each flow's procedure **by name**.
-
-## Distribution via fed-sx (`remote.sx`)
-
-```scheme
-(flow-peer-register! addr table)      ; mock a peer's exposed functions (fed-sx boundary)
-(remote-node addr fn)                 ; run a node on a peer
-(remote-failover addrs fn local)      ; try peers in order, fall through to a local node
-(flow-replicate-to addr)              ; copy this store to a peer's replica slot
-(flow-restore-from addr)              ; import a peer's replica (handoff)
-```
-
-**Handoff** is crash recovery across instances: replicate → local instance dies →
-peer restores the (plain-data) store and resumes. The replay log carries over, so
-all resolved suspends survive the move.
-
-## Files
-
-| File | Contents |
-|---|---|
-| `spec.sx` | combinators (flow-combinators-src / flow-control-src / flow-suspend-src) |
-| `store.sx` | durable store, lifecycle, crash recovery, introspection, hygiene |
-| `remote.sx` | fed-sx transport (mock peer registry), failover, replication |
-| `api.sx` | `flow-make-env` / `flow-run` SX helpers (one cached env, per-test reset) |
-| `tests/*.sx` | 10 suites, 151 cases |
-| `conformance.sh` | loads substrate + flow layer, runs every suite |
-
-## Notes on the substrate
-
-The guest Scheme (`lib/scheme/`, imported read-only) lacks dotted-rest params
-`(a . rest)` and named `let`; combinators use `(lambda args ...)` variadics + top-
-level recursion. `cons` is list-only (no dotted pairs), so log/assoc entries are
-2-element lists. Strings box as `{:scm-string "..."}`. Timeout is a step budget
-because there is no wall clock; `parallel` is sequential for the same reason.

lib/flow/api.sx

@@ -1,65 +0,0 @@
-;; lib/flow/api.sx — flow runtime entry points.
-;;
-;; Builds a Scheme env preloaded with the flow combinators (lib/flow/spec.sx),
-;; the durable store + lifecycle (lib/flow/store.sx), the fed-sx remote layer
-;; (lib/flow/remote.sx), and the host integration ABI (lib/flow/host.sx), and
-;; provides SX helpers to run flow programs.
-;;
-;; Scheme-level API (available inside flow programs):
-;;   (flow/start flow input) — run a flow; raw result if it completes, else
-;;                             (flow-suspended id tag). Defined in store.sx.
-;;   (flow/resume id value)  — resume a suspended flow (store.sx)
-;;   (flow/cancel id)        — cancel a flow (store.sx)
-;;   (suspend tag)           — suspension point (spec.sx)
-;;   (request kind payload)  — host request envelope over suspend (host.sx)
-;;   (remote-node addr fn)   — node executed on a federation peer (remote.sx)
-;;
-;; SX-level helpers (for hosts and tests):
-;;   (flow-make-env)        — fresh standard env + combinators + store + remote + host
-;;   (flow-run src)         — eval a Scheme program string in a reset shared env
-;;   (flow-run-in env src)  — eval a Scheme program string in a given env
-;;
-;; flow-run reuses ONE env (building the full standard env is expensive) and
-;; resets the mutable flow globals before each program, so tests stay isolated
-;; without paying for a fresh standard env each time. flow-registry persists (it
-;; models reloaded flow definitions surviving a restart).
-
-(define
-  flow-make-env
-  (fn
-    ()
-    (let
-      ((env (scheme-standard-env)))
-      (flow-load-combinators! env)
-      (flow-load-store! env)
-      (flow-load-remote! env)
-      (flow-load-host! env)
-      env)))
-
-(define
-  flow-run-in
-  (fn (env src) (scheme-eval-program (scheme-parse-all src) env)))
-
-(define
-  flow-reset-src
-  "(set! flow-store (list)) (set! flow-next-id 0) (set! flow-replay-log (list)) (set! flow-suspend-k #f) (set! flow-timeout-budget -1) (set! flow-peers (list)) (set! flow-replicas (list))")
-
-(define flow-env-cache false)
-
-(define
-  flow-shared-env
-  (fn
-    ()
-    (begin
-      (if flow-env-cache nil (set! flow-env-cache (flow-make-env)))
-      flow-env-cache)))
-
-(define
-  flow-run
-  (fn
-    (src)
-    (let
-      ((env (flow-shared-env)))
-      (begin
-        (scheme-eval-program (scheme-parse-all flow-reset-src) env)
-        (scheme-eval-program (scheme-parse-all src) env)))))

lib/flow/conformance.sh

@@ -1,103 +0,0 @@
-#!/usr/bin/env bash
-# flow-on-sx conformance runner — runs all flow test suites in one sx_server process.
-#
-# Usage:
-#   bash lib/flow/conformance.sh        # run all suites
-#   bash lib/flow/conformance.sh -v     # verbose (list each suite)
-
-set -uo pipefail
-cd "$(git rev-parse --show-toplevel)"
-
-SX_SERVER="${SX_SERVER:-hosts/ocaml/_build/default/bin/sx_server.exe}"
-if [ ! -x "$SX_SERVER" ]; then
-  SX_SERVER="/root/rose-ash/hosts/ocaml/_build/default/bin/sx_server.exe"
-fi
-if [ ! -x "$SX_SERVER" ]; then
-  echo "ERROR: sx_server.exe not found." >&2
-  exit 1
-fi
-
-VERBOSE="${1:-}"
-
-# Suites: NAME RUNNER-FN PATH
-SUITES=(
-  "basic       flow-basic-tests-run!     lib/flow/tests/basic.sx"
-  "control     flow-ctl-tests-run!       lib/flow/tests/control.sx"
-  "suspend     flow-sus-tests-run!       lib/flow/tests/suspend.sx"
-  "recovery    flow-rec-tests-run!       lib/flow/tests/recovery.sx"
-  "distributed flow-dist-tests-run!      lib/flow/tests/distributed.sx"
-  "api         flow-api-tests-run!       lib/flow/tests/api.sx"
-  "combinators flow-cmb-tests-run!       lib/flow/tests/combinators.sx"
-  "railway     flow-rail-tests-run!      lib/flow/tests/railway.sx"
-  "integration flow-int-tests-run!       lib/flow/tests/integration.sx"
-  "hygiene     flow-hyg-tests-run!       lib/flow/tests/hygiene.sx"
-  "host        flow-hst-tests-run!       lib/flow/tests/host.sx"
-)
-
-TMPFILE=$(mktemp); trap "rm -f $TMPFILE" EXIT
-EPOCH=1
-
-emit_load () { echo "(epoch $EPOCH)"; echo "(load \"$1\")"; EPOCH=$((EPOCH+1)); }
-emit_eval () { echo "(epoch $EPOCH)"; echo "(eval \"$1\")"; EPOCH=$((EPOCH+1)); }
-
-{
-  emit_load "lib/guest/lex.sx"
-  emit_load "lib/guest/reflective/env.sx"
-  emit_load "lib/guest/reflective/quoting.sx"
-  emit_load "lib/scheme/parser.sx"
-  emit_load "lib/scheme/eval.sx"
-  emit_load "lib/scheme/runtime.sx"
-  emit_load "lib/flow/spec.sx"
-  emit_load "lib/flow/store.sx"
-  emit_load "lib/flow/remote.sx"
-  emit_load "lib/flow/host.sx"
-  emit_load "lib/flow/api.sx"
-  for SUITE in "${SUITES[@]}"; do
-    read -r _NAME _RUNNER FILE <<< "$SUITE"
-    emit_load "$FILE"
-    emit_eval "($_RUNNER)"
-  done
-} > "$TMPFILE"
-
-OUTPUT=$(timeout 540 "$SX_SERVER" < "$TMPFILE" 2>&1 || true)
-
-TOTAL_PASS=0
-TOTAL_FAIL=0
-FAILED_SUITES=()
-
-LAST_DICT_LINES=$(echo "$OUTPUT" | grep -E '^\{:' || true)
-
-I=0
-while read -r LINE; do
-  [ -z "$LINE" ] && continue
-  P=$(echo "$LINE" | grep -oE ':passed [0-9]+' | awk '{print $2}')
-  F=$(echo "$LINE" | grep -oE ':failed [0-9]+' | awk '{print $2}')
-  [ -z "$P" ] && P=0
-  [ -z "$F" ] && F=0
-  SUITE_INFO="${SUITES[$I]}"
-  SUITE_NAME=$(echo "$SUITE_INFO" | awk '{print $1}')
-  TOTAL_PASS=$((TOTAL_PASS + P))
-  TOTAL_FAIL=$((TOTAL_FAIL + F))
-  if [ "$F" -gt 0 ]; then
-    FAILED_SUITES+=("$SUITE_NAME: $P/$((P+F))")
-    printf 'X %-12s %d/%d\n' "$SUITE_NAME" "$P" "$((P+F))"
-    echo "$LINE" | grep -oE ':name "[^"]*"' | sed 's/:name /    fail: /'
-  elif [ "$VERBOSE" = "-v" ]; then
-    printf 'ok %-12s %d passed\n' "$SUITE_NAME" "$P"
-  fi
-  I=$((I+1))
-done <<< "$LAST_DICT_LINES"
-
-TOTAL=$((TOTAL_PASS + TOTAL_FAIL))
-if [ "$TOTAL" -eq 0 ]; then
-  echo "ERROR: no suite results parsed. Raw output:" >&2
-  echo "$OUTPUT" >&2
-  exit 1
-fi
-if [ $TOTAL_FAIL -eq 0 ]; then
-  echo "ok $TOTAL_PASS/$TOTAL flow-on-sx tests passed (${#SUITES[@]} suites)"
-else
-  echo "FAIL $TOTAL_PASS/$TOTAL passed, $TOTAL_FAIL failed:"
-  for S in "${FAILED_SUITES[@]}"; do echo "  $S"; done
-  exit 1
-fi

lib/flow/host.sx

@@ -1,42 +0,0 @@
-;; lib/flow/host.sx — the host integration ABI (Phase 8).
-;;
-;; `suspend` is flow's seam to the outside world, but a bare (suspend tag) is just a
-;; signal — every author would invent their own tag shape. This layer defines a
-;; stable request/response contract so a host (e.g. an art-dag driver, or a human
-;; review UI) can hook in WITHOUT reverse-engineering ad-hoc tags.
-;;
-;; A flow asks the host to do something and waits for the answer:
-;;   (request kind payload)  — suspend with a typed envelope (flow-request kind
-;;     payload); evaluates to the host's resume value.
-;;   (await-human prompt)    — request kind=human (a decision point)
-;;   (await-render recipe)   — request kind=render (e.g. an art-dag job)
-;;   (await-effect kind p)   — request of an arbitrary kind
-;;
-;; The host drives flows by polling its work queue and resuming:
-;;   (flow-host-requests)    — ((id kind payload) ...) for every SUSPENDED flow whose
-;;     waiting tag is a host request. The host dispatches by kind (render -> submit a
-;;     Celery job; human -> show UI), then calls (flow/resume id answer).
-;;   (request? tag) / (request-kind tag) / (request-payload tag) — parse one tag.
-;;
-;; Reference driver — the host only supplies `dispatch`, a (kind payload) -> answer:
-;;   (flow-drive-host dispatch)        — one tick: service every CURRENTLY pending
-;;     request (snapshot), resuming each with (dispatch kind payload); returns the
-;;     count serviced. Resumes may create new requests — serviced on the next tick.
-;;   (flow-run-host dispatch maxticks) — tick until quiescent (no pending requests)
-;;     or maxticks reached; returns total requests serviced. Bounded for determinism.
-;;
-;; Contract: the host owns IO and persistence. flow stays deterministic — a flow
-;; never performs IO itself, it only `request`s; the host performs the effect and
-;; feeds the result back via resume (which the replay log records, so the effect is
-;; not re-run on recovery). Persist with flow-store-export after each transition and
-;; flow-store-import! on boot.
-
-(define
-  flow-host-src
-  "(define (request kind payload) (suspend (list (quote flow-request) kind payload)))\n   (define (request? tag) (and (pair? tag) (eq? (car tag) (quote flow-request))))\n   (define (request-kind tag) (car (cdr tag)))\n   (define (request-payload tag) (car (cdr (cdr tag))))\n   (define (await-human prompt) (request (quote human) prompt))\n   (define (await-render recipe) (request (quote render) recipe))\n   (define (await-effect kind payload) (request kind payload))\n   (define (flow-host-req-step pend)\n     (if (null? pend)\n         (list)\n         (let ((id (car (car pend))) (tag (car (cdr (car pend)))))\n           (if (request? tag)\n               (cons (list id (request-kind tag) (request-payload tag))\n                     (flow-host-req-step (cdr pend)))\n               (flow-host-req-step (cdr pend))))))\n   (define (flow-host-requests) (flow-host-req-step (flow/pending)))\n   (define (flow-drive-host-step reqs dispatch)\n     (if (null? reqs)\n         0\n         (begin\n           (flow/resume (car (car reqs)) (dispatch (car (cdr (car reqs))) (car (cdr (cdr (car reqs))))))\n           (+ 1 (flow-drive-host-step (cdr reqs) dispatch)))))\n   (define (flow-drive-host dispatch) (flow-drive-host-step (flow-host-requests) dispatch))\n   (define (flow-run-host dispatch maxticks)\n     (if (<= maxticks 0)\n         0\n         (let ((n (flow-drive-host dispatch)))\n           (if (= n 0) 0 (+ n (flow-run-host dispatch (- maxticks 1)))))))")
-
-(define
-  flow-load-host!
-  (fn
-    (env)
-    (begin (scheme-eval-program (scheme-parse-all flow-host-src) env) env)))

lib/flow/remote.sx

@@ -1,34 +0,0 @@
-;; lib/flow/remote.sx — distributed nodes via fed-sx (Phase 4).
-;;
-;; A node can execute on a federation peer. The transport is the fed-sx boundary;
-;; it is MOCKED in tests by a peer registry mapping addr -> function table. In
-;; production flow-transport would issue a fed-sx call; here it dispatches locally.
-;;
-;;   (flow-peer-register! addr table) — register a mock peer. table is a list of
-;;     (fn-name proc) entries — the functions that peer exposes.
-;;   (flow-transport addr fn input)   — invoke fn on the peer with input. Raises
-;;     (flow-remote-unreachable) if the addr is unknown, (flow-remote-no-fn) if the
-;;     peer does not expose fn.
-;;   (remote-node addr fn)            — a node that runs fn on the peer at addr.
-;;   (remote-failover addrs fn local) — try fn on each peer in addrs in order; on a
-;;     raised error move to the next peer; if every peer fails, run the `local`
-;;     node as a fallback.
-;;
-;; Persistence across instances + handoff. Each instance runs the same flow
-;; definitions, so the only thing that needs to cross the wire is the (plain-data)
-;; store — exactly flow-store-export from store.sx. Replication pushes that export
-;; to a peer's replica slot; handoff = restore the replica on the peer and resume.
-;;
-;;   (flow-replicate-to addr) — copy this instance's store to peer addr's replica
-;;   (flow-restore-from addr) — import the replica from peer addr (#t / #f)
-;;   (flow-replica-get addr)  — the raw replicated store at addr (or #f)
-
-(define
-  flow-remote-src
-  "(define flow-peers (list))\n   (define (flow-assoc key alist)\n     (if (null? alist)\n         #f\n         (if (eq? (car (car alist)) key) (car (cdr (car alist))) (flow-assoc key (cdr alist)))))\n   (define (flow-peer-register! addr table) (set! flow-peers (cons (list addr table) flow-peers)))\n   (define (flow-transport addr fn input)\n     (let ((table (flow-assoc addr flow-peers)))\n       (if table\n           (let ((proc (flow-assoc fn table)))\n             (if proc (proc input) (raise (quote flow-remote-no-fn))))\n           (raise (quote flow-remote-unreachable)))))\n   (define (remote-node addr fn) (lambda (input) (flow-transport addr fn input)))\n   (define (flow-failover-step addrs fn input local)\n     (if (null? addrs)\n         (local input)\n         (guard (e (#t (flow-failover-step (cdr addrs) fn input local)))\n           (flow-transport (car addrs) fn input))))\n   (define (remote-failover addrs fn local)\n     (lambda (input) (flow-failover-step addrs fn input local)))\n\n   (define flow-replicas (list))\n   (define (flow-replicas-remove addr reps)\n     (if (null? reps)\n         (list)\n         (if (eq? (car (car reps)) addr)\n             (flow-replicas-remove addr (cdr reps))\n             (cons (car reps) (flow-replicas-remove addr (cdr reps))))))\n   (define (flow-replicate-to addr)\n     (set! flow-replicas (cons (list addr (flow-store-export)) (flow-replicas-remove addr flow-replicas))))\n   (define (flow-replica-get addr) (flow-assoc addr flow-replicas))\n   (define (flow-restore-from addr)\n     (let ((data (flow-replica-get addr)))\n       (if data (begin (flow-store-import! data) #t) #f)))")
-
-(define
-  flow-load-remote!
-  (fn
-    (env)
-    (begin (scheme-eval-program (scheme-parse-all flow-remote-src) env) env)))

lib/flow/scoreboard.json

@@ -1,19 +0,0 @@
-{
-  "total": 166,
-  "passed": 166,
-  "failed": 0,
-  "suites": {
-    "basic": { "passed": 18, "total": 18 },
-    "control": { "passed": 31, "total": 31 },
-    "suspend": { "passed": 17, "total": 17 },
-    "recovery": { "passed": 8, "total": 8 },
-    "distributed": { "passed": 19, "total": 19 },
-    "api": { "passed": 12, "total": 12 },
-    "combinators": { "passed": 17, "total": 17 },
-    "railway": { "passed": 10, "total": 10 },
-    "integration": { "passed": 10, "total": 10 },
-    "hygiene": { "passed": 9, "total": 9 },
-    "host": { "passed": 15, "total": 15 }
-  },
-  "phases": { "phase1": "done", "phase2": "done", "phase3": "done", "phase4": "done", "phase5": "done", "phase6": "done", "phase7": "done", "phase8": "done" }
-}

lib/flow/scoreboard.md

@@ -1,53 +0,0 @@
-# flow-on-sx Scoreboard
-
-**All tests pass: 166 / 166 across 11 suites. Phases 1-8 complete.**
-
-`bash lib/flow/conformance.sh`
-
-## Per-suite breakdown
-
-| Suite | Passing | Covers |
-|-------|--------:|--------|
-| basic |     18  | Phase 1: single nodes, linear sequence, data-flow threading, defflow, parallel fan/join, nested composition, publish-shaped flow |
-| control |  31  | Phase 2: `branch` (6); error model `fail`/`failed?`/`fail-reason` (6); `try-catch` (6); `retry n` (6); `timeout` cooperative step budget (7) |
-| suspend |  17  | Phase 3: suspend/resume/cancel via deterministic replay; multi-step, replay determinism, lifecycle guards, suspend-in-branch |
-| recovery |  8  | Phase 3: crash recovery — store export/import, resumable scan, restart-at-every-step, replay-log survival |
-| distributed | 19 | Phase 4: `remote-node` (7); `remote-failover` (6); replication + handoff across instances (6) |
-| api |  12  | Phase 5: introspection — `flow/status`, `flow/result`, `flow/list`, `flow/pending` |
-| combinators | 17 | Phase 5: `tap`, `recover` (fail-value), `map-flow` fan-over-list, `flow-while`/`flow-until` bounded iteration |
-| railway | 10 | Phase 6: `attempt` — fail-value short-circuiting sequence + recover rejoin |
-| integration | 10 | Phase 7: end-to-end order + onboarding flows composing every phase (suspend, branch, federation, crash recovery, handoff, introspection) |
-| hygiene | 9 | Phase 5: `flow/gc` (prune terminal flows), `flow/forget` (drop one terminal record) |
-| host | 15 | Phase 8: host ABI — `request`/`await-human`/`await-render`, `flow-host-requests` queue, `flow-run-host` reference driver; art-dag-shaped render→review→publish loop |
-
-## Architecture
-
-Flow combinators are a **Scheme prelude** (`lib/flow/spec.sx`) loaded onto
-`scheme-standard-env`. A flow is a Scheme procedure `input -> output`. The whole
-flow executes inside the Scheme interpreter, so Phase 3's `suspend` (call/cc) will
-capture the flow continuation directly.
-
-- `lib/flow/spec.sx` — combinators: `flow-node`, `flow-id`, `flow-const`,
-  `sequence`, `parallel`, `defflow`; `flow-load-combinators!`.
-- `lib/flow/api.sx` — `flow/start` (Scheme); `flow-make-env`, `flow-run`,
-  `flow-run-in` (SX helpers).
-- `lib/flow/tests/basic.sx` — 18 cases.
-- `lib/flow/conformance.sh` — loads substrate + flow layer, runs suites.
-
-## Semantics notes
-
-- **node** = 1-arg Scheme procedure; the upstream value is the argument. A node
-  ignoring its argument is effectively a thunk.
-- **sequence** threads left-to-right; empty sequence = identity.
-- **parallel** fans the same input to every branch and joins results into a list.
-  Evaluation is **sequential** for now; true concurrency arrives in Phase 3.
-
-## Phases
-
-- [x] Phase 1 — Declarative DAG + sequential execution (combinators + 18 tests, `flow/start`)
-- [x] Phase 2 — Control flow + error handling (branch, error model, try-catch, retry, timeout)
-- [x] Phase 3 — Suspend/resume (suspend/resume/cancel + crash recovery via deterministic replay)
-- [x] Phase 4 — Distributed nodes via fed-sx (remote-node, failover, replication + handoff)
-- [x] Phase 5 — Operational API + combinators (introspection, tap, recover, map-flow)
-- [ ] Phase 3 — Suspend / resume (the showcase)
-- [ ] Phase 4 — Distributed nodes via fed-sx

lib/flow/spec.sx

@@ -1,61 +0,0 @@
-;; lib/flow/spec.sx — flow combinators as a Scheme prelude.
-;;
-;; A flow is a Scheme procedure of one argument: the upstream value.
-;;   node : input -> output
-;; A leaf node ignoring its argument is effectively a thunk. Combinators
-;; build composite nodes out of child nodes. The whole flow runs INSIDE the
-;; Scheme interpreter.
-;;
-;; Phase 1 combinators (flow-combinators-src):
-;;   flow-node / flow-id / flow-const / sequence / parallel / defflow
-;;   defflow both binds the flow and registers it by name (flow-register!, in
-;;   store.sx) so it can be re-resolved after a process restart.
-;;   map-flow (Phase 5): run a node over each item of a list input, join results.
-;;   flow-while / flow-until (Phase 5): bounded iteration — re-run body, threading
-;;   the value, while/until pred holds, up to `max` steps (deterministic bound; no
-;;   unbounded loops in pure SX).
-;;
-;; Phase 2 combinators (flow-control-src):
-;;   branch / fail / failed? / fail-reason / try-catch / retry / timeout / tick
-;;   tap (Phase 5): side-effecting pass-through (returns input unchanged).
-;;   recover (Phase 5): the fail-VALUE counterpart of try-catch.
-;;   attempt (Phase 6): railway sequence — thread nodes left-to-right but stop at
-;;     the first node that returns a (fail ...) value, returning that failure.
-;;
-;; Phase 3 suspend core (flow-suspend-src):
-;;   The guest Scheme's call/cc is ESCAPE-ONLY (re-invoking a captured k after it
-;;   returns hangs the runtime), so suspend/resume CANNOT re-enter a continuation.
-;;   Instead, durability uses DETERMINISTIC REPLAY: a flow re-runs from the start
-;;   on each resume; suspend points that have already been resolved replay their
-;;   logged value, and the first unresolved suspend escapes back to the driver.
-;;   The entire persisted state is the replay log (plain (tag value) data), which
-;;   survives process restart — no live continuation is ever serialized.
-;;
-;;   (suspend tag)  — if tag is in the replay log, return its value; else escape
-;;     to the driver as (flow-suspended tag). tags must be unique & deterministic
-;;     across replays. ALL effects/non-determinism must go through suspend so their
-;;     results are logged (otherwise they re-run on every replay).
-;;   (flow-drive flow input log) — run flow with the given replay log; returns
-;;     (flow-done result) or (flow-suspended tag).
-
-(define
-  flow-combinators-src
-  "(define (flow-node f) f)\n   (define (flow-id input) input)\n   (define (flow-const v) (lambda (input) v))\n   (define (flow-seq-step ns v)\n     (if (null? ns) v (flow-seq-step (cdr ns) ((car ns) v))))\n   (define sequence (lambda ns (lambda (input) (flow-seq-step ns input))))\n   (define parallel (lambda ns (lambda (input) (map (lambda (n) (n input)) ns))))\n   (define (map-flow node) (lambda (items) (map node items)))\n   (define (flow-while-step pred body input n)\n     (if (<= n 0)\n         input\n         (if (pred input) (flow-while-step pred body (body input) (- n 1)) input)))\n   (define (flow-while pred body max) (lambda (input) (flow-while-step pred body input max)))\n   (define (flow-until-step pred body input n)\n     (if (<= n 0)\n         input\n         (if (pred input) input (flow-until-step pred body (body input) (- n 1)))))\n   (define (flow-until pred body max) (lambda (input) (flow-until-step pred body input max)))\n   (define-syntax defflow\n     (syntax-rules ()\n       ((defflow nm body)\n        (begin (define nm body) (flow-register! (quote nm) nm)))))")
-
-(define
-  flow-control-src
-  "(define (branch pred then else)\n     (lambda (input) (if (pred input) (then input) (else input))))\n   (define (fail reason) (list (quote flow-fail) reason))\n   (define (failed? x) (and (pair? x) (eq? (car x) (quote flow-fail))))\n   (define (fail-reason x) (car (cdr x)))\n   (define (recover node handler)\n     (lambda (input)\n       (let ((r (node input)))\n         (if (failed? r) (handler (fail-reason r)) r))))\n   (define (tap effect)\n     (lambda (input) (begin (effect input) input)))\n   (define (flow-attempt-step ns v)\n     (if (failed? v)\n         v\n         (if (null? ns) v (flow-attempt-step (cdr ns) ((car ns) v)))))\n   (define attempt (lambda ns (lambda (input) (flow-attempt-step ns input))))\n   (define (try-catch node handler)\n     (lambda (input) (guard (e (#t (handler e))) (node input))))\n   (define (flow-retry-step n node input)\n     (guard (e (#t (if (<= n 1) (raise e) (flow-retry-step (- n 1) node input))))\n       (node input)))\n   (define (retry n node) (lambda (input) (flow-retry-step n node input)))\n   (define flow-timeout-budget -1)\n   (define (tick)\n     (if (< flow-timeout-budget 0)\n         0\n         (begin\n           (set! flow-timeout-budget (- flow-timeout-budget 1))\n           (if (< flow-timeout-budget 0)\n               (raise (quote flow-timeout))\n               flow-timeout-budget))))\n   (define (timeout budget node)\n     (lambda (input)\n       (let ((saved flow-timeout-budget))\n         (set! flow-timeout-budget budget)\n         (guard (e (#t (begin (set! flow-timeout-budget saved) (raise e))))\n           (let ((result (node input)))\n             (set! flow-timeout-budget saved)\n             result)))))")
-
-(define
-  flow-suspend-src
-  "(define flow-replay-log (list))\n   (define flow-suspend-k #f)\n   (define (flow-log-lookup tag log)\n     (if (null? log)\n         (list #f #f)\n         (if (eq? (car (car log)) tag)\n             (list #t (car (cdr (car log))))\n             (flow-log-lookup tag (cdr log)))))\n   (define (suspend tag)\n     (let ((hit (flow-log-lookup tag flow-replay-log)))\n       (if (car hit)\n           (car (cdr hit))\n           (flow-suspend-k (list (quote flow-suspended) tag)))))\n   (define (flow-drive flow input log)\n     (set! flow-replay-log log)\n     (call/cc\n       (lambda (k)\n         (set! flow-suspend-k k)\n         (list (quote flow-done) (flow input)))))")
-
-(define
-  flow-load-combinators!
-  (fn
-    (env)
-    (begin
-      (scheme-eval-program (scheme-parse-all flow-combinators-src) env)
-      (scheme-eval-program (scheme-parse-all flow-control-src) env)
-      (scheme-eval-program (scheme-parse-all flow-suspend-src) env)
-      env)))

lib/flow/tests/api.sx

@@ -1,79 +0,0 @@
-;; lib/flow/tests/api.sx — Phase 5: operational introspection API.
-
-(define flow-api-pass 0)
-(define flow-api-fail 0)
-(define flow-api-fails (list))
-
-(define
-  flow-api-test
-  (fn
-    (name actual expected)
-    (if
-      (= actual expected)
-      (set! flow-api-pass (+ flow-api-pass 1))
-      (begin
-        (set! flow-api-fail (+ flow-api-fail 1))
-        (append! flow-api-fails {:name name :expected expected :actual actual})))))
-
-(define flow-a (fn (src) (flow-run src)))
-
-;; ── flow/status ─────────────────────────────────────────────────
-(flow-api-test "status: unknown id" (flow-a "(flow/status 999)") "unknown")
-(flow-api-test
-  "status: suspended flow"
-  (flow-a
-    "(defflow w (lambda (x) (suspend (quote q)))) (define id (car (cdr (flow/start w 0)))) (flow/status id)")
-  "suspended")
-(flow-api-test
-  "status: completed flow"
-  (flow-a
-    "(defflow w (sequence (lambda (x) (suspend (quote q))) (lambda (v) v))) (define id (car (cdr (flow/start w 0)))) (flow/resume id 5) (flow/status id)")
-  "done")
-(flow-api-test
-  "status: cancelled flow"
-  (flow-a
-    "(defflow w (lambda (x) (suspend (quote q)))) (define id (car (cdr (flow/start w 0)))) (flow/cancel id) (flow/status id)")
-  "cancelled")
-
-;; ── flow/result ─────────────────────────────────────────────────
-(flow-api-test
-  "result: returns the value of a completed flow"
-  (flow-a
-    "(defflow w (sequence (lambda (x) (suspend (quote q))) (lambda (v) (list (quote got) v)))) (define id (car (cdr (flow/start w 0)))) (flow/resume id 9) (flow/result id)")
-  (list "got" 9))
-(flow-api-test
-  "result: a still-suspended flow has no result"
-  (flow-a
-    "(defflow w (lambda (x) (suspend (quote q)))) (define id (car (cdr (flow/start w 0)))) (flow/result id)")
-  (list "flow-error" "not-done"))
-(flow-api-test
-  "result: unknown id errors"
-  (flow-a "(flow/result 999)")
-  (list "flow-error" "no-such-flow"))
-
-;; ── flow/list ───────────────────────────────────────────────────
-(flow-api-test "list: empty store" (flow-a "(flow/list)") (list))
-(flow-api-test
-  "list: reports id + status for each flow (newest first)"
-  (flow-a
-    "(defflow w (lambda (x) (suspend (quote q)))) (flow/start w 0) (flow/start (lambda (x) (* x 2)) 5) (flow/list)")
-  (list (list 2 "done") (list 1 "suspended")))
-
-;; ── flow/pending ────────────────────────────────────────────────
-(flow-api-test
-  "pending: lists suspended flows with their waiting tag"
-  (flow-a
-    "(defflow w (lambda (x) (suspend (quote review)))) (flow/start w 0) (flow/pending)")
-  (list (list 1 "review")))
-(flow-api-test
-  "pending: excludes completed and cancelled flows"
-  (flow-a
-    "(defflow w (lambda (x) (suspend (quote q)))) (defflow v (sequence (lambda (x) (suspend (quote r))) (lambda (y) y))) (define i1 (car (cdr (flow/start w 0)))) (define i2 (car (cdr (flow/start v 0)))) (define i3 (car (cdr (flow/start w 0)))) (flow/resume i2 1) (flow/cancel i3) (flow/pending)")
-  (list (list 1 "q")))
-(flow-api-test
-  "pending: operator can drain all pending flows"
-  (flow-a
-    "(defflow w (sequence (lambda (x) (suspend (quote q))) (lambda (v) (* v 10)))) (flow/start w 0) (flow/start w 0) (define ps (flow/pending)) (flow/resume (car (car ps)) 1) (flow/resume (car (car (cdr ps))) 2) (flow/list)")
-  (list (list 1 "done") (list 2 "done")))
-
-(define flow-api-tests-run! (fn () {:total (+ flow-api-pass flow-api-fail) :passed flow-api-pass :failed flow-api-fail :fails flow-api-fails}))

lib/flow/tests/basic.sx

@@ -1,121 +0,0 @@
-;; lib/flow/tests/basic.sx — Phase 1: declarative DAG + sequential execution.
-
-(define flow-basic-pass 0)
-(define flow-basic-fail 0)
-(define flow-basic-fails (list))
-
-(define
-  flow-basic-test
-  (fn
-    (name actual expected)
-    (if
-      (= actual expected)
-      (set! flow-basic-pass (+ flow-basic-pass 1))
-      (begin
-        (set! flow-basic-fail (+ flow-basic-fail 1))
-        (append! flow-basic-fails {:name name :expected expected :actual actual})))))
-
-;; Run a Scheme flow-program string and return its final value.
-(define flow-b (fn (src) (flow-run src)))
-
-;; Scheme strings are boxed as {:scm-string "..."}; unwrap to a host string.
-(define flow-bs (fn (src) (get (flow-run src) :scm-string)))
-
-;; ── single node ─────────────────────────────────────────────────
-(flow-basic-test
-  "node: identity passes input through"
-  (flow-b "(flow/start flow-id 7)")
-  7)
-(flow-basic-test
-  "node: const ignores input"
-  (flow-b "(flow/start (flow-const 99) 1)")
-  99)
-(flow-basic-test
-  "node: bare lambda is a node"
-  (flow-b "(flow/start (lambda (x) (* x x)) 6)")
-  36)
-
-;; ── linear sequence ─────────────────────────────────────────────
-(flow-basic-test
-  "sequence: empty is identity"
-  (flow-b "(flow/start (sequence) 42)")
-  42)
-(flow-basic-test
-  "sequence: single child"
-  (flow-b "(flow/start (sequence (lambda (x) (+ x 1))) 41)")
-  42)
-(flow-basic-test
-  "sequence: two children thread"
-  (flow-b
-    "(flow/start (sequence (lambda (x) (+ x 1)) (lambda (x) (* x 10))) 4)")
-  50)
-(flow-basic-test
-  "sequence: three children thread"
-  (flow-b
-    "(flow/start (sequence (lambda (x) (+ x 1)) (lambda (x) (* x 2)) (lambda (x) (- x 3))) 5)")
-  9)
-
-;; ── data flow between nodes ─────────────────────────────────────
-(flow-basic-test
-  "data flow: string accumulation"
-  (flow-bs
-    "(flow/start (sequence (lambda (s) (string-append s \"-a\")) (lambda (s) (string-append s \"-b\"))) \"x\")")
-  "x-a-b")
-(flow-basic-test
-  "data flow: list build"
-  (flow-b
-    "(flow/start (sequence (lambda (x) (cons x (list))) (lambda (xs) (cons 0 xs))) 7)")
-  (list 0 7))
-
-;; ── defflow ─────────────────────────────────────────────────────
-(flow-basic-test
-  "defflow: names a flow"
-  (flow-b
-    "(defflow inc2 (sequence (lambda (x) (+ x 1)) (lambda (x) (+ x 1)))) (flow/start inc2 40)")
-  42)
-(flow-basic-test
-  "defflow: reusable"
-  (flow-b
-    "(defflow dbl (lambda (x) (* x 2))) (+ (flow/start dbl 3) (flow/start dbl 10))")
-  26)
-
-;; ── parallel (sequential semantics, join into list) ─────────────
-(flow-basic-test
-  "parallel: fans input to all branches"
-  (flow-b
-    "(flow/start (parallel (lambda (x) (+ x 1)) (lambda (x) (* x 2)) (lambda (x) (- x 3))) 10)")
-  (list 11 20 7))
-(flow-basic-test
-  "parallel: empty joins to empty list"
-  (flow-b "(flow/start (parallel) 5)")
-  (list))
-(flow-basic-test
-  "parallel: single branch"
-  (flow-b "(flow/start (parallel (lambda (x) (* x x))) 9)")
-  (list 81))
-
-;; ── nested composition ──────────────────────────────────────────
-(flow-basic-test
-  "nested: sequence of sequences"
-  (flow-b
-    "(flow/start (sequence (sequence (lambda (x) (+ x 1)) (lambda (x) (+ x 1))) (sequence (lambda (x) (* x 3)))) 0)")
-  6)
-(flow-basic-test
-  "nested: parallel inside sequence, join then reduce"
-  (flow-b
-    "(flow/start (sequence (parallel (lambda (x) (+ x 1)) (lambda (x) (* x 2))) (lambda (xs) (apply + xs))) 10)")
-  31)
-(flow-basic-test
-  "nested: sequence inside parallel branch"
-  (flow-b
-    "(flow/start (parallel (sequence (lambda (x) (+ x 1)) (lambda (x) (* x 2))) (lambda (x) x)) 5)")
-  (list 12 5))
-
-;; ── publish-shaped flow (the architecture sketch) ───────────────
-(flow-basic-test
-  "publish: write -> (review | spell) -> join lengths"
-  (flow-b
-    "(defflow publish (sequence (lambda (draft) (string-append draft \"!\")) (parallel (lambda (c) (string-length c)) (lambda (c) (string-length (string-append c \"?\")))))) (flow/start publish \"hi\")")
-  (list 3 4))
-
-(define flow-basic-tests-run! (fn () {:total (+ flow-basic-pass flow-basic-fail) :passed flow-basic-pass :failed flow-basic-fail :fails flow-basic-fails}))

lib/flow/tests/combinators.sx

@@ -1,108 +0,0 @@
-;; lib/flow/tests/combinators.sx — Phase 5: combinator library (tap, recover, map-flow, iteration).
-
-(define flow-cmb-pass 0)
-(define flow-cmb-fail 0)
-(define flow-cmb-fails (list))
-
-(define
-  flow-cmb-test
-  (fn
-    (name actual expected)
-    (if
-      (= actual expected)
-      (set! flow-cmb-pass (+ flow-cmb-pass 1))
-      (begin
-        (set! flow-cmb-fail (+ flow-cmb-fail 1))
-        (append! flow-cmb-fails {:name name :expected expected :actual actual})))))
-
-(define flow-m (fn (src) (flow-run src)))
-
-;; ── tap (side-effecting pass-through) ───────────────────────────
-(flow-cmb-test
-  "tap: returns input unchanged"
-  (flow-m "(flow/start (tap (lambda (x) (* x 999))) 7)")
-  7)
-(flow-cmb-test
-  "tap: runs the side effect"
-  (flow-m
-    "(define seen 0) (flow/start (tap (lambda (x) (set! seen x))) 42) seen")
-  42)
-(flow-cmb-test
-  "tap: value flows on while the effect observes it"
-  (flow-m
-    "(define log 0) (flow/start (sequence (lambda (x) (+ x 1)) (tap (lambda (x) (set! log x))) (lambda (x) (* x 2))) 10) (list log (flow/result 1))")
-  (list 11 22))
-
-;; ── recover (fail-value counterpart of try-catch) ───────────────
-(flow-cmb-test
-  "recover: passes a non-fail value through"
-  (flow-m "(flow/start (recover (lambda (x) (* x 2)) (lambda (r) -1)) 5)")
-  10)
-(flow-cmb-test
-  "recover: handles a fail value via the reason"
-  (flow-m
-    "(flow/start (recover (lambda (x) (fail (quote too-small))) (lambda (r) (list (quote recovered) r))) 1)")
-  (list "recovered" "too-small"))
-(flow-cmb-test
-  "recover: handler can supply a default value"
-  (flow-m
-    "(flow/start (sequence (recover (lambda (x) (if (> x 0) x (fail (quote neg))) ) (flow-const 0)) (lambda (x) (* x 10))) -3)")
-  0)
-(flow-cmb-test
-  "recover: does not catch raised exceptions (those are try-catch's job)"
-  (flow-m
-    "(flow/start (try-catch (recover (lambda (x) (raise (quote boom))) (flow-const 0)) (lambda (e) e)) 1)")
-  "boom")
-
-;; ── map-flow (run a node over a list, join) ─────────────────────
-(flow-cmb-test
-  "map-flow: applies the node to each item"
-  (flow-m "(flow/start (map-flow (lambda (x) (* x x))) (list 1 2 3 4))")
-  (list 1 4 9 16))
-(flow-cmb-test
-  "map-flow: empty list joins to empty"
-  (flow-m "(flow/start (map-flow (lambda (x) (+ x 1))) (list))")
-  (list))
-(flow-cmb-test
-  "map-flow: each item runs an independent sub-flow"
-  (flow-m
-    "(flow/start (map-flow (sequence (lambda (x) (+ x 1)) (lambda (x) (* x 2)))) (list 0 4 9))")
-  (list 2 10 20))
-(flow-cmb-test
-  "map-flow: composes — fan over a list then reduce the join"
-  (flow-m
-    "(flow/start (sequence (map-flow (lambda (x) (* x 10))) (lambda (xs) (apply + xs))) (list 1 2 3))")
-  60)
-
-;; ── flow-while / flow-until (bounded iteration) ─────────────────
-(flow-cmb-test
-  "flow-while: iterates while the predicate holds"
-  (flow-m
-    "(flow/start (flow-while (lambda (x) (< x 10)) (lambda (x) (+ x 1)) 100) 0)")
-  10)
-(flow-cmb-test
-  "flow-while: a false predicate leaves input unchanged"
-  (flow-m
-    "(flow/start (flow-while (lambda (x) (< x 0)) (lambda (x) (+ x 1)) 100) 5)")
-  5)
-(flow-cmb-test
-  "flow-while: respects the max-iteration bound"
-  (flow-m "(flow/start (flow-while (lambda (x) #t) (lambda (x) (+ x 1)) 3) 0)")
-  3)
-(flow-cmb-test
-  "flow-while: doubles until past a threshold"
-  (flow-m
-    "(flow/start (flow-while (lambda (x) (< x 50)) (lambda (x) (* x 2)) 100) 3)")
-  96)
-(flow-cmb-test
-  "flow-until: iterates until the predicate becomes true"
-  (flow-m
-    "(flow/start (flow-until (lambda (x) (>= x 10)) (lambda (x) (+ x 3)) 100) 0)")
-  12)
-(flow-cmb-test
-  "flow-until: composes inside a sequence"
-  (flow-m
-    "(flow/start (sequence (flow-until (lambda (x) (> x 100)) (lambda (x) (* x 3)) 100) (lambda (x) (- x 100))) 5)")
-  35)
-
-(define flow-cmb-tests-run! (fn () {:total (+ flow-cmb-pass flow-cmb-fail) :passed flow-cmb-pass :failed flow-cmb-fail :fails flow-cmb-fails}))

lib/flow/tests/control.sx

@@ -1,179 +0,0 @@
-;; lib/flow/tests/control.sx — Phase 2: control flow + error handling.
-
-(define flow-ctl-pass 0)
-(define flow-ctl-fail 0)
-(define flow-ctl-fails (list))
-
-(define
-  flow-ctl-test
-  (fn
-    (name actual expected)
-    (if
-      (= actual expected)
-      (set! flow-ctl-pass (+ flow-ctl-pass 1))
-      (begin
-        (set! flow-ctl-fail (+ flow-ctl-fail 1))
-        (append! flow-ctl-fails {:name name :expected expected :actual actual})))))
-
-(define flow-c (fn (src) (flow-run src)))
-(define flow-cs (fn (src) (get (flow-run src) :scm-string)))
-
-;; ── branch ──────────────────────────────────────────────────────
-(flow-ctl-test
-  "branch: true selects then"
-  (flow-c
-    "(flow/start (branch (lambda (x) (> x 0)) (lambda (x) (* x 100)) (lambda (x) (- 0 x))) 5)")
-  500)
-(flow-ctl-test
-  "branch: false selects else"
-  (flow-c
-    "(flow/start (branch (lambda (x) (> x 0)) (lambda (x) (* x 100)) (lambda (x) (- 0 x))) -3)")
-  3)
-(flow-ctl-test
-  "branch: predicate sees the threaded input"
-  (flow-c
-    "(flow/start (sequence (lambda (x) (+ x 1)) (branch (lambda (x) (> x 3)) (flow-const 100) (flow-const 0))) 3)")
-  100)
-(flow-ctl-test
-  "branch: branches are full nodes (sequence inside)"
-  (flow-c
-    "(flow/start (branch (lambda (x) (< x 10)) (sequence (lambda (x) (+ x 1)) (lambda (x) (* x 2))) (flow-const 0)) 4)")
-  10)
-(flow-ctl-test
-  "branch: nested branch (3-way sign)"
-  (flow-c
-    "(defflow sign (branch (lambda (x) (> x 0)) (flow-const 1) (branch (lambda (x) (< x 0)) (flow-const -1) (flow-const 0)))) (list (flow/start sign 7) (flow/start sign -7) (flow/start sign 0))")
-  (list 1 -1 0))
-(flow-ctl-test
-  "branch: publish-shaped approval gate"
-  (flow-cs
-    "(defflow publish (branch (lambda (post) (>= (string-length post) 3)) (lambda (post) (string-append post \" [published]\")) (lambda (post) (string-append post \" [rejected]\")))) (flow/start publish \"ok\")")
-  "ok [rejected]")
-
-;; ── error model — explicit (fail reason) values ─────────────────
-(flow-ctl-test
-  "fail: failed? is true for a failure value"
-  (flow-c "(failed? (fail 404))")
-  true)
-(flow-ctl-test
-  "fail: fail-reason extracts the reason"
-  (flow-c "(fail-reason (fail 404))")
-  404)
-(flow-ctl-test
-  "fail: failed? is false for a plain value"
-  (flow-c "(failed? 7)")
-  false)
-(flow-ctl-test
-  "fail: failed? is false for an ordinary list"
-  (flow-c "(failed? (list 1 2 3))")
-  false)
-(flow-ctl-test
-  "fail: a node may emit a failure as data"
-  (flow-c
-    "(defflow validate (lambda (s) (if (>= (string-length s) 3) s (fail (quote too-short))))) (failed? (flow/start validate \"hi\"))")
-  true)
-(flow-ctl-test
-  "fail: failure flows downstream, branch recovers"
-  (flow-c
-    "(defflow guarded (sequence (lambda (s) (if (>= (string-length s) 3) (string-length s) (fail (quote too-short)))) (branch failed? (lambda (f) (list (quote recovered) (fail-reason f))) (lambda (n) (list (quote ok) n))))) (flow/start guarded \"hi\")")
-  (list "recovered" "too-short"))
-
-;; ── try-catch — reify raised exceptions ─────────────────────────
-(flow-ctl-test
-  "try-catch: no exception returns node result"
-  (flow-c "(flow/start (try-catch (lambda (x) (* x 2)) (lambda (e) -1)) 5)")
-  10)
-(flow-ctl-test
-  "try-catch: handler runs on raise"
-  (flow-c
-    "(flow/start (try-catch (lambda (x) (raise (quote boom))) (flow-const 99)) 1)")
-  99)
-(flow-ctl-test
-  "try-catch: handler receives the reified error"
-  (flow-c "(flow/start (try-catch (lambda (x) (raise 42)) (lambda (e) e)) 0)")
-  42)
-(flow-ctl-test
-  "try-catch: catches exception from deep inside a sequence"
-  (flow-c
-    "(flow/start (try-catch (sequence (lambda (x) (+ x 1)) (lambda (x) (raise (quote deep)))) (flow-const -99)) 5)")
-  -99)
-(flow-ctl-test
-  "try-catch: handler may convert to a failure value"
-  (flow-c
-    "(failed? (flow/start (try-catch (lambda (x) (raise (quote bad))) (lambda (e) (fail e))) 0))")
-  true)
-(flow-ctl-test
-  "try-catch: composes — recover then continue"
-  (flow-c
-    "(flow/start (sequence (try-catch (lambda (x) (raise (quote x))) (flow-const 10)) (lambda (n) (* n 5))) 0)")
-  50)
-
-;; ── retry — re-run on raised exceptions ─────────────────────────
-(flow-ctl-test
-  "retry: succeeds after transient failures"
-  (flow-c
-    "(define ctr 0) (defflow flaky (lambda (x) (set! ctr (+ ctr 1)) (if (< ctr 3) (raise (quote nope)) (* x 10)))) (list (flow/start (retry 5 flaky) 7) ctr)")
-  (list 70 3))
-(flow-ctl-test
-  "retry: exhausted re-raises (caught by try-catch)"
-  (flow-c
-    "(flow/start (try-catch (retry 2 (lambda (x) (raise (quote always)))) (flow-const (quote gaveup))) 0)")
-  "gaveup")
-(flow-ctl-test
-  "retry: n=1 means a single attempt"
-  (flow-c
-    "(define ctr 0) (flow/start (try-catch (retry 1 (lambda (x) (set! ctr (+ ctr 1)) (raise (quote bad)))) (lambda (e) ctr)) 0)")
-  1)
-(flow-ctl-test
-  "retry: success on first attempt does not re-run"
-  (flow-c
-    "(define ctr 0) (flow/start (sequence (retry 5 (lambda (x) (set! ctr (+ ctr 1)) (* x 2))) (lambda (n) ctr)) 21)")
-  1)
-(flow-ctl-test
-  "retry: does not retry explicit failure values"
-  (flow-c
-    "(define ctr 0) (failed? (flow/start (retry 5 (lambda (x) (set! ctr (+ ctr 1)) (fail (quote bad)))) 0))")
-  true)
-(flow-ctl-test
-  "retry: failure-value path runs node exactly once"
-  (flow-c
-    "(define ctr 0) (flow/start (sequence (retry 5 (lambda (x) (set! ctr (+ ctr 1)) (fail (quote bad)))) (lambda (f) ctr)) 0)")
-  1)
-
-;; ── timeout — cooperative step budget ───────────────────────────
-(flow-ctl-test
-  "timeout: work within budget completes"
-  (flow-c
-    "(define (cd n) (if (<= n 0) 99 (begin (tick) (cd (- n 1))))) (flow/start (try-catch (timeout 10 (lambda (x) (cd x))) (flow-const (quote timed-out))) 5)")
-  99)
-(flow-ctl-test
-  "timeout: work exceeding budget raises flow-timeout"
-  (flow-c
-    "(define (cd n) (if (<= n 0) 99 (begin (tick) (cd (- n 1))))) (flow/start (try-catch (timeout 10 (lambda (x) (cd x))) (flow-const (quote timed-out))) 20)")
-  "timed-out")
-(flow-ctl-test
-  "timeout: exact budget boundary completes"
-  (flow-c
-    "(define (cd n) (if (<= n 0) 99 (begin (tick) (cd (- n 1))))) (flow/start (try-catch (timeout 5 (lambda (x) (cd x))) (flow-const (quote timed-out))) 5)")
-  99)
-(flow-ctl-test
-  "timeout: one tick over the budget raises"
-  (flow-c
-    "(define (cd n) (if (<= n 0) 99 (begin (tick) (cd (- n 1))))) (flow/start (try-catch (timeout 5 (lambda (x) (cd x))) (flow-const (quote timed-out))) 6)")
-  "timed-out")
-(flow-ctl-test
-  "timeout: the raised error is identifiable"
-  (flow-c
-    "(define (cd n) (if (<= n 0) 99 (begin (tick) (cd (- n 1))))) (flow/start (try-catch (timeout 2 (lambda (x) (cd x))) (lambda (e) e)) 9)")
-  "flow-timeout")
-(flow-ctl-test
-  "timeout: a node that never ticks is unbounded"
-  (flow-c "(flow/start (timeout 0 (lambda (x) (* x 2))) 5)")
-  10)
-(flow-ctl-test
-  "timeout: budget is restored across sequential timeouts"
-  (flow-c
-    "(define (cd n) (if (<= n 0) 1 (begin (tick) (cd (- n 1))))) (flow/start (sequence (timeout 4 (lambda (x) (cd x))) (timeout 4 (lambda (x) (cd 3))) (lambda (x) (begin (tick) (+ x 100)))) 3)")
-  101)
-
-(define flow-ctl-tests-run! (fn () {:total (+ flow-ctl-pass flow-ctl-fail) :passed flow-ctl-pass :failed flow-ctl-fail :fails flow-ctl-fails}))

lib/flow/tests/distributed.sx

@@ -1,120 +0,0 @@
-;; lib/flow/tests/distributed.sx — Phase 4: distributed nodes via fed-sx (mocked).
-
-(define flow-dist-pass 0)
-(define flow-dist-fail 0)
-(define flow-dist-fails (list))
-
-(define
-  flow-dist-test
-  (fn
-    (name actual expected)
-    (if
-      (= actual expected)
-      (set! flow-dist-pass (+ flow-dist-pass 1))
-      (begin
-        (set! flow-dist-fail (+ flow-dist-fail 1))
-        (append! flow-dist-fails {:name name :expected expected :actual actual})))))
-
-(define flow-d (fn (src) (flow-run src)))
-
-;; ── remote-node ─────────────────────────────────────────────────
-(flow-dist-test
-  "remote: a node executes on a peer"
-  (flow-d
-    "(flow-peer-register! (quote edge) (list (list (quote double) (lambda (x) (* x 2))))) (flow/start (remote-node (quote edge) (quote double)) 21)")
-  42)
-(flow-dist-test
-  "remote: remote nodes compose in a sequence"
-  (flow-d
-    "(flow-peer-register! (quote edge) (list (list (quote inc) (lambda (x) (+ x 1))) (list (quote double) (lambda (x) (* x 2))))) (flow/start (sequence (remote-node (quote edge) (quote inc)) (remote-node (quote edge) (quote double))) 4)")
-  10)
-(flow-dist-test
-  "remote: a remote node mixes with local nodes"
-  (flow-d
-    "(flow-peer-register! (quote edge) (list (list (quote double) (lambda (x) (* x 2))))) (flow/start (sequence (lambda (x) (+ x 5)) (remote-node (quote edge) (quote double)) (lambda (x) (- x 1))) 10)")
-  29)
-(flow-dist-test
-  "remote: unreachable peer raises flow-remote-unreachable"
-  (flow-d
-    "(flow/start (try-catch (remote-node (quote ghost) (quote double)) (lambda (e) e)) 1)")
-  "flow-remote-unreachable")
-(flow-dist-test
-  "remote: unknown function on a peer raises flow-remote-no-fn"
-  (flow-d
-    "(flow-peer-register! (quote edge) (list (list (quote double) (lambda (x) (* x 2))))) (flow/start (try-catch (remote-node (quote edge) (quote missing)) (lambda (e) e)) 1)")
-  "flow-remote-no-fn")
-(flow-dist-test
-  "remote: a remote node can suspend the flow (peer returns control)"
-  (flow-d
-    "(flow-peer-register! (quote edge) (list (list (quote review) (lambda (x) x)))) (flow/start (sequence (remote-node (quote edge) (quote review)) (lambda (x) (suspend (quote human))) (lambda (v) (list (quote published) v))) 7)")
-  (list "flow-suspended" 1 "human"))
-(flow-dist-test
-  "remote: a transient remote failure is recoverable with retry"
-  (flow-d
-    "(define hits 0) (flow-peer-register! (quote edge) (list (list (quote flaky) (lambda (x) (begin (set! hits (+ hits 1)) (if (< hits 2) (raise (quote down)) (* x 3))))))) (list (flow/start (retry 3 (remote-node (quote edge) (quote flaky))) 7) hits)")
-  (list 21 2))
-
-;; ── failover (retry on a different peer, fall through to local) ──
-(flow-dist-test
-  "failover: first reachable peer serves the request"
-  (flow-d
-    "(flow-peer-register! (quote p2) (list (list (quote f) (lambda (x) (+ x 100))))) (flow/start (remote-failover (list (quote p2) (quote down)) (quote f) (flow-const (quote local))) 5)")
-  105)
-(flow-dist-test
-  "failover: skips an unreachable peer to the next one"
-  (flow-d
-    "(flow-peer-register! (quote p2) (list (list (quote f) (lambda (x) (+ x 100))))) (flow/start (remote-failover (list (quote down) (quote p2)) (quote f) (flow-const (quote local))) 5)")
-  105)
-(flow-dist-test
-  "failover: skips a peer whose function raises"
-  (flow-d
-    "(flow-peer-register! (quote bad) (list (list (quote f) (lambda (x) (raise (quote boom)))))) (flow-peer-register! (quote good) (list (list (quote f) (lambda (x) (* x 10))))) (flow/start (remote-failover (list (quote bad) (quote good)) (quote f) (flow-const 0)) 4)")
-  40)
-(flow-dist-test
-  "failover: all peers fail, the local fallback runs"
-  (flow-d
-    "(flow/start (remote-failover (list (quote down1) (quote down2)) (quote f) (lambda (x) (* x -1))) 9)")
-  -9)
-(flow-dist-test
-  "failover: threads the input through to the chosen peer"
-  (flow-d
-    "(flow-peer-register! (quote p) (list (list (quote f) (lambda (x) (list (quote got) x))))) (flow/start (sequence (lambda (x) (+ x 1)) (remote-failover (list (quote p)) (quote f) (flow-const 0))) 41)")
-  (list "got" 42))
-(flow-dist-test
-  "failover: composes inside a larger sequence"
-  (flow-d
-    "(flow-peer-register! (quote p) (list (list (quote f) (lambda (x) (* x 2))))) (flow/start (sequence (remote-failover (list (quote down) (quote p)) (quote f) (flow-const 1)) (lambda (x) (+ x 3))) 5)")
-  13)
-
-;; ── replication + handoff ───────────────────────────────────────
-(flow-dist-test
-  "replicate: a peer holds the exported store"
-  (flow-d
-    "(defflow w (lambda (x) (suspend (quote q)))) (flow/start w 10) (flow-replicate-to (quote peerB)) (if (flow-replica-get (quote peerB)) (quote replicated) (quote missing))")
-  "replicated")
-(flow-dist-test
-  "handoff: a peer resumes a flow after the local instance dies"
-  (flow-d
-    "(defflow w (sequence (lambda (x) (suspend (quote q))) (lambda (v) (list (quote done) v)))) (define id (car (cdr (flow/start w 10)))) (flow-replicate-to (quote peerB)) (set! flow-store (list)) (flow-restore-from (quote peerB)) (flow/resume id 55)")
-  (list "done" 55))
-(flow-dist-test
-  "handoff: restored peer reports the flow as resumable"
-  (flow-d
-    "(defflow w (lambda (x) (suspend (quote q)))) (define id (car (cdr (flow/start w 10)))) (flow-replicate-to (quote peerB)) (set! flow-store (list)) (flow-restore-from (quote peerB)) (flow-resumable-ids)")
-  (list 1))
-(flow-dist-test
-  "handoff: without restore the dead instance has lost the flow"
-  (flow-d
-    "(defflow w (lambda (x) (suspend (quote q)))) (define id (car (cdr (flow/start w 10)))) (flow-replicate-to (quote peerB)) (set! flow-store (list)) (flow/resume id 1)")
-  (list "flow-error" "no-such-flow"))
-(flow-dist-test
-  "restore: from an unknown peer yields false"
-  (flow-d "(flow-restore-from (quote nowhere))")
-  false)
-(flow-dist-test
-  "handoff: replication preserves the replay log across the move"
-  (flow-d
-    "(defflow two (sequence (lambda (x) (suspend (quote a))) (lambda (x) (suspend (quote b))) (lambda (x) (list x)))) (define id (car (cdr (flow/start two 0)))) (flow/resume id 11) (flow-replicate-to (quote peerB)) (set! flow-store (list)) (flow-restore-from (quote peerB)) (flow/resume id 22)")
-  (list 22))
-
-(define flow-dist-tests-run! (fn () {:total (+ flow-dist-pass flow-dist-fail) :passed flow-dist-pass :failed flow-dist-fail :fails flow-dist-fails}))

lib/flow/tests/host.sx

@@ -1,106 +0,0 @@
-;; lib/flow/tests/host.sx — Phase 8: host integration ABI (request/await/host-queue/driver).
-
-(define flow-hst-pass 0)
-(define flow-hst-fail 0)
-(define flow-hst-fails (list))
-
-(define
-  flow-hst-test
-  (fn
-    (name actual expected)
-    (if
-      (= actual expected)
-      (set! flow-hst-pass (+ flow-hst-pass 1))
-      (begin
-        (set! flow-hst-fail (+ flow-hst-fail 1))
-        (append! flow-hst-fails {:name name :expected expected :actual actual})))))
-
-(define flow-hst (fn (src) (flow-run src)))
-
-;; ── request envelope ────────────────────────────────────────────
-(flow-hst-test
-  "request: suspends with a typed envelope"
-  (flow-hst
-    "(car (cdr (cdr (flow/start (lambda (x) (request (quote render) x)) 5))))")
-  (list "flow-request" "render" 5))
-(flow-hst-test
-  "request?: recognizes an envelope"
-  (flow-hst "(request? (list (quote flow-request) (quote human) 1))")
-  true)
-(flow-hst-test
-  "request?: a plain tag is not a request"
-  (flow-hst "(request? (list (quote review) 1))")
-  false)
-(flow-hst-test
-  "request-kind / request-payload: parse the envelope"
-  (flow-hst
-    "(define t (list (quote flow-request) (quote render) (list (quote recipe) 7))) (list (request-kind t) (request-payload t))")
-  (list "render" (list "recipe" 7)))
-
-;; ── named decision points ───────────────────────────────────────
-(flow-hst-test
-  "await-human: is a request of kind human"
-  (flow-hst
-    "(car (cdr (cdr (flow/start (lambda (x) (await-human x)) (quote approve?)))))")
-  (list "flow-request" "human" "approve?"))
-(flow-hst-test
-  "await-render: is a request of kind render"
-  (flow-hst
-    "(car (cdr (cdr (flow/start (lambda (x) (await-render x)) (quote recipe)))))")
-  (list "flow-request" "render" "recipe"))
-(flow-hst-test
-  "request: the host's resume value flows back into the flow"
-  (flow-hst
-    "(defflow f (sequence (lambda (x) (await-render x)) (lambda (art) (list (quote got) art)))) (define id (car (cdr (flow/start f 1)))) (flow/resume id (quote the-artifact))")
-  (list "got" "the-artifact"))
-
-;; ── host work queue ─────────────────────────────────────────────
-(flow-hst-test
-  "flow-host-requests: lists (id kind payload) for pending requests"
-  (flow-hst
-    "(flow/start (lambda (x) (await-render x)) 99) (flow-host-requests)")
-  (list (list 1 "render" 99)))
-(flow-hst-test
-  "flow-host-requests: excludes bare (non-request) suspends"
-  (flow-hst
-    "(defflow a (lambda (x) (await-render x))) (defflow b (lambda (x) (suspend (quote plain)))) (flow/start a 1) (flow/start b 2) (flow-host-requests)")
-  (list (list 1 "render" 1)))
-
-;; ── the art-dag-shaped host driver loop (manual resumes) ────────
-(flow-hst-test
-  "host driver: render then human-review then publish"
-  (flow-hst
-    "(defflow pipeline (sequence (lambda (recipe) (await-render recipe)) (lambda (art) (await-human (list (quote review) art))) (branch (lambda (d) (eq? d (quote approve))) (flow-const (quote published)) (flow-const (fail (quote rejected)))))) (define id (car (cdr (flow/start pipeline 99)))) (define r1 (flow-host-requests)) (flow/resume id (list (quote art) 99)) (define r2 (flow-host-requests)) (flow/resume id (quote approve)) (list r1 r2 (flow/status id) (flow/result id))")
-  (list
-    (list (list 1 "render" 99))
-    (list (list 1 "human" (list "review" (list "art" 99))))
-    "done"
-    "published"))
-(flow-hst-test
-  "host driver: rejection at the human gate yields a failure"
-  (flow-hst
-    "(defflow pipeline (sequence (lambda (recipe) (await-render recipe)) (lambda (art) (await-human (list (quote review) art))) (branch (lambda (d) (eq? d (quote approve))) (flow-const (quote published)) (flow-const (fail (quote rejected)))))) (define id (car (cdr (flow/start pipeline 1)))) (flow/resume id (quote artifact)) (failed? (flow/resume id (quote reject)))")
-  true)
-
-;; ── reference driver: host supplies only a dispatch fn ──────────
-(flow-hst-test
-  "flow-drive-host: one tick services every pending request"
-  (flow-hst
-    "(flow/start (lambda (x) (await-render x)) 5) (define n (flow-drive-host (lambda (k p) (list (quote done) p)))) (list n (flow/status 1) (flow/result 1))")
-  (list 1 "done" (list "done" 5)))
-(flow-hst-test
-  "flow-run-host: drives a render -> human pipeline to completion"
-  (flow-hst
-    "(defflow pipeline (sequence (lambda (recipe) (await-render recipe)) (lambda (art) (await-human (list (quote review) art))) (branch (lambda (d) (eq? d (quote approve))) (flow-const (quote published)) (flow-const (fail (quote rejected)))))) (define id (car (cdr (flow/start pipeline 99)))) (define serviced (flow-run-host (lambda (kind payload) (if (eq? kind (quote render)) (list (quote art) payload) (quote approve))) 10)) (list serviced (flow/status id) (flow/result id))")
-  (list 2 "done" "published"))
-(flow-hst-test
-  "flow-run-host: returns 0 when nothing is pending"
-  (flow-hst "(flow-run-host (lambda (k p) p) 5)")
-  0)
-(flow-hst-test
-  "flow-run-host: respects the maxticks bound"
-  (flow-hst
-    "(defflow pipe2 (sequence (lambda (r) (await-render r)) (lambda (a) (await-human a)) (lambda (d) d))) (define id (car (cdr (flow/start pipe2 1)))) (define serviced (flow-run-host (lambda (k p) p) 1)) (list serviced (flow/status id))")
-  (list 1 "suspended"))
-
-(define flow-hst-tests-run! (fn () {:total (+ flow-hst-pass flow-hst-fail) :passed flow-hst-pass :failed flow-hst-fail :fails flow-hst-fails}))

lib/flow/tests/hygiene.sx

@@ -1,67 +0,0 @@
-;; lib/flow/tests/hygiene.sx — Phase 5: store hygiene (flow/gc, flow/forget).
-
-(define flow-hyg-pass 0)
-(define flow-hyg-fail 0)
-(define flow-hyg-fails (list))
-
-(define
-  flow-hyg-test
-  (fn
-    (name actual expected)
-    (if
-      (= actual expected)
-      (set! flow-hyg-pass (+ flow-hyg-pass 1))
-      (begin
-        (set! flow-hyg-fail (+ flow-hyg-fail 1))
-        (append! flow-hyg-fails {:name name :expected expected :actual actual})))))
-
-(define flow-h (fn (src) (flow-run src)))
-
-;; ── flow/gc ─────────────────────────────────────────────────────
-(flow-hyg-test
-  "gc: empty store removes nothing"
-  (flow-h "(flow/gc)")
-  0)
-(flow-hyg-test
-  "gc: removes a done flow, keeps a suspended one"
-  (flow-h
-    "(defflow w (lambda (x) (suspend (quote q)))) (flow/start w 0) (flow/start (lambda (x) x) 5) (define removed (flow/gc)) (list removed (flow/list))")
-  (list 1 (list (list 1 "suspended"))))
-(flow-hyg-test
-  "gc: removes a cancelled flow"
-  (flow-h
-    "(defflow w (lambda (x) (suspend (quote q)))) (define id (car (cdr (flow/start w 0)))) (flow/cancel id) (flow/gc)")
-  1)
-(flow-hyg-test
-  "gc: a kept suspended flow is still resumable"
-  (flow-h
-    "(defflow w (sequence (lambda (x) (suspend (quote q))) (lambda (v) (* v 2)))) (define id (car (cdr (flow/start w 0)))) (flow/start (lambda (x) x) 1) (flow/gc) (flow/resume id 21)")
-  42)
-(flow-hyg-test
-  "gc: counts every terminal flow it drops"
-  (flow-h
-    "(flow/start (lambda (x) x) 1) (flow/start (lambda (x) x) 2) (defflow w (lambda (x) (suspend (quote q)))) (flow/start w 0) (flow/gc)")
-  2)
-
-;; ── flow/forget ─────────────────────────────────────────────────
-(flow-hyg-test
-  "forget: drops a completed flow"
-  (flow-h
-    "(defflow w (sequence (lambda (x) (suspend (quote q))) (lambda (v) v))) (define id (car (cdr (flow/start w 0)))) (flow/resume id 7) (list (flow/forget id) (flow/status id))")
-  (list true "unknown"))
-(flow-hyg-test
-  "forget: refuses to drop a live (suspended) flow"
-  (flow-h
-    "(defflow w (lambda (x) (suspend (quote q)))) (define id (car (cdr (flow/start w 0)))) (list (flow/forget id) (flow/status id))")
-  (list false "suspended"))
-(flow-hyg-test
-  "forget: drops a cancelled flow"
-  (flow-h
-    "(defflow w (lambda (x) (suspend (quote q)))) (define id (car (cdr (flow/start w 0)))) (flow/cancel id) (list (flow/forget id) (flow/status id))")
-  (list true "unknown"))
-(flow-hyg-test
-  "forget: unknown id yields false"
-  (flow-h "(flow/forget 999)")
-  false)
-
-(define flow-hyg-tests-run! (fn () {:total (+ flow-hyg-pass flow-hyg-fail) :passed flow-hyg-pass :failed flow-hyg-fail :fails flow-hyg-fails}))

lib/flow/tests/integration.sx

@@ -1,115 +0,0 @@
-;; lib/flow/tests/integration.sx — Phase 7: end-to-end flows composing every phase.
-
-(define flow-int-pass 0)
-(define flow-int-fail 0)
-(define flow-int-fails (list))
-
-(define
-  flow-int-test
-  (fn
-    (name actual expected)
-    (if
-      (= actual expected)
-      (set! flow-int-pass (+ flow-int-pass 1))
-      (begin
-        (set! flow-int-fail (+ flow-int-fail 1))
-        (append! flow-int-fails {:name name :expected expected :actual actual})))))
-
-(define flow-i (fn (src) (flow-run src)))
-
-;; The order-processing flow, defined once per program via this prelude string:
-;;   validate amount (attempt: fail if <= 0)
-;;   -> suspend for payment confirmation (resume value = confirmed amount)
-;;   -> branch: confirmed>0 ? record on the ledger peer : declined failure
-(define
-  order-prelude
-  "(flow-peer-register! (quote ledger) (list (list (quote record) (lambda (amt) (list (quote recorded) amt)))))\n   (defflow order\n     (attempt\n       (lambda (amt) (if (> amt 0) amt (fail (quote invalid-amount))))\n       (lambda (amt) (suspend (quote await-payment)))\n       (branch (lambda (amt) (> amt 0))\n               (remote-node (quote ledger) (quote record))\n               (flow-const (fail (quote declined))))))")
-
-;; ── happy path through every phase ──────────────────────────────
-(flow-int-test
-  "order: validate -> suspend -> resume -> branch -> federate"
-  (flow-i
-    (str
-      order-prelude
-      "(define id (car (cdr (flow/start order 100)))) (flow/resume id 250)"))
-  (list "recorded" 250))
-(flow-int-test
-  "order: starting suspends awaiting payment"
-  (flow-i
-    (str
-      order-prelude
-      "(define s (flow/start order 100)) (list (car s) (car (cdr (cdr s))))"))
-  (list "flow-suspended" "await-payment"))
-(flow-int-test
-  "order: invalid amount fails up front and never suspends"
-  (flow-i
-    (str
-      order-prelude
-      "(define r (flow/start order -5)) (list (failed? r) (fail-reason r))"))
-  (list true "invalid-amount"))
-(flow-int-test
-  "order: a declined payment yields a failure value"
-  (flow-i
-    (str
-      order-prelude
-      "(define id (car (cdr (flow/start order 100)))) (failed? (flow/resume id 0))"))
-  true)
-
-;; ── crash recovery mid-flow ─────────────────────────────────────
-(flow-int-test
-  "order: survives a simulated crash between suspend and resume"
-  (flow-i
-    (str
-      order-prelude
-      "(define id (car (cdr (flow/start order 100)))) (define saved (flow-store-export)) (set! flow-store (list)) (flow-store-import! saved) (flow/resume id 250)"))
-  (list "recorded" 250))
-
-;; ── handoff to a peer mid-flow ──────────────────────────────────
-(flow-int-test
-  "order: hands off to a peer that resumes and completes"
-  (flow-i
-    (str
-      order-prelude
-      "(define id (car (cdr (flow/start order 100)))) (flow-replicate-to (quote nodeB)) (set! flow-store (list)) (flow-restore-from (quote nodeB)) (flow/resume id 250)"))
-  (list "recorded" 250))
-
-;; ── introspection during the flow's life ────────────────────────
-(flow-int-test
-  "order: pending shows what the flow awaits, then result after resume"
-  (flow-i
-    (str
-      order-prelude
-      "(define id (car (cdr (flow/start order 100)))) (define p (flow/pending)) (flow/resume id 250) (list p (flow/status id) (flow/result id))"))
-  (list
-    (list (list 1 "await-payment"))
-    "done"
-    (list "recorded" 250)))
-
-;; ── onboarding: two human steps + cancellation ──────────────────
-(define
-  onboard-prelude
-  "(defflow onboard\n     (sequence\n       (lambda (user) (+ user 1))\n       (lambda (x) (suspend (quote confirm-email)))\n       (lambda (x) (suspend (quote complete-profile)))\n       (lambda (x) (list (quote onboarded) x))))")
-
-(flow-int-test
-  "onboard: two suspends resume in order to completion"
-  (flow-i
-    (str
-      onboard-prelude
-      "(define id (car (cdr (flow/start onboard 0)))) (flow/resume id 7) (flow/resume id 9)"))
-  (list "onboarded" 9))
-(flow-int-test
-  "onboard: the second pending tag appears after the first resume"
-  (flow-i
-    (str
-      onboard-prelude
-      "(define id (car (cdr (flow/start onboard 0)))) (flow/resume id 7) (car (cdr (car (flow/pending))))"))
-  "complete-profile")
-(flow-int-test
-  "onboard: cancelling abandons the flow"
-  (flow-i
-    (str
-      onboard-prelude
-      "(define id (car (cdr (flow/start onboard 0)))) (flow/cancel id) (list (flow/status id) (car (flow/resume id 7)))"))
-  (list "cancelled" "flow-error"))
-
-(define flow-int-tests-run! (fn () {:total (+ flow-int-pass flow-int-fail) :passed flow-int-pass :failed flow-int-fail :fails flow-int-fails}))

lib/flow/tests/railway.sx

@@ -1,73 +0,0 @@
-;; lib/flow/tests/railway.sx — Phase 6: railway-oriented composition (attempt).
-
-(define flow-rail-pass 0)
-(define flow-rail-fail 0)
-(define flow-rail-fails (list))
-
-(define
-  flow-rail-test
-  (fn
-    (name actual expected)
-    (if
-      (= actual expected)
-      (set! flow-rail-pass (+ flow-rail-pass 1))
-      (begin
-        (set! flow-rail-fail (+ flow-rail-fail 1))
-        (append! flow-rail-fails {:name name :expected expected :actual actual})))))
-
-(define flow-r (fn (src) (flow-run src)))
-
-;; ── attempt — short-circuit on the first (fail ...) ─────────────
-(flow-rail-test
-  "attempt: threads like sequence when nothing fails"
-  (flow-r
-    "(flow/start (attempt (lambda (x) (+ x 1)) (lambda (x) (* x 10))) 4)")
-  50)
-(flow-rail-test
-  "attempt: empty is identity"
-  (flow-r "(flow/start (attempt) 7)")
-  7)
-(flow-rail-test
-  "attempt: returns the first failure"
-  (flow-r
-    "(failed? (flow/start (attempt (lambda (x) (fail (quote bad))) (lambda (x) (* x 10))) 4))")
-  true)
-(flow-rail-test
-  "attempt: the failure carries its reason"
-  (flow-r
-    "(fail-reason (flow/start (attempt (lambda (x) x) (lambda (x) (fail (quote rejected)))) 4))")
-  "rejected")
-(flow-rail-test
-  "attempt: nodes after a failure do not run"
-  (flow-r
-    "(define ran 0) (flow/start (attempt (lambda (x) (fail (quote stop))) (lambda (x) (begin (set! ran (+ ran 1)) x))) 0) ran")
-  0)
-(flow-rail-test
-  "attempt: a failed input short-circuits immediately"
-  (flow-r
-    "(define ran 0) (fail-reason (flow/start (attempt (lambda (x) (begin (set! ran (+ ran 1)) x))) (fail (quote pre))))")
-  "pre")
-(flow-rail-test
-  "attempt: middle failure halts the chain"
-  (flow-r
-    "(define ran 0) (flow/start (attempt (lambda (x) (+ x 1)) (lambda (x) (fail (quote mid))) (lambda (x) (begin (set! ran (+ ran 1)) x))) 5) ran")
-  0)
-
-;; ── attempt + recover (rejoin the happy track) ──────────────────
-(flow-rail-test
-  "attempt + recover: recover turns a failure into a value"
-  (flow-r
-    "(flow/start (recover (attempt (lambda (x) (if (> x 0) x (fail (quote non-positive)))) (lambda (x) (* x 2))) (flow-const 0)) -5)")
-  0)
-(flow-rail-test
-  "attempt + recover: happy path passes recover through"
-  (flow-r
-    "(flow/start (recover (attempt (lambda (x) (if (> x 0) x (fail (quote non-positive)))) (lambda (x) (* x 2))) (flow-const 0)) 5)")
-  10)
-(flow-rail-test
-  "attempt: validation pipeline reports the failing stage"
-  (flow-r
-    "(defflow validate (attempt (lambda (s) (if (>= (string-length s) 3) s (fail (quote too-short)))) (lambda (s) (if (<= (string-length s) 8) s (fail (quote too-long)))) (lambda (s) (list (quote ok) (string-length s))))) (list (fail-reason (flow/start validate \"hi\")) (flow/start validate \"hello\"))")
-  (list "too-short" (list "ok" 5)))
-
-(define flow-rail-tests-run! (fn () {:total (+ flow-rail-pass flow-rail-fail) :passed flow-rail-pass :failed flow-rail-fail :fails flow-rail-fails}))

lib/flow/tests/recovery.sx

@@ -1,71 +0,0 @@
-;; lib/flow/tests/recovery.sx — Phase 3: crash recovery (store export/import + restart).
-;;
-;; "restart" is simulated within one program: (set! flow-store (list)) wipes the
-;; in-memory store (process death), while flow-registry persists as it would after
-;; reloading flow definitions. Recovery = import the exported (plain-data) store and
-;; resume; the flow proc is re-resolved by name.
-
-(define flow-rec-pass 0)
-(define flow-rec-fail 0)
-(define flow-rec-fails (list))
-
-(define
-  flow-rec-test
-  (fn
-    (name actual expected)
-    (if
-      (= actual expected)
-      (set! flow-rec-pass (+ flow-rec-pass 1))
-      (begin
-        (set! flow-rec-fail (+ flow-rec-fail 1))
-        (append! flow-rec-fails {:name name :expected expected :actual actual})))))
-
-(define flow-r (fn (src) (flow-run src)))
-
-;; ── export / wipe / import ──────────────────────────────────────
-(flow-rec-test
-  "export nulls the live procedure"
-  (flow-r
-    "(defflow w (lambda (x) (suspend (quote await)))) (flow/start w 10) (car (cdr (car (cdr (car (flow-store-export))))))")
-  false)
-(flow-rec-test
-  "a wiped store loses the flow (process death)"
-  (flow-r
-    "(defflow w (lambda (x) (suspend (quote await)))) (define id (car (cdr (flow/start w 10)))) (set! flow-store (list)) (flow/resume id 1)")
-  (list "flow-error" "no-such-flow"))
-(flow-rec-test
-  "import restores a wiped store and resume completes"
-  (flow-r
-    "(defflow w (sequence (lambda (x) (suspend (quote await))) (lambda (c) (list (quote done) c)))) (define id (car (cdr (flow/start w 10)))) (define saved (flow-store-export)) (set! flow-store (list)) (flow-store-import! saved) (flow/resume id 777)")
-  (list "done" 777))
-
-;; ── resumable scan ──────────────────────────────────────────────
-(flow-rec-test
-  "resumable-ids lists the suspended flow after import"
-  (flow-r
-    "(defflow w (lambda (x) (suspend (quote await)))) (define id (car (cdr (flow/start w 10)))) (define saved (flow-store-export)) (set! flow-store (list)) (flow-store-import! saved) (flow-resumable-ids)")
-  (list 1))
-(flow-rec-test
-  "resumable-ids excludes completed flows"
-  (flow-r
-    "(defflow w (sequence (lambda (x) (suspend (quote await))) (lambda (c) c))) (define id (car (cdr (flow/start w 10)))) (flow/resume id 5) (flow-resumable-ids)")
-  (list))
-(flow-rec-test
-  "resumable-ids excludes cancelled flows after import"
-  (flow-r
-    "(defflow w (lambda (x) (suspend (quote await)))) (define id (car (cdr (flow/start w 10)))) (flow/cancel id) (define saved (flow-store-export)) (set! flow-store (list)) (flow-store-import! saved) (flow-resumable-ids)")
-  (list))
-
-;; ── restart at every step ───────────────────────────────────────
-(flow-rec-test
-  "two suspends survive a restart between each step"
-  (flow-r
-    "(defflow two (sequence (lambda (x) (suspend (quote a))) (lambda (x) (suspend (quote b))) (lambda (x) (list (quote end) x)))) (define id (car (cdr (flow/start two 0)))) (define s1 (flow-store-export)) (set! flow-store (list)) (flow-store-import! s1) (flow/resume id 100) (define s2 (flow-store-export)) (set! flow-store (list)) (flow-store-import! s2) (flow/resume id 200)")
-  (list "end" 200))
-(flow-rec-test
-  "import preserves the replay log (earlier value survives restart)"
-  (flow-r
-    "(defflow two (sequence (lambda (x) (suspend (quote a))) (lambda (x) (suspend (quote b))) (lambda (x) (list x)))) (define id (car (cdr (flow/start two 0)))) (flow/resume id 11) (define saved (flow-store-export)) (set! flow-store (list)) (flow-store-import! saved) (flow/resume id 22)")
-  (list 22))
-
-(define flow-rec-tests-run! (fn () {:total (+ flow-rec-pass flow-rec-fail) :passed flow-rec-pass :failed flow-rec-fail :fails flow-rec-fails}))

lib/flow/tests/suspend.sx

@@ -1,114 +0,0 @@
-;; lib/flow/tests/suspend.sx — Phase 3: suspend / resume / cancel (deterministic replay).
-
-(define flow-sus-pass 0)
-(define flow-sus-fail 0)
-(define flow-sus-fails (list))
-
-(define
-  flow-sus-test
-  (fn
-    (name actual expected)
-    (if
-      (= actual expected)
-      (set! flow-sus-pass (+ flow-sus-pass 1))
-      (begin
-        (set! flow-sus-fail (+ flow-sus-fail 1))
-        (append! flow-sus-fails {:name name :expected expected :actual actual})))))
-
-(define flow-s (fn (src) (flow-run src)))
-
-;; ── flow/start ──────────────────────────────────────────────────
-(flow-sus-test
-  "start: non-suspending flow returns the raw result"
-  (flow-s "(flow/start (lambda (x) (* x 2)) 5)")
-  10)
-(flow-sus-test
-  "start: a suspending flow returns a flow-suspended state"
-  (flow-s
-    "(defflow w (sequence (lambda (x) (+ x 1)) (lambda (g) (suspend (quote await))) (lambda (c) c))) (car (flow/start w 10))")
-  "flow-suspended")
-(flow-sus-test
-  "start: suspended state carries a numeric id"
-  (flow-s
-    "(defflow w (lambda (x) (suspend (quote await)))) (car (cdr (flow/start w 10)))")
-  1)
-(flow-sus-test
-  "start: suspended state carries the suspend tag"
-  (flow-s
-    "(defflow w (lambda (x) (suspend (quote await)))) (car (cdr (cdr (flow/start w 10))))")
-  "await")
-
-;; ── flow/resume ─────────────────────────────────────────────────
-(flow-sus-test
-  "resume: injects the value and completes"
-  (flow-s
-    "(defflow w (sequence (lambda (x) (+ x 1)) (lambda (g) (suspend (quote await))) (lambda (c) (list (quote done) c)))) (define s (flow/start w 10)) (flow/resume (car (cdr s)) 777)")
-  (list "done" 777))
-(flow-sus-test
-  "resume: injected value threads into the next node"
-  (flow-s
-    "(defflow w (sequence (lambda (x) (suspend (quote v))) (lambda (n) (* n 3)))) (define s (flow/start w 0)) (flow/resume (car (cdr s)) 14)")
-  42)
-(flow-sus-test
-  "resume: replays earlier suspends (recompute is deterministic)"
-  (flow-s
-    "(define runs 0) (defflow w (sequence (lambda (x) (begin (set! runs (+ runs 1)) (+ x 1))) (lambda (g) (suspend (quote await))) (lambda (c) c))) (define s (flow/start w 10)) (flow/resume (car (cdr s)) 99) runs")
-  2)
-
-;; ── multi-step suspension ───────────────────────────────────────
-(flow-sus-test
-  "multi: first resume suspends at the next tag"
-  (flow-s
-    "(defflow two (sequence (lambda (x) (suspend (quote a))) (lambda (x) (suspend (quote b))) (lambda (x) (list (quote end) x)))) (define s (flow/start two 0)) (define s2 (flow/resume (car (cdr s)) 100)) (car (cdr (cdr s2)))")
-  "b")
-(flow-sus-test
-  "multi: second resume completes with the latest value"
-  (flow-s
-    "(defflow two (sequence (lambda (x) (suspend (quote a))) (lambda (x) (suspend (quote b))) (lambda (x) (list (quote end) x)))) (define id (car (cdr (flow/start two 0)))) (flow/resume id 100) (flow/resume id 200)")
-  (list "end" 200))
-
-;; ── error / lifecycle guards ────────────────────────────────────
-(flow-sus-test
-  "resume: completed flow cannot be resumed again"
-  (flow-s
-    "(defflow w (lambda (x) (suspend (quote q)))) (define id (car (cdr (flow/start w 0)))) (flow/resume id 1) (flow/resume id 2)")
-  (list "flow-error" "not-suspended"))
-(flow-sus-test
-  "resume: unknown id errors"
-  (flow-s "(flow/resume 999 1)")
-  (list "flow-error" "no-such-flow"))
-
-;; ── flow/cancel ─────────────────────────────────────────────────
-(flow-sus-test
-  "cancel: returns a flow-cancelled state"
-  (flow-s
-    "(defflow w (lambda (x) (suspend (quote q)))) (define id (car (cdr (flow/start w 0)))) (flow/cancel id)")
-  (list "flow-cancelled" 1))
-(flow-sus-test
-  "cancel: a cancelled flow cannot be resumed (stale resume rejected)"
-  (flow-s
-    "(defflow w (lambda (x) (suspend (quote q)))) (define id (car (cdr (flow/start w 0)))) (flow/cancel id) (flow/resume id 5)")
-  (list "flow-error" "not-suspended"))
-(flow-sus-test
-  "cancel: unknown id errors"
-  (flow-s "(flow/cancel 999)")
-  (list "flow-error" "no-such-flow"))
-
-;; ── composition ─────────────────────────────────────────────────
-(flow-sus-test
-  "suspend inside a branch arm"
-  (flow-s
-    "(defflow gate (branch (lambda (x) (> x 0)) (lambda (x) (suspend (quote approve))) (flow-const (quote rejected)))) (define s (flow/start gate 5)) (flow/resume (car (cdr s)) (quote approved))")
-  "approved")
-(flow-sus-test
-  "two independent runs get independent ids"
-  (flow-s
-    "(defflow w (lambda (x) (suspend (quote q)))) (list (car (cdr (flow/start w 0))) (car (cdr (flow/start w 0))))")
-  (list 1 2))
-(flow-sus-test
-  "suspend reason may be a structured value"
-  (flow-s
-    "(defflow w (lambda (x) (suspend (list (quote needs) (quote approval))))) (car (cdr (cdr (flow/start w 0))))")
-  (list "needs" "approval"))
-
-(define flow-sus-tests-run! (fn () {:total (+ flow-sus-pass flow-sus-fail) :passed flow-sus-pass :failed flow-sus-fail :fails flow-sus-fails}))

lib/mod/activity.sx

@@ -1,40 +0,0 @@
-;; lib/mod/activity.sx — export decisions as ActivityPub-shaped events.
-;;
-;; The rose-ash platform propagates cross-domain effects as ActivityPub-shaped
-;; activities. A moderation decision maps to a moderation verb so the rest of the
-;; platform (and federated peers) can act on it: remove→Delete, ban→Block,
-;; hide/escalate→Flag, keep→no activity. The precise mod action is preserved in
-;; :action so a consumer can disambiguate (e.g. hide vs escalate, both Flag).
-
-(define
-  mod/action->verb
-  (fn
-    (action)
-    (cond
-      ((= action "remove") "Delete")
-      ((= action "ban") "Block")
-      ((= action "hide") "Flag")
-      ((= action "escalate") "Flag")
-      (true nil))))
-
-(define
-  mod/decision->activity
-  (fn
-    (d actor)
-    (let
-      ((verb (mod/action->verb (get d :action))))
-      (if (nil? verb) nil {:type verb :action (get d :action) :actor actor :summary (str "moderation/" (get d :action) " via " (get d :rule)) :object (get d :report-id) :rule (get d :rule)}))))
-
-;; map a batch of decisions to activities, dropping the no-op keeps
-(define
-  mod/decisions->activities
-  (fn
-    (decisions actor)
-    (reduce
-      (fn
-        (acc d)
-        (let
-          ((a (mod/decision->activity d actor)))
-          (if (nil? a) acc (append acc (list a)))))
-      (list)
-      decisions)))

lib/mod/api.sx

@@ -1,163 +0,0 @@
-;; lib/mod/api.sx — report registry + lifecycle façade + public entry points.
-;;
-;; mod/report files a report (assigning a sequential id) and opens a lifecycle
-;; case for it; mod/add-evidence accumulates evidence; mod/decide runs the engine
-;; and commits to the audit log. The lifecycle façade (mod/triage, mod/resolve,
-;; mod/review, mod/appeal, mod/finalize) drives the per-report case through its
-;; states, logging each committed decision to the audit trail.
-
-(define mod/*reports* (list))
-(define mod/*cases* (list))
-(define mod/*counter* 0)
-(define mod/*rules* mod/default-rules)
-
-(define
-  mod/reset!
-  (fn
-    ()
-    (begin
-      (set! mod/*reports* (list))
-      (set! mod/*cases* (list))
-      (set! mod/*counter* 0)
-      (mod/audit-reset!))))
-
-(define
-  mod/report
-  (fn
-    (by about reason)
-    (begin
-      (set! mod/*counter* (+ mod/*counter* 1))
-      (let
-        ((id (str "r" mod/*counter*)))
-        (let
-          ((r (mod/mk-report id by about reason)))
-          (begin
-            (append! mod/*reports* r)
-            (append! mod/*cases* {:id id :case (mod/mk-case r)})
-            r))))))
-
-(define
-  mod/get-report
-  (fn
-    (id)
-    (reduce
-      (fn (acc r) (if (= (mod/report-id r) id) r acc))
-      nil
-      mod/*reports*)))
-
-(define
-  mod/add-evidence
-  (fn
-    (id kind val)
-    (let
-      ((r (mod/get-report id)))
-      (if
-        (nil? r)
-        nil
-        (let
-          ((updated (mod/attach-evidence r (mod/mk-evidence kind val))))
-          (begin
-            (set!
-              mod/*reports*
-              (map
-                (fn (x) (if (= (mod/report-id x) id) updated x))
-                mod/*reports*))
-            updated))))))
-
-(define
-  mod/decide
-  (fn
-    (id)
-    (let
-      ((r (mod/get-report id)))
-      (if
-        (nil? r)
-        nil
-        (let
-          ((d (mod/decide-report r mod/*reports* mod/*rules*)))
-          (begin (mod/log-decision! d (mod/report-evidence r)) d))))))
-
-;; ── lifecycle façade over the case registry ──
-
-(define
-  mod/case-of
-  (fn
-    (id)
-    (reduce
-      (fn (acc rec) (if (= (get rec :id) id) (get rec :case) acc))
-      nil
-      mod/*cases*)))
-
-(define
-  mod/case-store!
-  (fn
-    (id c)
-    (set!
-      mod/*cases*
-      (map
-        (fn (rec) (if (= (get rec :id) id) {:id id :case c} rec))
-        mod/*cases*))))
-
-;; apply a lifecycle op to the stored case, persist it, and (when a decision was
-;; committed cleanly) append it to the audit log; returns the updated case
-(define
-  mod/case-apply!
-  (fn
-    (id op log?)
-    (let
-      ((c (mod/case-of id)))
-      (if
-        (nil? c)
-        nil
-        (let
-          ((c2 (op c)))
-          (begin
-            (mod/case-store! id c2)
-            (when
-              log?
-              (when
-                (nil? (mod/case-error c2))
-                (let
-                  ((d (mod/case-decision c2)))
-                  (if
-                    (nil? d)
-                    nil
-                    (mod/log-decision!
-                      d
-                      (mod/report-evidence (mod/case-report c2)))))))
-            c2))))))
-
-(define
-  mod/triage
-  (fn
-    (id)
-    (mod/case-apply!
-      id
-      (fn (c) (mod/case-triage c mod/*reports* mod/*rules*))
-      false)))
-
-(define
-  mod/resolve
-  (fn (id) (mod/case-apply! id (fn (c) (mod/case-resolve c)) true)))
-
-(define
-  mod/review
-  (fn
-    (id kind val)
-    (mod/case-apply!
-      id
-      (fn (c) (mod/case-review c kind val mod/*reports* mod/*rules*))
-      true)))
-
-(define
-  mod/appeal
-  (fn
-    (id kind val)
-    (mod/case-apply!
-      id
-      (fn (c) (mod/case-appeal c kind val mod/*reports* mod/*rules*))
-      true)))
-
-(define
-  mod/finalize
-  (fn (id) (mod/case-apply! id (fn (c) (mod/case-finalize c)) false)))

lib/mod/audit.sx

@@ -1,54 +0,0 @@
-;; lib/mod/audit.sx — append-only decision log.
-;;
-;; Every decision the api commits is recorded as an immutable audit entry holding
-;; the decision (action + matching rule), the proof tree (the derivation that
-;; justified it), and a snapshot of the evidence in force at decision time. The
-;; log is append-only: entries are never mutated or removed, only appended, each
-;; with a monotonic sequence number. Retrieval is by report id (full history) or
-;; by sequence.
-
-(define mod/*audit-log* (list))
-(define mod/*audit-seq* 0)
-
-(define
-  mod/audit-reset!
-  (fn
-    ()
-    (begin (set! mod/*audit-log* (list)) (set! mod/*audit-seq* 0))))
-
-(define mod/mk-audit-entry (fn (seq decision evidence-snapshot) {:action (get decision :action) :evidence evidence-snapshot :proof (get decision :proof) :rule (get decision :rule) :report-id (get decision :report-id) :seq seq}))
-
-(define
-  mod/log-decision!
-  (fn
-    (decision evidence-snapshot)
-    (begin
-      (set! mod/*audit-seq* (+ mod/*audit-seq* 1))
-      (let
-        ((entry (mod/mk-audit-entry mod/*audit-seq* decision evidence-snapshot)))
-        (begin (append! mod/*audit-log* entry) entry)))))
-
-;; entries for one report, in chronological (sequence) order
-(define
-  mod/audit
-  (fn
-    (id)
-    (reduce
-      (fn
-        (acc e)
-        (if (= (get e :report-id) id) (append acc (list e)) acc))
-      (list)
-      mod/*audit-log*)))
-
-(define mod/audit-all (fn () mod/*audit-log*))
-(define mod/audit-count (fn () (len mod/*audit-log*)))
-
-;; most recent decision logged for a report (nil if none)
-(define
-  mod/audit-latest
-  (fn
-    (id)
-    (reduce
-      (fn (acc e) (if (= (get e :report-id) id) e acc))
-      nil
-      mod/*audit-log*)))

lib/mod/batch.sx

@@ -1,55 +0,0 @@
-;; lib/mod/batch.sx — batch triage + corpus analytics.
-;;
-;; Operational layer: decide a whole queue of reports at once, summarize the
-;; outcomes by action, and measure which rules actually fire across a corpus.
-;; mod/never-fired is the empirical complement to lint's static unreachable check
-;; (Ext 5): lint finds rules that CAN'T fire by structure; never-fired finds rules
-;; that DIDN'T fire on real data.
-
-(define
-  mod/decide-batch
-  (fn
-    (reports rules)
-    (map (fn (r) (mod/decide-report r reports rules)) reports)))
-
-(define
-  mod/count-action
-  (fn
-    (decisions action)
-    (reduce
-      (fn (acc d) (if (= (get d :action) action) (+ acc 1) acc))
-      0
-      decisions)))
-
-(define mod/action-histogram (fn (decisions) {:keep (mod/count-action decisions "keep") :remove (mod/count-action decisions "remove") :escalate (mod/count-action decisions "escalate") :hide (mod/count-action decisions "hide") :ban (mod/count-action decisions "ban")}))
-
-(define
-  mod/rule-fire-count
-  (fn
-    (decisions rule-name)
-    (reduce
-      (fn (acc d) (if (= (get d :rule) rule-name) (+ acc 1) acc))
-      0
-      decisions)))
-
-(define
-  mod/rule-coverage
-  (fn
-    (reports rules)
-    (let
-      ((decisions (mod/decide-batch reports rules)))
-      (map (fn (rule) {:rule (mod/rule-name rule) :fired (mod/rule-fire-count decisions (mod/rule-name rule))}) rules))))
-
-(define
-  mod/never-fired
-  (fn
-    (reports rules)
-    (reduce
-      (fn
-        (acc c)
-        (if
-          (= (get c :fired) 0)
-          (append acc (list (get c :rule)))
-          acc))
-      (list)
-      (mod/rule-coverage reports rules))))

lib/mod/conformance.conf

@@ -1,60 +0,0 @@
-# Mod conformance config — sourced by lib/guest/conformance.sh.
-
-LANG_NAME=mod
-MODE=dict
-
-PRELOADS=(
-  lib/guest/pratt.sx
-  lib/prolog/tokenizer.sx
-  lib/prolog/parser.sx
-  lib/prolog/runtime.sx
-  lib/prolog/query.sx
-  lib/prolog/compiler.sx
-  lib/mod/schema.sx
-  lib/mod/policy.sx
-  lib/mod/defrule.sx
-  lib/mod/engine.sx
-  lib/mod/explain.sx
-  lib/mod/severity.sx
-  lib/mod/offenders.sx
-  lib/mod/quorum.sx
-  lib/mod/trace.sx
-  lib/mod/whatif.sx
-  lib/mod/batch.sx
-  lib/mod/temporal.sx
-  lib/mod/sla.sx
-  lib/mod/wire.sx
-  lib/mod/activity.sx
-  lib/mod/policies.sx
-  lib/mod/pipeline.sx
-  lib/mod/lifecycle.sx
-  lib/mod/audit.sx
-  lib/mod/api.sx
-  lib/mod/fed.sx
-  lib/mod/link.sx
-  lib/mod/lint.sx
-)
-
-SUITES=(
-  "decide:lib/mod/tests/decide.sx:(mod-decide-tests-run!)"
-  "audit:lib/mod/tests/audit.sx:(mod-audit-tests-run!)"
-  "escalation:lib/mod/tests/escalation.sx:(mod-escalation-tests-run!)"
-  "fed:lib/mod/tests/fed.sx:(mod-fed-tests-run!)"
-  "extensions:lib/mod/tests/extensions.sx:(mod-extensions-tests-run!)"
-  "link:lib/mod/tests/link.sx:(mod-link-tests-run!)"
-  "lint:lib/mod/tests/lint.sx:(mod-lint-tests-run!)"
-  "severity:lib/mod/tests/severity.sx:(mod-severity-tests-run!)"
-  "offenders:lib/mod/tests/offenders.sx:(mod-offenders-tests-run!)"
-  "quorum:lib/mod/tests/quorum.sx:(mod-quorum-tests-run!)"
-  "trace:lib/mod/tests/trace.sx:(mod-trace-tests-run!)"
-  "whatif:lib/mod/tests/whatif.sx:(mod-whatif-tests-run!)"
-  "batch:lib/mod/tests/batch.sx:(mod-batch-tests-run!)"
-  "temporal:lib/mod/tests/temporal.sx:(mod-temporal-tests-run!)"
-  "sla:lib/mod/tests/sla.sx:(mod-sla-tests-run!)"
-  "wire:lib/mod/tests/wire.sx:(mod-wire-tests-run!)"
-  "disjunction:lib/mod/tests/disjunction.sx:(mod-disjunction-tests-run!)"
-  "activity:lib/mod/tests/activity.sx:(mod-activity-tests-run!)"
-  "policies:lib/mod/tests/policies.sx:(mod-policies-tests-run!)"
-  "defrule:lib/mod/tests/defrule.sx:(mod-defrule-tests-run!)"
-  "pipeline:lib/mod/tests/pipeline.sx:(mod-pipeline-tests-run!)"
-)

lib/mod/conformance.sh

@@ -1,3 +0,0 @@
-#!/usr/bin/env bash
-# Thin wrapper — see lib/guest/conformance.sh and lib/mod/conformance.conf.
-exec bash "$(dirname "$0")/../guest/conformance.sh" "$(dirname "$0")/conformance.conf" "$@"

lib/mod/defrule.sx

@@ -1,16 +0,0 @@
-;; lib/mod/defrule.sx — ergonomic rule / ruleset construction.
-;;
-;; The roadmap sketched a (defrule action :when conditions) surface. Conditions
-;; already evaluate to plain data, so this needs no macro — variadic functions
-;; suffice: mod/defrule collects its trailing condition forms via &rest (dropping
-;; the explicit outer (list ...)), and mod/ruleset assembles rules the same way.
-;;
-;;   (mod/ruleset
-;;     (mod/defrule "spam-hide" :hide (list :classification "spam"))
-;;     (mod/defrule "default-keep" :keep))
-
-(define
-  mod/defrule
-  (fn (name action &rest conds) (mod/mk-rule name action conds)))
-
-(define mod/ruleset (fn (&rest rules) rules))

lib/mod/engine.sx

@@ -1,64 +0,0 @@
-;; lib/mod/engine.sx — decide a report by querying the policy program.
-;;
-;; build-program assembles the report's facts plus the compiled policy clauses;
-;; decide-report runs the Prolog query and returns a decision. A decision is a
-;; proof, not a bare keyword: it carries the matching rule, the conditions it
-;; required, the evidence that satisfied them, and a derivation — the proof tree.
-;;
-;; The proof tree is built constructively: for the matching rule, each body goal
-;; is re-queried against the same DB with the report id bound, recording the goal
-;; text, whether it was solved, and the bindings that satisfied it. That is a
-;; genuine derivation drawn from the Prolog database, ready for the audit trail.
-
-(define
-  mod/find-rule
-  (fn
-    (rules name)
-    (reduce
-      (fn
-        (acc r)
-        (if (nil? acc) (if (= (mod/rule-name r) name) r acc) acc))
-      nil
-      rules)))
-
-(define
-  mod/build-program
-  (fn
-    (r count rules)
-    (str (mod/report-facts r count) "\n" (mod/rules->program rules))))
-
-(define
-  mod/proof-goals
-  (fn
-    (db id conds)
-    (if
-      (empty? conds)
-      (list {:solved true :goal "true" :bindings {}})
-      (map
-        (fn
-          (c)
-          (let
-            ((g (mod/cond->goal c id)))
-            (let ((sols (pl-query-all db g))) {:solved (if (empty? sols) false true) :goal g :bindings (if (empty? sols) {} (first sols))})))
-        conds))))
-
-(define
-  mod/decide-report
-  (fn
-    (r reports rules)
-    (let
-      ((count (mod/report-count (mod/report-about r) reports))
-        (kinds (mod/classify-keywords r))
-        (id (mod/report-id r)))
-      (let
-        ((program (mod/build-program r count rules)))
-        (let
-          ((db (pl-load program)))
-          (let
-            ((sol (pl-query-one db (str "policy_action(" id ", Action, Rule)"))))
-            (if
-              (nil? sol)
-              {:action "keep" :proof {:goals (list) :evidence kinds :conditions (list) :rule "none" :count count} :report-id id :rule "none"}
-              (let
-                ((rname (dict-get sol "Rule")))
-                (let ((rule (mod/find-rule rules rname))) {:action (mod/rule-action rule) :proof {:goals (mod/proof-goals db id (mod/rule-when rule)) :evidence kinds :conditions (mod/rule-when rule) :rule rname :count count} :report-id id :rule rname})))))))))

lib/mod/explain.sx

@@ -1,55 +0,0 @@
-;; lib/mod/explain.sx — human-readable proof explanation.
-;;
-;; Turns a decision (from mod/decide-report, or any audit entry) into a readable
-;; multi-line "why": the action, the rule that fired, the evidence in play, and
-;; the derivation goal-by-goal with [proved]/[unproved] marks and the unification
-;; bindings that satisfied each goal. Pure SX over the Phase-2 proof tree.
-
-(define
-  mod/explain-binds
-  (fn
-    (binds)
-    (mod/join-with
-      ", "
-      (map (fn (k) (str k "=" (dict-get binds k))) (keys binds)))))
-
-(define
-  mod/explain-goal
-  (fn
-    (g)
-    (let
-      ((mark (if (get g :solved) "  [proved] " "  [unproved] "))
-        (binds (get g :bindings)))
-      (if
-        (empty? (keys binds))
-        (str mark (get g :goal))
-        (str mark (get g :goal) "  {" (mod/explain-binds binds) "}")))))
-
-(define
-  mod/explain-evidence
-  (fn
-    (evidence)
-    (if
-      (empty? evidence)
-      "Evidence: (none)"
-      (str "Evidence: " (mod/join-with ", " evidence)))))
-
-(define
-  mod/explain
-  (fn
-    (decision)
-    (let
-      ((id (get decision :report-id))
-        (action (get decision :action))
-        (rule (get decision :rule))
-        (proof (get decision :proof)))
-      (let
-        ((goals (get proof :goals)) (evidence (get proof :evidence)))
-        (mod/join-with
-          "\n"
-          (append
-            (list
-              (str "Report " id ": " action " (rule: " rule ")")
-              (mod/explain-evidence evidence)
-              "Because:")
-            (map mod/explain-goal goals)))))))

lib/mod/fed.sx

@@ -1,145 +0,0 @@
-;; lib/mod/fed.sx — federation: cross-instance reports, decision sharing, trust,
-;; revocation. fed-sx itself is mocked here (an in-memory outbox); the real wire
-;; transport would replace mod/fed-send!.
-;;
-;; Trust is advisory by default (the hard rule): a peer's decision only binds
-;; locally when (mod/trusted? peer :mod) holds. An untrusted peer's decision is
-;; recorded as a suggestion in the advisory log and is NOT applied. Local
-;; decisions propagate outward via the outbox. Revocation undoes a locally
-;; applied action when its proof is invalidated, notifying the origin peer.
-
-(define mod/*fed-trust* (list))     ;; {:peer :scope}
-(define mod/*fed-outbox* (list))    ;; {:to :type :payload}
-(define mod/*fed-advisory* (list))  ;; {:peer :decision} — received, not applied
-(define mod/*fed-applied* (list))   ;; {:report-id :action :origin :revoked}
-(define mod/*fed-origins* (list))   ;; {:id :origin}
-
-(define
-  mod/fed-reset!
-  (fn
-    ()
-    (begin
-      (set! mod/*fed-trust* (list))
-      (set! mod/*fed-outbox* (list))
-      (set! mod/*fed-advisory* (list))
-      (set! mod/*fed-applied* (list))
-      (set! mod/*fed-origins* (list)))))
-
-;; ── trust model ──
-
-(define
-  mod/trust-match?
-  (fn
-    (t peer scope)
-    (if (= (get t :peer) peer) (= (get t :scope) scope) false)))
-
-(define
-  mod/grant-trust
-  (fn (peer scope) (begin (append! mod/*fed-trust* {:scope scope :peer peer}) true)))
-
-(define
-  mod/revoke-trust
-  (fn
-    (peer scope)
-    (set!
-      mod/*fed-trust*
-      (reduce
-        (fn
-          (acc t)
-          (if (mod/trust-match? t peer scope) acc (append acc (list t))))
-        (list)
-        mod/*fed-trust*))))
-
-(define
-  mod/trusted?
-  (fn
-    (peer scope)
-    (mod/any? (fn (t) (mod/trust-match? t peer scope)) mod/*fed-trust*)))
-
-;; ── cross-instance reports ──
-
-(define
-  mod/fed-receive-report
-  (fn
-    (peer by about reason)
-    (let
-      ((r (mod/report by about reason)))
-      (begin (append! mod/*fed-origins* {:id (mod/report-id r) :origin peer}) r))))
-
-(define
-  mod/report-origin
-  (fn
-    (id)
-    (reduce
-      (fn (acc o) (if (= (get o :id) id) (get o :origin) acc))
-      "local"
-      mod/*fed-origins*)))
-
-;; ── decision sharing (mock fed-sx send) ──
-
-(define
-  mod/fed-send!
-  (fn (to type payload) (begin (append! mod/*fed-outbox* {:type type :to to :payload payload}) true)))
-
-(define mod/fed-outbox (fn () mod/*fed-outbox*))
-
-(define
-  mod/fed-share-decision
-  (fn
-    (decision peers)
-    (reduce
-      (fn
-        (acc p)
-        (begin (mod/fed-send! p "decision" decision) (append acc (list p))))
-      (list)
-      peers)))
-
-;; ── receiving a peer's decision (advisory unless trusted) ──
-
-(define
-  mod/fed-applied-action
-  (fn
-    (report-id)
-    (reduce
-      (fn (acc a) (if (= (get a :report-id) report-id) a acc))
-      nil
-      mod/*fed-applied*)))
-
-(define
-  mod/fed-receive-decision
-  (fn
-    (peer decision)
-    (if
-      (mod/trusted? peer :mod)
-      (begin (append! mod/*fed-applied* {:revoked false :action (get decision :action) :report-id (get decision :report-id) :origin peer}) {:advisory false :peer peer :applied true :decision decision})
-      (begin (append! mod/*fed-advisory* {:peer peer :decision decision}) {:advisory true :peer peer :applied false :decision decision}))))
-
-;; ── revocation ──
-
-(define
-  mod/fed-revoke!
-  (fn
-    (report-id reason)
-    (begin
-      (set!
-        mod/*fed-applied*
-        (map
-          (fn (a) (if (= (get a :report-id) report-id) {:revoked true :action (get a :action) :report-id (get a :report-id) :origin (get a :origin)} a))
-          mod/*fed-applied*))
-      (mod/fed-send! (mod/report-origin report-id) "revocation" {:report-id report-id :reason reason})
-      report-id)))
-
-;; re-run the engine; if the action no longer holds, the prior decision's proof
-;; is invalidated — revoke the applied moderation.
-(define
-  mod/fed-revoke-if-invalidated
-  (fn
-    (report decision reports rules)
-    (let
-      ((d2 (mod/decide-report report reports rules)))
-      (if
-        (= (get d2 :action) (get decision :action))
-        {:revoked false :decision d2}
-        (begin
-          (mod/fed-revoke! (get decision :report-id) "proof invalidated")
-          {:revoked true :decision d2})))))

lib/mod/lifecycle.sx

@@ -1,160 +0,0 @@
-;; lib/mod/lifecycle.sx — report lifecycle state machine (pure SX over the engine).
-;;
-;; Lifecycle state is deliberately separate from policy: the Prolog rules answer
-;; "what action?", this module answers "where in the process is this report?".
-;;
-;;   :open ──triage──▶ :triaged ──resolve/review──▶ :decided ──appeal──▶ :appealed
-;;                                                      │                    │
-;;                                                      └────finalize───▶ :final ◀┘
-;;
-;; A case is an immutable value {:report :state :decision :tier :error :history}.
-;; Every transition returns a NEW case; illegal transitions return the case
-;; unchanged with :error set. Tiers: triage runs the engine (auto-tier); a
-;; terminal action (hide/remove/keep) resolves immediately, an :escalate action
-;; flags the case for human review (human-tier) before it can be resolved.
-
-(define mod/case* (fn (report state decision tier err history) {:history history :state state :report report :error err :tier tier :decision decision}))
-
-(define
-  mod/mk-case
-  (fn (report) (mod/case* report "open" nil nil nil (list))))
-
-(define mod/case-report (fn (c) (get c :report)))
-(define mod/case-state (fn (c) (get c :state)))
-(define mod/case-decision (fn (c) (get c :decision)))
-(define mod/case-tier (fn (c) (get c :tier)))
-(define mod/case-error (fn (c) (get c :error)))
-(define mod/case-history (fn (c) (get c :history)))
-
-;; ── transition table ──
-
-(define mod/lc-transitions {:final (list) :appealed (list "final") :decided (list "appealed" "final") :open (list "triaged") :triaged (list "decided")})
-
-(define mod/member? (fn (x lst) (mod/any? (fn (y) (= y x)) lst)))
-
-(define
-  mod/lc-can-transition?
-  (fn
-    (from to)
-    (let
-      ((outs (get mod/lc-transitions from)))
-      (if (nil? outs) false (mod/member? to outs)))))
-
-;; ── core transition: validate, record history, or flag :error ──
-
-(define
-  mod/case-goto
-  (fn
-    (c to note report decision tier)
-    (let
-      ((from (mod/case-state c)))
-      (if
-        (mod/lc-can-transition? from to)
-        (mod/case*
-          report
-          to
-          decision
-          tier
-          nil
-          (append (mod/case-history c) (list {:note note :to to :from from})))
-        (mod/case*
-          (mod/case-report c)
-          from
-          (mod/case-decision c)
-          (mod/case-tier c)
-          (str "illegal transition: " from " -> " to)
-          (mod/case-history c))))))
-
-(define
-  mod/case-error-set
-  (fn
-    (c msg)
-    (mod/case*
-      (mod/case-report c)
-      (mod/case-state c)
-      (mod/case-decision c)
-      (mod/case-tier c)
-      msg
-      (mod/case-history c))))
-
-;; ── lifecycle operations ──
-
-;; :open → :triaged — run the auto-tier first pass.
-(define
-  mod/case-triage
-  (fn
-    (c reports rules)
-    (let
-      ((d (mod/decide-report (mod/case-report c) reports rules)))
-      (let
-        ((tier (if (= (get d :action) "escalate") "human" "auto")))
-        (mod/case-goto
-          c
-          "triaged"
-          "auto-tier first pass"
-          (mod/case-report c)
-          d
-          tier)))))
-
-;; :triaged → :decided — auto-tier resolves; human-tier is blocked until review.
-(define
-  mod/case-resolve
-  (fn
-    (c)
-    (if
-      (= (mod/case-tier c) "human")
-      (mod/case-error-set c "awaiting human review (escalated)")
-      (mod/case-goto
-        c
-        "decided"
-        "auto-tier resolved"
-        (mod/case-report c)
-        (mod/case-decision c)
-        (mod/case-tier c)))))
-
-;; :triaged → :decided — human review: attach evidence, re-decide, resolve.
-(define
-  mod/case-review
-  (fn
-    (c kind val reports rules)
-    (let
-      ((nr (mod/attach-evidence (mod/case-report c) (mod/mk-evidence kind val))))
-      (let
-        ((d (mod/decide-report nr reports rules)))
-        (mod/case-goto c "decided" (str "human review: " kind) nr d "human")))))
-
-;; :decided → :appealed — appeal: attach evidence, re-decide (may override).
-(define
-  mod/case-appeal
-  (fn
-    (c kind val reports rules)
-    (let
-      ((nr (mod/attach-evidence (mod/case-report c) (mod/mk-evidence kind val))))
-      (let
-        ((d (mod/decide-report nr reports rules)))
-        (mod/case-goto
-          c
-          "appealed"
-          (str "appeal: " kind)
-          nr
-          d
-          (mod/case-tier c))))))
-
-;; :decided | :appealed → :final
-(define
-  mod/case-finalize
-  (fn
-    (c)
-    (mod/case-goto
-      c
-      "final"
-      "finalized"
-      (mod/case-report c)
-      (mod/case-decision c)
-      (mod/case-tier c))))
-
-(define
-  mod/case-action
-  (fn
-    (c)
-    (let ((d (mod/case-decision c))) (if (nil? d) nil (get d :action)))))

lib/mod/link.sx

@@ -1,92 +0,0 @@
-;; lib/mod/link.sx — report linking + deduplication.
-;;
-;; Reports about the same subject form a cluster; identical reports (same
-;; reporter + subject + reason) are duplicates. Linking is Prolog-backed: all
-;; report facts are loaded and related ids are found by unification — the same
-;; relational substrate the policy engine uses, here for retrieval rather than
-;; decision. Dedup is pure SX over a normalized link key.
-
-(define
-  mod/link-key
-  (fn
-    (r)
-    (str
-      (mod/report-by r)
-      "|"
-      (mod/report-about r)
-      "|"
-      (downcase (mod/report-reason r)))))
-
-(define
-  mod/dedup-reports
-  (fn
-    (reports)
-    (reduce
-      (fn
-        (acc r)
-        (if
-          (mod/any? (fn (x) (= (mod/link-key x) (mod/link-key r))) acc)
-          acc
-          (append acc (list r))))
-      (list)
-      reports)))
-
-(define
-  mod/duplicate-count
-  (fn (reports) (- (len reports) (len (mod/dedup-reports reports)))))
-
-;; ── Prolog-backed relational retrieval ──
-
-(define
-  mod/report-rel-facts
-  (fn
-    (reports)
-    (mod/join-with
-      "\n"
-      (map
-        (fn
-          (r)
-          (str
-            "report("
-            (mod/report-id r)
-            ", "
-            (mod/pl-quote (mod/report-by r))
-            ", "
-            (mod/pl-quote (mod/report-about r))
-            ")."))
-        reports))))
-
-(define
-  mod/related-ids
-  (fn
-    (subject reports)
-    (let
-      ((db (pl-load (mod/report-rel-facts reports))))
-      (map
-        (fn (sol) (dict-get sol "Id"))
-        (pl-query-all db (str "report(Id, _, " (mod/pl-quote subject) ")"))))))
-
-(define
-  mod/reporters-of
-  (fn
-    (subject reports)
-    (let
-      ((db (pl-load (mod/report-rel-facts reports))))
-      (map
-        (fn (sol) (dict-get sol "By"))
-        (pl-query-all db (str "report(_, By, " (mod/pl-quote subject) ")"))))))
-
-(define
-  mod/distinct
-  (fn
-    (items)
-    (reduce
-      (fn
-        (acc x)
-        (if (mod/any? (fn (y) (= y x)) acc) acc (append acc (list x))))
-      (list)
-      items)))
-
-(define
-  mod/distinct-reporters-of
-  (fn (subject reports) (mod/distinct (mod/reporters-of subject reports))))

lib/mod/lint.sx

@@ -1,69 +0,0 @@
-;; lib/mod/lint.sx — static analysis of a policy rule set.
-;;
-;; Because precedence is "first matching clause wins" (pl-query-one), the rule
-;; order has correctness consequences a moderator can get wrong: a rule placed
-;; after an unconditional (empty :when) rule can never fire, and a rule set with
-;; no unconditional rule may leave some reports undecided. lint-rules surfaces
-;; these without running the engine.
-
-(define mod/rule-unconditional? (fn (r) (empty? (mod/rule-when r))))
-
-;; names of rules that follow the first unconditional rule — structurally dead,
-;; since the unconditional rule always matches first
-(define
-  mod/unreachable-rules
-  (fn
-    (rules)
-    (get
-      (reduce
-        (fn
-          (acc r)
-          (if
-            (get acc :hit)
-            {:dead (append (get acc :dead) (list (mod/rule-name r))) :hit true}
-            (if (mod/rule-unconditional? r) {:dead (get acc :dead) :hit true} acc)))
-        {:dead (list) :hit false}
-        rules)
-      :dead)))
-
-(define
-  mod/has-catchall?
-  (fn (rules) (mod/any? mod/rule-unconditional? rules)))
-
-(define
-  mod/count-eq
-  (fn
-    (x lst)
-    (reduce (fn (a y) (if (= y x) (+ a 1) a)) 0 lst)))
-
-(define
-  mod/duplicate-rule-names
-  (fn
-    (rules)
-    (let
-      ((names (map mod/rule-name rules)))
-      (mod/distinct
-        (reduce
-          (fn
-            (acc n)
-            (if
-              (< 1 (mod/count-eq n names))
-              (append acc (list n))
-              acc))
-          (list)
-          names)))))
-
-(define mod/lint-rules (fn (rules) {:duplicate-names (mod/duplicate-rule-names rules) :has-catchall (mod/has-catchall? rules) :unreachable (mod/unreachable-rules rules)}))
-
-;; a rule set is well-formed when nothing is dead, it has a catch-all, and rule
-;; names are unique
-(define
-  mod/rules-ok?
-  (fn
-    (rules)
-    (let
-      ((l (mod/lint-rules rules)))
-      (if
-        (empty? (get l :unreachable))
-        (if (get l :has-catchall) (empty? (get l :duplicate-names)) false)
-        false))))

lib/mod/offenders.sx

@@ -1,59 +0,0 @@
-;; lib/mod/offenders.sx — repeat-offender escalation (audit log as evidence).
-;;
-;; The append-only audit trail is itself a source of evidence: a subject already
-;; sanctioned several times is a repeat offender. mod/decide-escalating decides a
-;; report normally, then — if the action is a sanction and the subject has at
-;; least k PRIOR sanctions in the audit log — upgrades it to :ban. This is the one
-;; place a decision depends on history beyond the single report, and it reads that
-;; history from the audit log rather than re-deriving it.
-
-(define
-  mod/sanction?
-  (fn
-    (action)
-    (mod/any? (fn (a) (= a action)) (list "hide" "remove" "ban"))))
-
-;; count of prior sanctioning decisions in the audit log about a subject
-(define
-  mod/subject-sanctions
-  (fn
-    (subject)
-    (reduce
-      (fn
-        (acc e)
-        (let
-          ((r (mod/get-report (get e :report-id))))
-          (if
-            (nil? r)
-            acc
-            (if
-              (if
-                (= (mod/report-about r) subject)
-                (mod/sanction? (get e :action))
-                false)
-              (+ acc 1)
-              acc))))
-      0
-      (mod/audit-all))))
-
-(define
-  mod/repeat-offender?
-  (fn (subject k) (<= k (mod/subject-sanctions subject))))
-
-(define
-  mod/decide-escalating
-  (fn
-    (id k)
-    (let
-      ((r (mod/get-report id)))
-      (if
-        (nil? r)
-        nil
-        (let
-          ((priors (mod/subject-sanctions (mod/report-about r))))
-          (let
-            ((d (mod/decide id)))
-            (if
-              (if (mod/sanction? (get d :action)) (<= k priors) false)
-              {:action "ban" :proof {:goals (get (get d :proof) :goals) :prior-sanctions priors :evidence (get (get d :proof) :evidence) :conditions (list) :rule "repeat-offender-ban" :count (get (get d :proof) :count)} :report-id id :rule "repeat-offender-ban" :strategy "escalating"}
-              d)))))))

lib/mod/pipeline.sx

@@ -1,18 +0,0 @@
-;; lib/mod/pipeline.sx — end-to-end triage orchestration.
-;;
-;; A single entry point that runs a report through the subsystem and returns the
-;; full artifact bundle: the decision (under the report's domain policy), a
-;; human-readable explanation, an ActivityPub-shaped event for the bus, and the
-;; wire line for federated peers. Composes policies (Ext 17), explain (Ext 3),
-;; activity (Ext 16) and wire (Ext 14) — the modules are independent, this is just
-;; the convenience that wires them together for the common "process a report" path.
-
-(define
-  mod/triage-pipeline
-  (fn
-    (domain r reports actor)
-    (let ((d (mod/decide-in domain r reports))) {:activity (mod/decision->activity d actor) :action (get d :action) :wire (mod/decision->wire d) :rule (get d :rule) :decision d :explanation (mod/explain d)})))
-
-(define mod/pipeline-action (fn (p) (get p :action)))
-(define mod/pipeline-activity (fn (p) (get p :activity)))
-(define mod/pipeline-wire (fn (p) (get p :wire)))

lib/mod/policies.sx

@@ -1,40 +0,0 @@
-;; lib/mod/policies.sx — per-domain policy registry.
-;;
-;; rose-ash spans domains (blog, market, events, federation, …) that want
-;; different moderation — a marketplace listing and a blog comment are not held to
-;; the same bar. This registry maps a domain to a rule set; mod/decide-in resolves
-;; the right policy and decides. Unregistered domains fall back to the default
-;; rules, so adding a domain never leaves it unmoderated.
-
-(define mod/*policies* (list))
-
-(define mod/policies-reset! (fn () (set! mod/*policies* (list))))
-
-(define
-  mod/register-policy!
-  (fn (domain rules) (begin (append! mod/*policies* {:domain domain :rules rules}) true)))
-
-(define
-  mod/policy-registered?
-  (fn
-    (domain)
-    (mod/any? (fn (p) (= (get p :domain) domain)) mod/*policies*)))
-
-(define
-  mod/policy-for
-  (fn
-    (domain)
-    (reduce
-      (fn (acc p) (if (= (get p :domain) domain) (get p :rules) acc))
-      mod/default-rules
-      mod/*policies*)))
-
-(define
-  mod/decide-in
-  (fn
-    (domain r reports)
-    (mod/decide-report r reports (mod/policy-for domain))))
-
-(define
-  mod/registered-domains
-  (fn () (map (fn (p) (get p :domain)) mod/*policies*)))

lib/mod/policy.sx

@@ -1,137 +0,0 @@
-;; 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. 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
-;; goal-by-goal re-querying in the engine).
-;;
-;; Precedence (top wins): exoneration evidence (appeal override) > confirmed-abuse
-;; evidence (human review) > spam/abuse classification > repeated-report count >
-;; default keep.
-
-(define mod/mk-rule (fn (name action conds) {:when conds :name name :action action}))
-
-(define mod/rule-name (fn (r) (get r :name)))
-(define mod/rule-action (fn (r) (get r :action)))
-(define mod/rule-when (fn (r) (get r :when)))
-
-(define
-  mod/default-rules
-  (list
-    (mod/mk-rule
-      "exonerated-keep"
-      :keep (list (list :evidence "exonerated")))
-    (mod/mk-rule
-      "reviewer-remove"
-      :remove (list (list :evidence "confirmed-abuse")))
-    (mod/mk-rule "spam-hide" :hide (list (list :classification "spam")))
-    (mod/mk-rule
-      "abuse-remove"
-      :remove (list (list :classification "abuse")))
-    (mod/mk-rule
-      "repeated-escalate"
-      :escalate (list (list :count-at-least 3)))
-    (mod/mk-rule "default-keep" :keep (list))))
-
-;; ── condition → Prolog goal ──
-;;
-;; (:classification "spam")  → classification(Id, spam)
-;; (:evidence "kind")        → evidence(Id, 'kind', _)
-;; (:attr "verified")        → attr(Id, verified)
-;; (: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   (quorum engine)
-;; (:burst-at-least 3)       → report(Id, _, Sb), burst_count(Sb, Nb), Nb >= 3
-;;                             (temporal engine)
-
-(define
-  mod/cond->goal
-  (fn
-    (c idterm)
-    (let
-      ((tag (first c)))
-      (cond
-        ((= tag :classification)
-          (str "classification(" idterm ", " (nth c 1) ")"))
-        ((= tag :evidence)
-          (str
-            "evidence("
-            idterm
-            ", "
-            (mod/pl-quote (nth c 1))
-            ", _)"))
-        ((= 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("
-            idterm
-            ", B, S), report_count(S, N), N >= "
-            (nth c 1)))
-        ((= tag :score-at-least)
-          (str
-            "aggregate_all(sum(W), signal("
-            idterm
-            ", _, W), T), T >= "
-            (nth c 1)))
-        ((= tag :reporters-at-least)
-          (str
-            "report("
-            idterm
-            ", _, Sr), setof(Br, report(_, Br, Sr), Bsr), "
-            "length(Bsr, Nr), Nr >= "
-            (nth c 1)))
-        ((= tag :burst-at-least)
-          (str
-            "report("
-            idterm
-            ", _, Sb), burst_count(Sb, Nb), Nb >= "
-            (nth c 1)))
-        (true "true")))))
-
-(define
-  mod/conds->body
-  (fn
-    (conds idterm)
-    (if
-      (empty? conds)
-      "true"
-      (mod/join-with ", " (map (fn (c) (mod/cond->goal c idterm)) conds)))))
-
-(define
-  mod/rule->clause
-  (fn
-    (r)
-    (str
-      "policy_action(Id, "
-      (mod/rule-action r)
-      ", '"
-      (mod/rule-name r)
-      "') :- "
-      (mod/conds->body (mod/rule-when r) "Id")
-      ".")))
-
-(define
-  mod/rules->program
-  (fn (rules) (mod/join-with "\n" (map mod/rule->clause rules))))

lib/mod/quorum.sx

@@ -1,40 +0,0 @@
-;; lib/mod/quorum.sx — quorum decisions over distinct reporters (anti-brigade).
-;;
-;; The base engine asserts only the decided report's report/3 fact, so it can't
-;; reason about WHO reported a subject. The quorum engine additionally asserts
-;; every report's report/3 fact (via link's rel-facts), letting a rule require N
-;; *distinct* reporters with `setof`/`length` — so one user filing many reports
-;; does not manufacture consensus. Same decision shape as the base engine, plus
-;; :strategy "quorum".
-
-(define
-  mod/build-quorum-program
-  (fn
-    (r count reports rules)
-    (str
-      (mod/report-rel-facts reports)
-      "\n"
-      (mod/report-facts r count)
-      "\n"
-      (mod/rules->program rules))))
-
-(define
-  mod/decide-quorum
-  (fn
-    (r reports rules)
-    (let
-      ((count (mod/report-count (mod/report-about r) reports))
-        (kinds (mod/classify-keywords r))
-        (id (mod/report-id r)))
-      (let
-        ((program (mod/build-quorum-program r count reports rules)))
-        (let
-          ((db (pl-load program)))
-          (let
-            ((sol (pl-query-one db (str "policy_action(" id ", Action, Rule)"))))
-            (if
-              (nil? sol)
-              {:action "keep" :proof {:goals (list) :evidence kinds :conditions (list) :rule "none" :count count} :report-id id :rule "none" :strategy "quorum"}
-              (let
-                ((rule (mod/find-rule rules (dict-get sol "Rule"))))
-                {:action (mod/rule-action rule) :proof {:goals (mod/proof-goals db id (mod/rule-when rule)) :evidence kinds :conditions (mod/rule-when rule) :rule (mod/rule-name rule) :count count} :report-id id :rule (mod/rule-name rule) :strategy "quorum"}))))))))