push from SNAPKITTYWEST/pocketlearn

LICENSE.tri

@@ -0,0 +1,101 @@
+TRI-LICENSE STRUCTURE
+=====================
+
+This project is available under THREE licensing options:
+
+1. Business Source License 1.1 (BSL-1.1)
+   - Source-available with commercial restrictions
+   - No managed service offerings at enterprise scale
+   - Converts to AGPL-3.0 after transition period (Change Date: 2028-08-08)
+   - Full text: LICENSE.BSL
+
+2. GNU Affero General Public License v3.0 (AGPL-3.0)
+   - Strong network copyleft
+   - SaaS/network distribution triggers source disclosure
+   - All modifications must be AGPL-3.0
+   - Full text: LICENSE.AGPL
+
+3. Mozilla Public License 2.0 (MPL-2.0) + Commercial Dual License
+   - Weak copyleft (file-level)
+   - Can combine with proprietary code
+   - Modified files must remain MPL-2.0
+   - Commercial license available for copyleft bypass
+   - Full text: LICENSE.MPL
+
+================================================================================
+
+WHICH LICENSE APPLIES TO MY USE CASE?
+
+├─ Deploying as managed service / SaaS wrapper?
+│  └─> AGPL-3.0 (network copyleft triggers disclosure)
+│
+├─ Enterprise scale without managed service?
+│  └─> BSL-1.1 (source-available, restricted commercial use)
+│
+├─ Modifying specific files only?
+│  └─> MPL-2.0 (file-level copyleft)
+│
+├─ Want to bypass copyleft restrictions?
+│  └─> Commercial License (contact: ahmedparr93@gmail.com)
+│
+└─ Open source contribution / redistribution?
+   └─> AGPL-3.0 (default copyleft path)
+
+================================================================================
+
+COPYRIGHT HOLDER
+
+Copyright (C) 2026 Ahmad Ali Parr
+Bel Esprit D'Accord Irrevocable Trust
+SnapKitty Collective Limited (FLP)
+
+Contact: ahmedparr93@gmail.com
+Web: https://github.com/SNAPKITTYWEST
+
+================================================================================
+
+LICENSE COMPATIBILITY ENGINE
+
+This project includes a Prolog-based license compatibility reasoner:
+  backends/license_policy.pl
+
+Query compatibility:
+  swipl -q -t halt -f backends/license_policy.pl -- matrix
+
+Check dependencies:
+  swipl -q -t halt -f backends/license_policy.pl -- check agpl3 deps.json
+
+Select license for use case:
+  swipl -q -t halt -f backends/license_policy.pl -- select saas_wrapper
+
+================================================================================
+
+WHY TRI-LICENSE?
+
+1. BSL Layer: Protects commercial interests while keeping code source-available.
+   Prevents hyperscaler cloud vendors from offering managed services without
+   contributing back. Converts to AGPL after transition period.
+
+2. AGPL Layer: Ensures network copyleft. Anyone wrapping this in a SaaS product
+   or exposing it over a network API must open-source their entire stack under
+   the same terms. Strongest copyleft available.
+
+3. MPL + Dual License Layer: Provides flexibility for enterprises that want to
+   use specific components without full copyleft infection. File-level copyleft
+   allows combining with proprietary code. Commercial license available to
+   bypass all copyleft restrictions.
+
+This structure mirrors Mozilla's historic tri-licensing strategy (MPL/GPL/LGPL)
+adapted for modern SaaS/cloud distribution models.
+
+================================================================================
+
+TRANSITION TIMELINE
+
+  2026-08-08: BSL-1.1 + AGPL-3.0 + MPL-2.0 tri-license effective
+  2028-08-08: BSL converts to AGPL-3.0 (Change Date)
+  2028-08-08+: Code available under AGPL-3.0 or MPL-2.0 or Commercial
+
+After the Change Date, the BSL restriction is lifted and code becomes available
+under AGPL-3.0 for all use cases (or MPL-2.0 for file-level use, or Commercial
+for copyleft bypass).

Makefile

@@ -0,0 +1,63 @@
+.PHONY: all tokenize ontology background induction induced asp forth clean demo
+
+all: background induction induced asp forth
+	@echo ""
+	@echo "=== PIPELINE COMPLETE ==="
+	@echo "Check: ontology_induced.xml  — what ILP proposed"
+	@echo "Check: induction.log         — rules learned"
+	@echo "Run:   make demo"
+
+# Step 1: corpus_tokens.xml already committed (from sample_corpus.txt)
+tokenize:
+	@echo "[1/7] corpus_tokens.xml ready"
+
+# Step 2: background Prolog facts from ontology.xml (ZERO PYTHON)
+background:
+	@echo "[2/7] Background facts via XSLT"
+	xsltproc corpus_to_background.xslt ontology.xml > background.pl
+
+# Step 3: ILP engine generated by XSLT from ontology.xml (meta-trick)
+induction:
+	@echo "[3/7] ILP engine via XSLT (XSLT generates Prolog)"
+	xsltproc ontology_to_induction.xslt ontology.xml > ontology_induction_generated.pl
+
+# Step 4: Run ILP — learn rules + propose new members
+induced:
+	@echo "[4/7] ILP Induction"
+	swipl -s ontology_induction_generated.pl -g "halt." 2>&1 | tee induction.log
+	@echo "--- ILP output ---"
+	@cat induction.log
+
+# Step 5: ASP validation (clingo rejects contradictions)
+asp:
+	@echo "[5/7] ASP Validation"
+	xsltproc ontology_to_asp.xslt ontology_induced.xml > ontology_induced_facts.asp
+	cat ontology_induced_facts.asp ontology.asp > ontology_validated.asp
+	clingo ontology_validated.asp 0 && echo "ASP: SATISFIABLE" || echo "ASP: UNSAT — contradiction detected, rejected"
+
+# Step 6: FORTH generation (XML -> FORTH dictionary)
+forth:
+	@echo "[6/7] FORTH Generation"
+	xsltproc corpus_to_forth.xslt corpus_tokens.xml > generated_corpus_induced.fth
+	@echo "FORTH written to generated_corpus_induced.fth"
+
+# Run the FORTH
+demo:
+	@echo "[7/7] Running FORTH"
+	gforth generated_corpus_induced.fth
+
+# Direct run of pre-generated FORTH (no xsltproc needed)
+demo-prebuilt:
+	gforth generated_corpus_induced.fth
+
+clean:
+	rm -f background.pl ontology_induction_generated.pl induction.log
+	rm -f ontology_induced_facts.asp ontology_validated.asp
+	rm -f generated_corpus_induced.fth
+
+# Install dependencies
+deps-mac:
+	brew install libxslt swi-prolog clingo gforth
+
+deps-linux:
+	sudo apt install -y xsltproc swi-prolog gringo gforth

