datalog: SX-data embedding API (Phase 9, 143/143)

New lib/datalog/api.sx: dl-program-data facts rules takes SX data
lists. Rules accept either dict form or list form using <- as the
rule arrow (since SX parses :- as a keyword). dl-rule constructor
for the dict shape. dl-assert! adds a fact and re-saturates;
dl-retract! drops EDB matches, wipes all rule-headed IDB
relations, and re-saturates from scratch — simplest correct
semantics until provenance tracking arrives.

9 API tests cover ancestor closure via data, dict-rule form,
dl-rule constructor, incremental assert/retract, cyclic-graph
reach, assert into empty, fact-style rule (no arrow), dict
passthrough.

plans/datalog-on-sx.md

@@ -208,18 +208,30 @@ large graphs.
       group-by, distinct-counted-once.
 
 ### Phase 9 — SX embedding API
-- [ ] `(dl-program facts rules)` → database from SX data directly (no parsing required)
+- [x] `(dl-program-data facts rules)` builds a db from SX data —
+      `facts` is a list of literals, `rules` is a list of either
+      dicts `{:head … :body …}` or lists `(<head…> <- <body…>)`.
+      Variables are SX symbols whose first char is uppercase or `_`,
+      matching the parser's convention.
       ```
-      (dl-program
-        '((parent tom bob) (parent tom liz) (parent bob ann))
-        '((ancestor X Z :- (parent X Y) (ancestor Y Z))
-          (ancestor X Y :- (parent X Y))))
+      (dl-program-data
+        '((parent tom bob) (parent bob ann))
+        '((ancestor X Y <- (parent X Y))
+          (ancestor X Z <- (parent X Y) (ancestor Y Z))))
       ```
-- [ ] `(dl-query db '(ancestor tom ?X))` → `((ann) (bob) (liz) (pat))`
-- [ ] `(dl-assert! db '(parent ann pat))` → incremental fact addition + re-derive
-- [ ] `(dl-retract! db '(parent tom bob))` → fact removal + re-derive from scratch
+- [x] `(dl-rule head body)` constructor for the dict form.
+- [x] `(dl-query db '(ancestor tom X))` already worked — same query API
+      consumes the SX-data goal.
+- [x] `(dl-assert! db '(parent ann pat))` → adds the fact and re-saturates.
+- [x] `(dl-retract! db '(parent bob ann))` → drops matching tuples from
+      the EDB list, wipes every relation that has a rule (those are IDB),
+      and re-saturates from the surviving EDB.
+- [x] Tests in `lib/datalog/tests/api.sx` (9): closure via data API,
+      dict-rule form, dl-rule constructor, dl-assert! incremental,
+      dl-retract! removes derived, cyclic-graph reach via data,
+      assert into empty db, fact-style rule (no arrow), coerce dict.
 - [ ] Integration demo: federation graph query — `(ancestor actor1 actor2)` over
-      rose-ash ActivityPub follow relationships
+      rose-ash ActivityPub follow relationships (Phase 10).
 
 ### Phase 10 — Datalog as a query language for rose-ash
 - [ ] Schema: map SQLAlchemy model relationships to Datalog EDB facts
@@ -245,6 +257,16 @@ large graphs.
 
 _Newest first._
 
+- 2026-05-08 — Phase 9 done. New `lib/datalog/api.sx` exposes a
+  parser-free embedding: `dl-program-data facts rules` accepts SX
+  data lists, with rules in either dict form or list form using
+  `<-` as the rule arrow (since SX parses `:-` as a keyword).
+  `dl-rule head body` constructs the dict. `dl-assert! db lit` adds
+  a fact and re-saturates; `dl-retract! db lit` drops the fact from
+  EDB, wipes all rule-headed (IDB) relations, and re-saturates from
+  scratch — the simplest correct semantics until provenance tracking
+  arrives in a later phase. 9 API tests; conformance now 143/143.
+
 - 2026-05-08 — Phase 8 done. New `lib/datalog/aggregates.sx` (~110
   LOC): count / sum / min / max. Each is a body literal of shape
   `(op R V Goal)` — `dl-eval-aggregate` runs `dl-find-bindings` on