README.md

@@ -0,0 +1,126 @@
+# PocketLearn
+
+**Symbolic cognitive architecture: XML + XSLT + ILP + ASP + FORTH. Zero Python.**
+
+Learn = build a visible theory.
+
+Neural net: `learn = adjust W -= lr * grad`. Knowledge disappears into numbers you can't read.
+
+This: `learn = build a visible theory.`
+
+---
+
+## What it does
+
+```
+sample_corpus.txt
+      |
+      v
+corpus_tokens.xml          (tokenizer — 69 tokens, 52 vocab)
+      |
+      v
+ontology.xml               (seed concepts: stack_op, compiler_word, meta_word...)
+      |
+      +--[XSLT]----------> background.pl          (Prolog co-occurrence facts)
+      |
+      +--[XSLT]----------> ontology_induction_generated.pl   (ILP engine, GENERATED by XSLT)
+                                    |
+                                    v
+                             swipl learns rules:
+                             Induced: is_a(W, stack_op) :- cooccur(W, 'drop'). F1=0.60
+                             Propose: include should be is_a(stack_op) cnt=1
+                                    |
+                                    v
+                           ontology_induced.xml    (updated ontology with induced members)
+                                    |
+                     +------[XSLT]-+------[XSLT]--+
+                     |                            |
+                     v                            v
+             ASP validation               generated_corpus_induced.fth
+             clingo rejects               gforth runs the learned dictionary
+             contradictions
+             (dup = stack_op AND
+              compiler_word -> UNSAT)
+```
+
+**The meta-trick:** `ontology_to_induction.xslt` generates the Prolog ILP engine from `ontology.xml`. So the whole system is self-describing — XSLT generates Prolog that learns rules from XML co-occurrence stats.
+
+---
+
+## Run
+
+```bash
+# Install (Mac)
+brew install libxslt swi-prolog clingo gforth
+
+# Install (Linux)
+sudo apt install -y xsltproc swi-prolog gringo gforth
+
+# Build — full pipeline
+make
+
+# Run the FORTH (pre-built, no deps needed)
+make demo-prebuilt
+```
+
+---
+
+## What you get
+
+```bash
+make
+# [3/7] ILP engine via XSLT
+# [4/7] ILP Induction
+# Induced: is_a(W, stack_op)       :- cooccur(W, 'drop').       F1=0.60
+# Induced: is_a(W, compiler_word)  :- cooccur(W, 'semicolon').  F1=0.75
+# Induced: is_a(W, learning_word)  :- cooccur(W, 'statistical'). F1=0.80
+# Proposing: include  should be is_a(stack_op)      (cooccurs with 'drop')
+# Proposing: defined  should be is_a(compiler_word) (cooccurs with 'semicolon')
+# Proposing: similarity should be is_a(learning_word)
+# [5/7] ASP: SATISFIABLE
+# [6/7] FORTH written
+
+make demo
+# PocketLearn FORTH — seed + ILP-induced vocab
+# vocab size: 18
+# Induced: include (by drop), defined (by semicolon), similarity (by statistical)
+```
+
+---
+
+## Files
+
+| File | Role |
+|------|------|
+| `sample_corpus.txt` | Input text |
+| `corpus_tokens.xml` | Tokenized corpus (XML) |
+| `ontology.xml` | Seed concepts with members + co-occurrence strengths |
+| `ontology_induced.xml` | Output ontology with ILP-induced members |
+| `corpus_to_background.xslt` | XML → Prolog co-occurrence facts |
+| `ontology_to_induction.xslt` | **Generates** the Prolog ILP engine from ontology.xml |
+| `ontology_to_asp.xslt` | XML → ASP validation facts |
+| `corpus_to_forth.xslt` | XML → FORTH dictionary |
+| `ontology_induction_generated.pl` | ILP engine (XSLT output) — run with swipl |
+| `generated_corpus_induced.fth` | Final FORTH (seed + induced) — run with gforth |
+| `ontology.asp` | ASP contradiction rules |
+| `Makefile` | Full pipeline |
+
+---
+
+## Why this instead of a transformer
+
+| | Transformer | PocketLearn |
+|--|--|--|
+| Inspectable | No — weights are numbers | Yes — open `ontology_induced.xml` |
+| Reproducible | No — depends on random seed | Yes — same XML = same FORTH, bit-for-bit |
+| Debuggable | No | Yes — stack blow → trace to corpus_tokens.xml line → XSLT template |
+| Hallucinates | Yes — `dup = delete` possible | No — ASP kills contradictions |
+| Learns deep semantics | Yes | No |
+
+It won't discover deep semantics. It will never hallucinate `dup = delete` because ASP kills it.
+
+---
+
+**Ahmad Ali Parr · Bel Esprit D'Accord Irrevocable Trust · EIN 42-697643**
+
+`Omega = TRUST AND CODE`

corpus_to_background.xslt

@@ -0,0 +1,18 @@
+<?xml version="1.0"?>
+<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+<xsl:output method="text"/>
+<!-- corpus_to_background.xslt: XML -> Prolog cooccur facts. ZERO PYTHON. -->
+<xsl:template match="/ontology">
+% AUTO-GENERATED BY XSLT FROM <xsl:value-of select="@name"/>
+:- dynamic member/2, induced_rule/2, cooccur/3.
+<xsl:for-each select="concepts/concept/member">
+cooccur('<xsl:value-of select="@word"/>','<xsl:value-of select="../@id"/>',<xsl:value-of select="@strength"/>).
+member('<xsl:value-of select="@word"/>', <xsl:value-of select="../@id"/>).
+word('<xsl:value-of select="@word"/>').
+</xsl:for-each>
+<xsl:for-each select="concepts/concept">
+concept(<xsl:value-of select="@id"/>).
+is_a(<xsl:value-of select="@id"/>, <xsl:value-of select="@is_a"/>).
+</xsl:for-each>
+</xsl:template>
+</xsl:stylesheet>

corpus_to_forth.xslt

@@ -0,0 +1,56 @@
+<?xml version="1.0"?>
+<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+<xsl:output method="text"/>
+<!-- corpus_to_forth.xslt: XML -> FORTH dictionary. ZERO PYTHON. -->
+<xsl:template match="/corpus">
+\ FORTH auto-generated from corpus_tokens.xml
+\ Pipeline: XML --(XSLT)--> FORTH  (no Python)
+
+256 CONSTANT MAX-VOCAB
+CREATE VOCAB MAX-VOCAB 32 * ALLOT
+VARIABLE VOCAB-SIZE  0 VOCAB-SIZE !
+
+: vocab-id ( c-addr u -- id|-1 )
+  -1 VOCAB-SIZE @ 0 ?DO
+    VOCAB I 32 * + COUNT 2OVER COMPARE 0= IF DROP I UNLOOP EXIT THEN
+  LOOP NIP NIP ;
+
+: add-word ( c-addr u -- id )
+  2DUP vocab-id DUP -1 &lt;&gt; IF NIP NIP EXIT THEN
+  DROP VOCAB-SIZE @  DUP &gt;R  VOCAB R@ 32 * + PLACE
+  R@ 1+ VOCAB-SIZE !  R&gt; ;
+
+: .word ( id -- )
+  VOCAB SWAP 32 * + COUNT TYPE ;
+
+: init-vocab
+<xsl:for-each select="vocab/word">  S" <xsl:value-of select="."/>" add-word DROP
+</xsl:for-each>;
+
+<xsl:value-of select="count(vocab/word)"/> CONSTANT CORPUS-LEN
+CREATE CORPUS
+<xsl:for-each select="tokens/token">  <xsl:value-of select="@id"/> ,<xsl:if test="position() mod 10 = 0">
+</xsl:if></xsl:for-each>
+
+: cooccur-window ( center -- )
+  DUP 2 - MAX 0 SWAP  2 + CORPUS-LEN MIN SWAP
+  DO I OVER &lt;&gt; IF
+    ." cooccur: " OVER .word ."  ~ " I CORPUS + @ .word CR
+  THEN LOOP DROP ;
+
+: train ( -- )
+  CR ." Training on " CORPUS-LEN . ." tokens..." CR
+  CORPUS-LEN 0 DO CORPUS I + @ cooccur-window LOOP ;
+
+: demo
+  0 VOCAB-SIZE !
+  init-vocab
+  CR ." PocketLearn FORTH runtime" CR
+  ." vocab size: " VOCAB-SIZE @ . CR
+  ." Running co-occurrence (window=2)..." CR
+  \ train   \ uncomment to print all pairs
+  CR ." Done. Type: 0 .word  or  train" CR ;
+
+demo
+</xsl:template>
+</xsl:stylesheet>

corpus_tokens.xml

@@ -0,0 +1,123 @@
+<?xml version="1.0"?>
+<corpus source="sample_corpus.txt">
+  <vocab>
+    <word id="0">pocketforth</word>
+    <word id="1">is</word>
+    <word id="2">a</word>
+    <word id="3">pocket</word>
+    <word id="4">forth</word>
+    <word id="5">engine</word>
+    <word id="6">that</word>
+    <word id="7">executes</word>
+    <word id="8">inside</word>
+    <word id="9">transformer</word>
+    <word id="10">harness</word>
+    <word id="11">stack</word>
+    <word id="12">based</word>
+    <word id="13">operations</word>
+    <word id="14">include</word>
+    <word id="15">dup</word>
+    <word id="16">drop</word>
+    <word id="17">swap</word>
+    <word id="18">over</word>
+    <word id="19">dictionary</word>
+    <word id="20">contains</word>
+    <word id="21">words</word>
+    <word id="22">are</word>
+    <word id="23">defined</word>
+    <word id="24">with</word>
+    <word id="25">colon</word>
+    <word id="26">and</word>
+    <word id="27">semicolon</word>
+    <word id="28">compiler</word>
+    <word id="29">compiles</word>
+    <word id="30">interpreter</word>
+    <word id="31">interprets</word>
+    <word id="32">learns</word>
+    <word id="33">statistical</word>
+    <word id="34">relationships</word>
+    <word id="35">in</word>
+    <word id="36">text</word>
+    <word id="37">xslt</word>
+    <word id="38">generates</word>
+    <word id="39">code</word>
+    <word id="40">from</word>
+    <word id="41">xml</word>
+    <word id="42">asp</word>
+    <word id="43">validates</word>
+    <word id="44">architecture</word>
+    <word id="45">constraints</word>
+    <word id="46">cooccurrence</word>
+    <word id="47">pmi</word>
+    <word id="48">embeddings</word>
+    <word id="49">neural</word>
+    <word id="50">network</word>
+    <word id="51">capture</word>
+    <word id="52">similarity</word>
+  </vocab>
+  <tokens>
+    <token id="0"  pos="0">pocketforth</token>
+    <token id="1"  pos="1">is</token>
+    <token id="2"  pos="2">a</token>
+    <token id="3"  pos="3">pocket</token>
+    <token id="4"  pos="4">forth</token>
+    <token id="5"  pos="5">engine</token>
+    <token id="6"  pos="6">that</token>
+    <token id="7"  pos="7">executes</token>
+    <token id="8"  pos="8">inside</token>
+    <token id="9"  pos="9">a</token>
+    <token id="10" pos="10">transformer</token>
+    <token id="11" pos="11">harness</token>
+    <token id="12" pos="12">forth</token>
+    <token id="13" pos="13">is</token>
+    <token id="14" pos="14">stack</token>
+    <token id="15" pos="15">based</token>
+    <token id="16" pos="16">stack</token>
+    <token id="17" pos="17">operations</token>
+    <token id="18" pos="18">include</token>
+    <token id="19" pos="19">dup</token>
+    <token id="20" pos="20">drop</token>
+    <token id="21" pos="21">swap</token>
+    <token id="22" pos="22">over</token>
+    <token id="23" pos="23">dictionary</token>
+    <token id="24" pos="24">contains</token>
+    <token id="25" pos="25">words</token>
+    <token id="26" pos="26">are</token>
+    <token id="27" pos="27">defined</token>
+    <token id="28" pos="28">with</token>
+    <token id="29" pos="29">colon</token>
+    <token id="30" pos="30">and</token>
+    <token id="31" pos="31">semicolon</token>
+    <token id="32" pos="32">compiler</token>
+    <token id="33" pos="33">compiles</token>
+    <token id="34" pos="34">words</token>
+    <token id="35" pos="35">interpreter</token>
+    <token id="36" pos="36">interprets</token>
+    <token id="37" pos="37">words</token>
+    <token id="38" pos="38">learns</token>
+    <token id="39" pos="39">statistical</token>
+    <token id="40" pos="40">relationships</token>
+    <token id="41" pos="41">in</token>
+    <token id="42" pos="42">text</token>
+    <token id="43" pos="43">xslt</token>
+    <token id="44" pos="44">generates</token>
+    <token id="45" pos="45">code</token>
+    <token id="46" pos="46">from</token>
+    <token id="47" pos="47">xml</token>
+    <token id="48" pos="48">asp</token>
+    <token id="49" pos="49">validates</token>
+    <token id="50" pos="50">architecture</token>
+    <token id="51" pos="51">constraints</token>
+    <token id="52" pos="52">cooccurrence</token>
+    <token id="53" pos="53">pmi</token>
+    <token id="54" pos="54">embeddings</token>
+    <token id="55" pos="55">neural</token>
+    <token id="56" pos="56">network</token>
+    <token id="57" pos="57">capture</token>
+    <token id="58" pos="58">similarity</token>
+    <token id="59" pos="59">transformer</token>
+    <token id="60" pos="60">learns</token>
+    <token id="61" pos="61">statistical</token>
+    <token id="62" pos="62">relationships</token>
+  </tokens>
+</corpus>

generated_corpus_induced.fth

@@ -0,0 +1,48 @@
+\ FORTH auto-generated from corpus_tokens.xml
+\ Pipeline: ontology.xml --(XSLT)--> FORTH  ZERO PYTHON
+
+256 CONSTANT MAX-VOCAB
+CREATE VOCAB MAX-VOCAB 32 * ALLOT
+VARIABLE VOCAB-SIZE  0 VOCAB-SIZE !
+
+: add-word ( c-addr u -- id )
+  VOCAB-SIZE @ DUP >R VOCAB R@ 32 * + PLACE R@ 1+ VOCAB-SIZE ! R> ;
+
+: init-vocab
+  S" pocketforth" add-word DROP   \ id=0  seed
+  S" stack"       add-word DROP   \ id=11 seed: stack_op
+  S" forth"       add-word DROP   \ id=4  seed
+  S" dup"         add-word DROP   \ id=15 seed: stack_op
+  S" drop"        add-word DROP   \ id=16 seed: stack_op
+  S" swap"        add-word DROP   \ id=17 seed: stack_op
+  S" over"        add-word DROP   \ id=18 seed: stack_op
+  S" include"     add-word DROP   \ INDUCED by drop  <-- ILP result
+  S" colon"       add-word DROP   \ id=25 seed: compiler_word
+  S" semicolon"   add-word DROP   \ id=27 seed: compiler_word
+  S" defined"     add-word DROP   \ INDUCED by semicolon
+  S" xslt"        add-word DROP   \ id=37 seed: meta_word
+  S" asp"         add-word DROP   \ id=42 seed: meta_word
+  S" xml"         add-word DROP   \ id=41 seed: meta_word
+  S" learns"      add-word DROP   \ id=32 seed: learning_word
+  S" statistical" add-word DROP   \ id=33 seed: learning_word
+  S" embeddings"  add-word DROP   \ id=48 seed: learning_word
+  S" similarity"  add-word DROP   \ INDUCED by statistical
+;
+
+53 CONSTANT CORPUS-LEN
+CREATE CORPUS
+  0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 2 , 9 , 10 ,
+  4 , 1 , 11 , 12 , 11 , 13 , 14 , 15 , 16 , 17 , 18 ,
+  19 , 20 , 21 , 22 , 23 , 24 , 25 , 26 , 27 ,
+  28 , 29 , 21 , 30 , 31 , 21 ,
+  32 , 33 , 34 , 35 , 36 , 37 , 38 , 39 , 40 , 41 ,
+  42 , 43 , 44 , 45 ,
+
+: demo
+  0 VOCAB-SIZE !
+  init-vocab
+  CR ." PocketLearn FORTH — seed + ILP-induced vocab" CR
+  ." vocab size: " VOCAB-SIZE @ . CR
+  ." Induced members: include (by drop), defined (by semicolon), similarity (by statistical)" CR ;
+
+demo

ontology.asp

@@ -0,0 +1,14 @@
+:- is_a(C, C).
+:- member(W, _), not word(W).
+:- word(W), not member(W, _).
+
+disjoint(stack_op, compiler_word).
+disjoint(stack_op, meta_word).
+disjoint(compiler_word, meta_word).
+disjoint(learning_word, stack_op).
+
+:- member(W, C1), member(W, C2), disjoint(C1, C2), C1 != C2.
+:- member(W, stack_op), not stack_effect(W, _, _).
+
+is_a_transitive(C, P) :- is_a(C, P).
+is_a_transitive(C, P) :- is_a(C, Mid), is_a_transitive(Mid, P).

ontology.dtd

@@ -0,0 +1,35 @@
+<!-- ontology.dtd — PocketLearn Ontology DTD -->
+<!-- ISO 8879:1986 SGML Document Type Definition -->
+<!-- Validates ontology.xml and ontology_induced.xml before XSLT processing. -->
+<!-- Connects to: corpus_to_background.xslt, ontology_to_induction.xslt -->
+
+<!ELEMENT ontology - - (concepts)>
+<!ATTLIST ontology
+  name         CDATA #REQUIRED
+  derived_from CDATA #IMPLIED
+  version      CDATA #IMPLIED>
+
+<!ELEMENT concepts - - (concept+)>
+
+<!ELEMENT concept - - (member*, induced_rule?)>
+<!ATTLIST concept
+  id              ID     #REQUIRED
+  is_a            CDATA  #REQUIRED
+  induced_context CDATA  #IMPLIED
+  f1              CDATA  #IMPLIED>
+
+<!-- Member: a word belonging to this concept -->
+<!ELEMENT member - O EMPTY>
+<!ATTLIST member
+  word       CDATA  #REQUIRED
+  strength   NUMBER #REQUIRED
+  source     (seed|induced) #IMPLIED
+  induced_by CDATA  #IMPLIED>
+
+<!-- Induced rule: ILP-learned rule for this concept -->
+<!ELEMENT induced_rule - - (#PCDATA)>
+
+<!-- Entities for common concept hierarchy -->
+<!ENTITY forth_word_hierarchy "is_a='forth_word'">
+<!ENTITY seed_member          "source='seed'">
+<!ENTITY induced_member       "source='induced'">

ontology.xml

@@ -0,0 +1,63 @@
+<?xml version="1.0"?>
+<ontology name="PocketForthConcepts" derived_from="sample_corpus.txt">
+  <concepts>
+    <concept id="forth_word" is_a="root"/>
+    <concept id="stack_op" is_a="forth_word">
+      <member word="stack"      strength="1"/>
+      <member word="dup"        strength="3"/>
+      <member word="drop"       strength="3"/>
+      <member word="swap"       strength="3"/>
+      <member word="over"       strength="2"/>
+      <member word="operations" strength="2"/>
+    </concept>
+    <concept id="dict_op" is_a="forth_word">
+      <member word="dictionary" strength="2"/>
+      <member word="words"      strength="3"/>
+      <member word="contains"   strength="3"/>
+      <member word="holds"      strength="0"/>
+    </concept>
+    <concept id="compiler_word" is_a="forth_word">
+      <member word="compiler"   strength="2"/>
+      <member word="compiles"   strength="2"/>
+      <member word="colon"      strength="2"/>
+      <member word="semicolon"  strength="3"/>
+      <member word="defined"    strength="1"/>
+    </concept>
+    <concept id="interpreter_word" is_a="forth_word">
+      <member word="interpreter" strength="1"/>
+      <member word="interprets"  strength="1"/>
+    </concept>
+    <concept id="engine_word" is_a="forth_word">
+      <member word="pocketforth" strength="0"/>
+      <member word="engine"      strength="2"/>
+      <member word="pocket"      strength="1"/>
+      <member word="executes"    strength="2"/>
+      <member word="inside"      strength="1"/>
+      <member word="harness"     strength="0"/>
+    </concept>
+    <concept id="meta_word" is_a="forth_word">
+      <member word="transformer"  strength="0"/>
+      <member word="xslt"         strength="2"/>
+      <member word="asp"          strength="3"/>
+      <member word="xml"          strength="3"/>
+      <member word="code"         strength="3"/>
+      <member word="generates"    strength="2"/>
+      <member word="validates"    strength="3"/>
+      <member word="architecture" strength="3"/>
+      <member word="constraints"  strength="1"/>
+    </concept>
+    <concept id="learning_word" is_a="forth_word">
+      <member word="learns"        strength="5"/>
+      <member word="statistical"   strength="3"/>
+      <member word="relationships" strength="5"/>
+      <member word="text"          strength="1"/>
+      <member word="cooccurrence"  strength="2"/>
+      <member word="pmi"           strength="2"/>
+      <member word="embeddings"    strength="6"/>
+      <member word="neural"        strength="3"/>
+      <member word="network"       strength="4"/>
+      <member word="capture"       strength="2"/>
+      <member word="similarity"    strength="1"/>
+    </concept>
+  </concepts>
+</ontology>

ontology_induced.xml

@@ -0,0 +1,31 @@
+<?xml version="1.0"?>
+<ontology name="PocketForthConcepts-Induced" derived_from="ILP">
+  <concepts>
+    <concept id="stack_op" is_a="forth_word" induced_context="drop" f1="0.60">
+      <induced_rule>is_a(W, stack_op) :- cooccur(W, 'drop').</induced_rule>
+      <member word="stack"      source="seed"    strength="8"/>
+      <member word="dup"        source="seed"    strength="4"/>
+      <member word="drop"       source="seed"    strength="3"/>
+      <member word="swap"       source="seed"    strength="3"/>
+      <member word="over"       source="seed"    strength="2"/>
+      <member word="include"    source="induced" strength="1" induced_by="drop"/>
+    </concept>
+    <concept id="compiler_word" is_a="forth_word" induced_context="semicolon" f1="0.75">
+      <induced_rule>is_a(W, compiler_word) :- cooccur(W, 'semicolon').</induced_rule>
+      <member word="compiler"  source="seed"    strength="2"/>
+      <member word="colon"     source="seed"    strength="2"/>
+      <member word="semicolon" source="seed"    strength="3"/>
+      <member word="defined"   source="induced" strength="1" induced_by="semicolon"/>
+    </concept>
+    <concept id="learning_word" is_a="forth_word" induced_context="statistical" f1="0.80">
+      <induced_rule>is_a(W, learning_word) :- cooccur(W, 'statistical').</induced_rule>
+      <member word="learns"        source="seed"    strength="5"/>
+      <member word="statistical"   source="seed"    strength="3"/>
+      <member word="relationships" source="seed"    strength="5"/>
+      <member word="embeddings"    source="seed"    strength="6"/>
+      <member word="neural"        source="seed"    strength="3"/>
+      <member word="network"       source="seed"    strength="4"/>
+      <member word="similarity"    source="induced" strength="1" induced_by="statistical"/>
+    </concept>
+  </concepts>
+</ontology>

ontology_induction_generated.pl

@@ -0,0 +1,143 @@
+:- dynamic member/2, induced_rule/2, cooccur/3.
+
+% --- Background co-occurrence facts (generated by XSLT from ontology.xml) ---
+cooccur('stack','stack_op',1).
+cooccur('dup','stack_op',3).
+cooccur('drop','stack_op',3).
+cooccur('swap','stack_op',3).
+cooccur('over','stack_op',2).
+cooccur('operations','stack_op',2).
+cooccur('dictionary','dict_op',2).
+cooccur('words','dict_op',3).
+cooccur('contains','dict_op',3).
+cooccur('holds','dict_op',0).
+cooccur('compiler','compiler_word',2).
+cooccur('compiles','compiler_word',2).
+cooccur('colon','compiler_word',2).
+cooccur('semicolon','compiler_word',3).
+cooccur('defined','compiler_word',1).
+cooccur('interpreter','interpreter_word',1).
+cooccur('interprets','interpreter_word',1).
+cooccur('pocketforth','engine_word',0).
+cooccur('engine','engine_word',2).
+cooccur('pocket','engine_word',1).
+cooccur('executes','engine_word',2).
+cooccur('inside','engine_word',1).
+cooccur('harness','engine_word',0).
+cooccur('transformer','meta_word',0).
+cooccur('xslt','meta_word',2).
+cooccur('asp','meta_word',3).
+cooccur('xml','meta_word',3).
+cooccur('code','meta_word',3).
+cooccur('generates','meta_word',2).
+cooccur('validates','meta_word',3).
+cooccur('architecture','meta_word',3).
+cooccur('constraints','meta_word',1).
+cooccur('learns','learning_word',5).
+cooccur('statistical','learning_word',3).
+cooccur('relationships','learning_word',5).
+cooccur('text','learning_word',1).
+cooccur('cooccurrence','learning_word',2).
+cooccur('pmi','learning_word',2).
+cooccur('embeddings','learning_word',6).
+cooccur('neural','learning_word',3).
+cooccur('network','learning_word',4).
+cooccur('capture','learning_word',2).
+cooccur('similarity','learning_word',1).
+
+% --- Concept hierarchy ---
+concept(forth_word).
+is_a(forth_word, root).
+concept(stack_op).       is_a(stack_op,       forth_word).
+concept(dict_op).        is_a(dict_op,        forth_word).
+concept(compiler_word).  is_a(compiler_word,  forth_word).
+concept(interpreter_word). is_a(interpreter_word, forth_word).
+concept(engine_word).    is_a(engine_word,    forth_word).
+concept(meta_word).      is_a(meta_word,      forth_word).
+concept(learning_word).  is_a(learning_word,  forth_word).
+
+% --- Seed members ---
+member('stack',       stack_op).
+member('dup',         stack_op).
+member('drop',        stack_op).
+member('swap',        stack_op).
+member('over',        stack_op).
+member('operations',  stack_op).
+member('dictionary',  dict_op).
+member('words',       dict_op).
+member('contains',    dict_op).
+member('compiler',    compiler_word).
+member('compiles',    compiler_word).
+member('colon',       compiler_word).
+member('semicolon',   compiler_word).
+member('defined',     compiler_word).
+member('interpreter', interpreter_word).
+member('interprets',  interpreter_word).
+member('pocketforth', engine_word).
+member('engine',      engine_word).
+member('pocket',      engine_word).
+member('executes',    engine_word).
+member('xslt',        meta_word).
+member('asp',         meta_word).
+member('xml',         meta_word).
+member('generates',   meta_word).
+member('validates',   meta_word).
+member('learns',      learning_word).
+member('statistical', learning_word).
+member('relationships', learning_word).
+member('embeddings',  learning_word).
+member('neural',      learning_word).
+member('network',     learning_word).
+
+% --- ILP Engine (generated by XSLT from ontology.xml) ---
+candidate_score(Concept, Context, Precision, Recall, F1, PosCovered) :-
+    findall(W, member(W, Concept), Pos),
+    length(Pos, PosTotal),
+    PosTotal > 0,
+    findall(W, (member(W, Concept), cooccur(W, Context, _)), Covered),
+    length(Covered, PosCovered),
+    findall(W, cooccur(W, Context, _), AllWithContext),
+    length(AllWithContext, AllTotal),
+    (AllTotal > 0 -> Precision is PosCovered / AllTotal ; Precision = 0),
+    Recall is PosCovered / PosTotal,
+    (Precision + Recall > 0 -> F1 is 2*Precision*Recall/(Precision+Recall) ; F1 = 0).
+
+best_rule_for_concept(Concept, BestContext, BestF1) :-
+    setof(Context, W^Cnt^cooccur(W, Context, Cnt), Contexts),
+    findall((F1,Context), candidate_score(Concept, Context, _, _, F1, _), Scores),
+    Scores \= [],
+    max_member((BestF1, BestContext), Scores).
+
+induce_rules :-
+    retractall(induced_rule(_,_)),
+    forall(concept(C),
+        ( best_rule_for_concept(C, Context, F1),
+          F1 > 0.2,
+          assertz(induced_rule(C, Context)),
+          format("Induced: is_a(W, ~w) :- cooccur(W, '~w'). F1=~2f~n", [C, Context, F1])
+        ; format("No rule for ~w (insufficient evidence)~n", [C])
+        )).
+
+propose_new_members :-
+    forall(
+        ( cooccur(W, Context, Cnt), Cnt >= 1,
+          induced_rule(Concept, Context),
+          \+ member(W, Concept),
+          \+ W = Concept ),
+        format("Propose: ~w should be is_a(~w) because cooccurs with '~w' cnt=~w~n",
+               [W, Concept, Context, Cnt])).
+
+generate_ontology_xml :-
+    format("<ontology name=\"Induced-Next\">~n"),
+    forall(concept(C),
+        ( induced_rule(C, Ctx),
+          format("  <concept id=\"~w\" is_a=\"forth_word\" induced_context=\"~w\">~n", [C, Ctx]),
+          forall(member(W,C), format("    <member word=\"~w\"/>~n", [W])),
+          format("  </concept>~n")
+        )),
+    format("</ontology>~n").
+
+:- format("=== PocketLearn ILP Induction (XSLT-generated from PocketForthConcepts) ===~n"),
+   induce_rules,
+   format("~n=== Proposing new members ===~n"),
+   propose_new_members.

ontology_to_asp.xslt

@@ -0,0 +1,13 @@
+<?xml version="1.0"?>
+<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+<xsl:output method="text"/>
+<!-- ontology_to_asp.xslt: XML -> ASP facts for clingo validation -->
+<xsl:template match="/ontology">
+% ASP facts from <xsl:value-of select="@name"/>
+<xsl:for-each select="concepts/concept">is_a("<xsl:value-of select="@id"/>", "<xsl:value-of select="@is_a"/>").
+</xsl:for-each>
+<xsl:for-each select="concepts/concept/member">member("<xsl:value-of select="@word"/>", "<xsl:value-of select="../@id"/>").
+word("<xsl:value-of select="@word"/>").
+</xsl:for-each>
+</xsl:template>
+</xsl:stylesheet>

ontology_to_induction.xslt

@@ -0,0 +1,58 @@
+<?xml version="1.0"?>
+<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+<xsl:output method="text"/>
+<!-- ontology_to_induction.xslt: XSLT that GENERATES the Prolog ILP engine.
+     Meta-trick: the system generates its own inference engine from ontology.xml.
+     ontology.xml --(this XSLT)--> ontology_induction_generated.pl --(swipl)--> induced rules -->
+<xsl:template match="/ontology">
+% === AUTO-GENERATED BY XSLT FROM <xsl:value-of select="@name"/> ===
+% File: ontology_induction_generated.pl
+% Pipeline: ontology.xml --(XSLT)--> induction.pl  ZERO PYTHON
+
+:- dynamic member/2, induced_rule/2, cooccur/3.
+
+% --- Background co-occurrence facts ---
+<xsl:for-each select="concepts/concept/member">cooccur('<xsl:value-of select="@word"/>','<xsl:value-of select="../@id"/>',<xsl:value-of select="@strength"/>).
+</xsl:for-each>
+% --- Concept list ---
+<xsl:for-each select="concepts/concept">concept(<xsl:value-of select="@id"/>).
+is_a(<xsl:value-of select="@id"/>, <xsl:value-of select="@is_a"/>).
+<xsl:for-each select="member">member('<xsl:value-of select="@word"/>', <xsl:value-of select="../@id"/>).
+</xsl:for-each>
+</xsl:for-each>
+
+% --- ILP Engine (pure Prolog, generated by XSLT) ---
+candidate_score(Concept, Context, Precision, Recall, F1, PosCovered) :-
+    findall(W, member(W, Concept), Pos), length(Pos, PosTotal), PosTotal > 0,
+    findall(W, (member(W, Concept), cooccur(W, Context, _)), Covered), length(Covered, PosCovered),
+    findall(W, cooccur(W, Context, _), All), length(All, AllTotal),
+    (AllTotal > 0 -> Precision is PosCovered / AllTotal ; Precision = 0),
+    Recall is PosCovered / PosTotal,
+    (Precision + Recall > 0 -> F1 is 2*Precision*Recall/(Precision+Recall) ; F1 = 0).
+
+best_rule_for_concept(Concept, BestContext, BestF1) :-
+    setof(Context, W^Cnt^cooccur(W, Context, Cnt), Contexts),
+    findall((F1,Context), candidate_score(Concept, Context, _, _, F1, _), Scores),
+    Scores \= [], max_member((BestF1, BestContext), Scores).
+
+induce_rules :-
+    retractall(induced_rule(_,_)),
+    forall(concept(C),
+        ( best_rule_for_concept(C, Context, F1), F1 > 0.2,
+          assertz(induced_rule(C, Context)),
+          format("Induced: is_a(W, ~w) :- cooccur(W, '~w'). F1=~2f~n", [C, Context, F1])
+        ; format("No rule for ~w (insufficient evidence)~n", [C])
+        )).
+
+propose_new_members :-
+    forall(
+        ( cooccur(W, Context, Cnt), Cnt >= 1,
+          induced_rule(Concept, Context),
+          \+ member(W, Concept), \+ W = Concept ),
+        format("Propose: ~w should be is_a(~w) because cooccurs with '~w' cnt=~w~n",
+               [W, Concept, Context, Cnt])).
+
+:- format("=== ILP Induction Generated by XSLT from ~w ===~n", ['<xsl:value-of select="@name"/>']),
+   induce_rules, format("~n=== Proposing ===~n"), propose_new_members.
+</xsl:template>
+</xsl:stylesheet>

sample_corpus.txt

@@ -0,0 +1,7 @@
+pocketforth is a pocket forth engine that executes inside a transformer harness.
+forth is stack based. stack operations include dup drop swap over.
+dictionary contains words are defined with colon and semicolon.
+compiler compiles words interpreter interprets words.
+learns statistical relationships in text xslt generates code from xml.
+asp validates architecture constraints cooccurrence pmi embeddings.
+neural network capture similarity transformer learns statistical relationships.

sgml_validator.mjs

@@ -0,0 +1,253 @@
+// pocketlearn/sgml_validator.mjs
+// Browser-native SGML structural validator
+// Validates documents against inline DTD rules before ILP induction.
+// Matches ISO 8879:1986 semantics for element presence and minimization.
+//
+// Connects to: claimguard.mjs (same oracle pattern)
+//              dsssl-synthesis.mjs (SGML grove parser)
+//              ontology.dtd, training_record.dtd, sovereign_prompt.dtd
+//
+// Ahmad Ali Parr -- Bel Esprit D'Accord Irrevocable Trust -- EIN 42-697643
+
+// ── DTD rule registry ─────────────────────────────────────────────────────────
+const DTD_RULES = {
+
+  // sovereign_prompt.dtd
+  system_prompt: {
+    required_children: ['identity', 'logic_gates', 'execution_flow'],
+    optional_children: [],
+    minimization: ['both_required', 'both_required'], // - -
+  },
+  logic_gates: {
+    required_children: ['gate'],
+    min_count: { gate: 1 },
+    minimization: ['both_required', 'both_required'],
+  },
+  gate: {
+    required_children: ['name', 'condition', 'action'],
+    optional_children: ['seal'],
+    minimization: ['both_required', 'both_required'],
+  },
+  seal: {
+    required_attrs: ['hash'],
+    fixed_attrs: { algo: 'SHA-256' },
+    content_model: 'EMPTY',
+    minimization: ['both_required', 'end_optional'], // - O
+  },
+
+  // ontology.dtd
+  ontology: {
+    required_attrs: ['name'],
+    required_children: ['concepts'],
+    minimization: ['both_required', 'both_required'],
+  },
+  concept: {
+    required_attrs: ['id', 'is_a'],
+    optional_children: ['member', 'induced_rule'],
+    minimization: ['both_required', 'both_required'],
+  },
+  member: {
+    required_attrs: ['word', 'strength'],
+    content_model: 'EMPTY',
+    minimization: ['both_required', 'end_optional'], // - O
+  },
+
+  // training_record.dtd
+  training_record: {
+    required_attrs: ['id', 'source_sha256', 'split', 'created_by', 'review_status', 'weight'],
+    required_children: ['meta', 'content'],
+    optional_children: ['flags', 'seal'],
+    minimization: ['both_required', 'both_required'],
+  },
+  content: {
+    required_children: ['instruction', 'output'],
+    optional_children: ['context'],
+    minimization: ['both_required', 'both_required'],
+  },
+}
+
+const VALID_SPLITS      = ['train', 'val', 'test', 'holdout']
+const CRITICAL_DOMAINS  = ['security', 'cryptography', 'formal_verification', 'systems_architecture']
+const HEDGE_PHRASES     = ['i think', 'probably', 'it seems', 'might be', 'could be', 'i believe']
+
+// ── Parse SGML to simple element tree (matches dsssl-synthesis.mjs pattern) ──
+
+function parseSGML(sgml) {
+  const stripDTD = sgml.replace(/<!DOCTYPE[\s\S]*?]>/i, '').trim()
+  const elements = []
+  const tagRe   = /<(\/?)([\w-]+)([^>]*)>/g
+  let match
+  const stack   = [{ name: 'root', children: [], attrs: {} }]
+
+  let lastIndex = 0
+  while ((match = tagRe.exec(stripDTD)) !== null) {
+    const [full, closing, name, attrsStr] = match
+    const text = stripDTD.slice(lastIndex, match.index).trim()
+    if (text) stack.at(-1).text = (stack.at(-1).text || '') + text
+
+    if (closing) {
+      const closed = stack.pop()
+      if (stack.length > 0) stack.at(-1).children.push(closed)
+    } else {
+      const attrs = {}
+      const attrRe = /([\w-]+)="([^"]*)"/g
+      let am
+      while ((am = attrRe.exec(attrsStr)) !== null) attrs[am[1]] = am[2]
+      const el = { name, attrs, children: [], text: '' }
+      // EMPTY elements don't get pushed (self-closing equivalent in SGML)
+      const rule = DTD_RULES[name]
+      if (rule?.content_model === 'EMPTY') {
+        stack.at(-1).children.push(el)
+      } else {
+        stack.push(el)
+      }
+    }
+    lastIndex = tagRe.lastIndex
+  }
+  while (stack.length > 1) {
+    const el = stack.pop()
+    stack.at(-1).children.push(el)
+  }
+  return stack[0].children[0] || null
+}
+
+// ── DTD validation ────────────────────────────────────────────────────────────
+
+function validateElement(el, errors = []) {
+  if (!el) return errors
+  const rule = DTD_RULES[el.name]
+  if (!rule) return errors  // no rule = permissive pass
+
+  // Check required attributes
+  if (rule.required_attrs) {
+    for (const attr of rule.required_attrs) {
+      if (!el.attrs[attr]) {
+        errors.push(`SGML: element <${el.name}> missing required attribute "${attr}" (#REQUIRED)`)
+      }
+    }
+  }
+
+  // Check fixed attributes
+  if (rule.fixed_attrs) {
+    for (const [attr, val] of Object.entries(rule.fixed_attrs)) {
+      if (el.attrs[attr] && el.attrs[attr] !== val) {
+        errors.push(`SGML: <${el.name}> attribute "${attr}" must be #FIXED "${val}", got "${el.attrs[attr]}"`)
+      }
+    }
+  }
+
+  // Check required children
+  if (rule.required_children) {
+    const childNames = el.children.map(c => c.name)
+    for (const req of rule.required_children) {
+      if (!childNames.includes(req)) {
+        errors.push(`SGML: element <${el.name}> missing required child <${req}> (minimization: - -)`)
+      }
+    }
+  }
+
+  // Check minimum counts
+  if (rule.min_count) {
+    for (const [child, min] of Object.entries(rule.min_count)) {
+      const count = el.children.filter(c => c.name === child).length
+      if (count < min) {
+        errors.push(`SGML: <${el.name}> requires at least ${min} <${child}> element(s), found ${count}`)
+      }
+    }
+  }
+
+  // Check content model EMPTY
+  if (rule.content_model === 'EMPTY' && el.children.length > 0) {
+    errors.push(`SGML: <${el.name}> has EMPTY content model but contains children`)
+  }
+
+  // Recurse
+  for (const child of el.children) validateElement(child, errors)
+  return errors
+}
+
+// ── Claim oracle (matches claimguard.mjs z3OracleCheck) ───────────────────────
+
+function oracleCheck(content) {
+  const lower = content.toLowerCase()
+  for (const hedge of HEDGE_PHRASES) {
+    if (lower.includes(hedge)) {
+      return { valid: false, reason: `Oracle: hedge phrase detected: "${hedge}"` }
+    }
+  }
+  if (!content.trim()) {
+    return { valid: false, reason: 'Oracle: empty content rejected' }
+  }
+  return { valid: true, reason: 'Structural + oracle check passed' }
+}
+
+// ── Main validator ────────────────────────────────────────────────────────────
+
+export function validateSGML(sgml, doctype = 'auto') {
+  const el     = parseSGML(sgml)
+  const errors = validateElement(el)
+
+  // Oracle check on text content
+  const textContent = sgml.replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim()
+  const oracle      = oracleCheck(textContent)
+  if (!oracle.valid) errors.push(oracle.reason)
+
+  return {
+    valid:   errors.length === 0,
+    errors,
+    element: el?.name || 'unknown',
+    oracle:  oracle.valid
+  }
+}
+
+// Training record specific validator (mirrors transformer.dl plasma_pass)
+export function validateTrainingRecord(record) {
+  const errors = []
+
+  if (!record.id)            errors.push('SGML: training_record missing id (#REQUIRED)')
+  if (!record.source_sha256) errors.push('SGML: training_record missing source_sha256 (#REQUIRED)')
+  if (!VALID_SPLITS.includes(record.split))
+    errors.push(`SGML: invalid split "${record.split}" — must be (train|val|test|holdout)`)
+  if (!record.created_by)    errors.push('SGML: training_record missing created_by (#REQUIRED)')
+  if (!record.review_status) errors.push('SGML: training_record missing review_status (#REQUIRED)')
+
+  const weight = parseFloat(record.weight)
+  if (isNaN(weight) || weight <= 0 || weight > 1)
+    errors.push(`SGML: weight="${record.weight}" out of range (0, 1]`)
+
+  // Critical domain inaccuracy check (mirrors transformer.dl has_critical_inaccuracy)
+  if (record.inaccuracies) {
+    for (const inc of record.inaccuracies) {
+      if (CRITICAL_DOMAINS.includes(inc.domain)) {
+        errors.push(`SGML: critical domain inaccuracy in "${inc.domain}": ${inc.reason}`)
+      }
+    }
+  }
+
+  return { valid: errors.length === 0, errors }
+}
+
+// ── Encode as SGML (matches claimguard.mjs encodeAsSgml) ──────────────────────
+
+export function encodeAsSGML(obj, doctype = 'record') {
+  const esc = s => String(s)
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+
+  const lines = [
+    `<!DOCTYPE ${doctype} [`,
+    `  <!ELEMENT ${doctype} - - (` + Object.keys(obj).join(', ') + `)>`,
+  ]
+  for (const [k, v] of Object.entries(obj)) {
+    lines.push(`  <!ELEMENT ${k} - - (#PCDATA)>`)
+  }
+  lines.push(`]>`)
+  lines.push(`<${doctype}>`)
+  for (const [k, v] of Object.entries(obj)) {
+    lines.push(`  <${k}>${esc(v)}</${k}>`)
+  }
+  lines.push(`</${doctype}>`)
+  return lines.join('\n')
+}