elp(multilingual): native-el language layer — detect + localized phrases

Phase 3 piece 2. Ports multilingual.py: deterministic language detection
(en/es/pt/it) via stopword + diacritic scoring, localized fixed phrases (SACRED
per-language yes/no/decline/identity), PT/ES->EN retrieval term lexicon, and
EN->target predicate translation. No generative model.

Gate (multilingual_gate.el): 4/4 languages detected correctly; localized
declines + term/pred lexicons verified. Built bounded (elc rc=0 peak 25MB).

Worked through the documented el '+' mis-compile (two chained function-call Int
operands compile as string concat -> corrupt Int -> segfault on the accented
path); fixed by binding each score to an Int var and adding vars singly.

Simplifications (honest): diacritics scored by PRESENCE (str_contains) not
codepoint count (UTF-8 index safety); confidence scalar and the regex-based
parse_directive() from the reference not yet ported (directive parsing deferred
to the dialogue layer).

elp/manifest.el

@@ -80,6 +80,9 @@ build {
         "src/grammar.el",
         "src/realizer.el",
         "src/semantics.el",
+        "src/comprehend.el",
+        "src/propositions.el",
+        "src/multilingual.el",
         "src/elp.el",
     ]
 }

elp/src/comprehend.elh

@@ -0,0 +1,16 @@
+// comprehend.elh — public surface of the ELP comprehension front-end.
+// text → meaning-spec (the input half of the ELP; inverse of the realizer).
+extern fn parse_spec(text: String) -> [String]
+extern fn parse_spec_lang(text: String, lang: String) -> [String]
+extern fn parse_json(text: String) -> String
+extern fn parse_json_lang(text: String, lang: String) -> String
+// Analysis primitives (invertible morphology + deterministic grammar helpers):
+extern fn cp_tokenize(text: String) -> [String]
+extern fn cp_pron_concept(w: String) -> String
+extern fn cp_is_negation(w: String) -> Bool
+extern fn cp_is_neg_adverb(w: String) -> Bool
+extern fn cp_irr2(surface: String) -> [String]
+extern fn cp_reg_verb(w: String) -> [String]
+extern fn cp_analyze_verb(surface: String) -> [String]
+extern fn cp_verb_start(toks: [String], end: Int) -> Int
+extern fn cp_subord_start(toks: [String], n: Int) -> Int

elp/src/elp.el

@@ -63,6 +63,9 @@ import "morphology-cop.el"
 import "grammar.el"
 import "realizer.el"
 import "semantics.el"
+
+// ── Comprehension front-end (input half: text → meaning-spec) ─────────────────
+import "comprehend.el"
 //
 // Entry points:
 //
@@ -117,6 +120,9 @@ fn build_form_from_json(semantic_form_json: String, lang_code: String) -> [Strin
     let location: String  = sem_get(semantic_form_json, "location")
     let tense: String     = sem_get(semantic_form_json, "tense")
     let aspect: String    = sem_get(semantic_form_json, "aspect")
+    let polarity: String  = sem_get(semantic_form_json, "polarity")
+    let neg_word: String  = sem_get(semantic_form_json, "neg_word")
+    let iobj: String      = sem_get(semantic_form_json, "iobj")
 
     let form: [String] = native_list_empty()
     let form = native_list_append(form, "intent")
@@ -127,12 +133,19 @@ fn build_form_from_json(semantic_form_json: String, lang_code: String) -> [Strin
     let form = native_list_append(form, predicate)
     let form = native_list_append(form, "patient")
     let form = native_list_append(form, patient)
+    let form = native_list_append(form, "iobj")
+    let form = native_list_append(form, iobj)
     let form = native_list_append(form, "location")
     let form = native_list_append(form, location)
     let form = native_list_append(form, "tense")
     let form = native_list_append(form, tense)
     let form = native_list_append(form, "aspect")
     let form = native_list_append(form, aspect)
+    // SACRED: polarity crosses the JSON boundary and is never inferred away.
+    let form = native_list_append(form, "polarity")
+    let form = native_list_append(form, polarity)
+    let form = native_list_append(form, "neg_word")
+    let form = native_list_append(form, neg_word)
     let form = native_list_append(form, "lang")
     let form = native_list_append(form, lang_code)
 

elp/src/morphology.el

@@ -250,6 +250,7 @@ fn en_irregular_verb(base: String) -> [String] {
     if str_eq(base, "cut")     { let r: [String] = ["cut",    "cuts",  "cut",    "cut",     "cutting"];  return r }
     if str_eq(base, "set")     { let r: [String] = ["set",    "sets",  "set",    "set",     "setting"];  return r }
     if str_eq(base, "hit")     { let r: [String] = ["hit",    "hits",  "hit",    "hit",     "hitting"];  return r }
+    if str_eq(base, "fight")   { let r: [String] = ["fight",  "fights","fought", "fought",  "fighting"]; return r }
     return empty
 }
 

elp/src/multilingual.el

@@ -0,0 +1,280 @@
+// multilingual.el - the language layer for the native-el interlocutor.
+//
+// Deterministic, NO generative model (ports multilingual.py):
+//   1. ml_detect(text)          -> ISO code  (en/es/pt/it) via stopword + diacritic score
+//   2. ml_tr(key, lang)         -> localized fixed phrase (SACRED per-language yes/no/decline)
+//   3. ml_term(w, lang)         -> PT/ES content term -> EN engram equivalent
+//   4. ml_translate_pred(lemma, lang) -> EN predicate lemma -> target infinitive
+//
+// The Python detector count-weights stopwords and diacritics; here diacritics are
+// scored by PRESENCE (str_contains) rather than codepoint counting, to stay clear
+// of UTF-8 index hazards in the runtime. Faithful enough to classify typical
+// queries; documented simplification.  Depends on: comprehend (cp_tokenize).
+
+// ── 1. language detection ─────────────────────────────────────────────────────
+
+fn ml_stop_en(w: String) -> Bool {
+    if str_eq(w, "the") { return true }
+    if str_eq(w, "does") { return true }
+    if str_eq(w, "do") { return true }
+    if str_eq(w, "did") { return true }
+    if str_eq(w, "what") { return true }
+    if str_eq(w, "who") { return true }
+    if str_eq(w, "is") { return true }
+    if str_eq(w, "are") { return true }
+    if str_eq(w, "how") { return true }
+    if str_eq(w, "you") { return true }
+    if str_eq(w, "your") { return true }
+    if str_eq(w, "of") { return true }
+    if str_eq(w, "to") { return true }
+    if str_eq(w, "and") { return true }
+    if str_eq(w, "for") { return true }
+    if str_eq(w, "explain") { return true }
+    if str_eq(w, "answer") { return true }
+    if str_eq(w, "memory") { return true }
+    if str_eq(w, "with") { return true }
+    if str_eq(w, "not") { return true }
+    if str_eq(w, "store") { return true }
+    return false
+}
+
+fn ml_stop_es(w: String) -> Bool {
+    if str_eq(w, "que") { return true }
+    if str_eq(w, "qué") { return true }
+    if str_eq(w, "una") { return true }
+    if str_eq(w, "usted") { return true }
+    if str_eq(w, "su") { return true }
+    if str_eq(w, "cómo") { return true }
+    if str_eq(w, "como") { return true }
+    if str_eq(w, "cuál") { return true }
+    if str_eq(w, "quién") { return true }
+    if str_eq(w, "está") { return true }
+    if str_eq(w, "es") { return true }
+    if str_eq(w, "los") { return true }
+    if str_eq(w, "las") { return true }
+    if str_eq(w, "del") { return true }
+    if str_eq(w, "al") { return true }
+    if str_eq(w, "explica") { return true }
+    if str_eq(w, "explique") { return true }
+    if str_eq(w, "forma") { return true }
+    if str_eq(w, "con") { return true }
+    if str_eq(w, "memoria") { return true }
+    if str_eq(w, "responde") { return true }
+    return false
+}
+
+fn ml_stop_pt(w: String) -> Bool {
+    if str_eq(w, "que") { return true }
+    if str_eq(w, "uma") { return true }
+    if str_eq(w, "você") { return true }
+    if str_eq(w, "sua") { return true }
+    if str_eq(w, "seu") { return true }
+    if str_eq(w, "como") { return true }
+    if str_eq(w, "memória") { return true }
+    if str_eq(w, "isso") { return true }
+    if str_eq(w, "os") { return true }
+    if str_eq(w, "as") { return true }
+    if str_eq(w, "da") { return true }
+    if str_eq(w, "do") { return true }
+    if str_eq(w, "na") { return true }
+    if str_eq(w, "no") { return true }
+    if str_eq(w, "explica") { return true }
+    if str_eq(w, "forma") { return true }
+    if str_eq(w, "é") { return true }
+    if str_eq(w, "está") { return true }
+    if str_eq(w, "com") { return true }
+    if str_eq(w, "responda") { return true }
+    return false
+}
+
+fn ml_stop_it(w: String) -> Bool {
+    if str_eq(w, "che") { return true }
+    if str_eq(w, "una") { return true }
+    if str_eq(w, "come") { return true }
+    if str_eq(w, "della") { return true }
+    if str_eq(w, "gli") { return true }
+    if str_eq(w, "è") { return true }
+    if str_eq(w, "sono") { return true }
+    if str_eq(w, "questo") { return true }
+    if str_eq(w, "nel") { return true }
+    if str_eq(w, "di") { return true }
+    if str_eq(w, "il") { return true }
+    if str_eq(w, "cosa") { return true }
+    if str_eq(w, "per") { return true }
+    if str_eq(w, "memoria") { return true }
+    if str_eq(w, "spiega") { return true }
+    if str_eq(w, "rispondi") { return true }
+    return false
+}
+
+// diacritic PRESENCE score (weight 3 each; hard overrides weight 8).
+fn ml_dia_score(low: String, lang: String) -> Int {
+    let s: Int = 0
+    if str_eq(lang, "pt") {
+        if str_contains(low, "ã") { let s = s + 3 }
+        if str_contains(low, "õ") { let s = s + 3 }
+        if str_contains(low, "ç") { let s = s + 3 }
+        if str_contains(low, "ê") { let s = s + 3 }
+        if str_contains(low, "á") { let s = s + 3 }
+        // hard PT markers (ã/õ almost never appear outside PT)
+        if str_contains(low, "ã") { let s = s + 8 }
+        if str_contains(low, "õ") { let s = s + 8 }
+    }
+    if str_eq(lang, "es") {
+        if str_contains(low, "ñ") { let s = s + 3 }
+        if str_contains(low, "¿") { let s = s + 3 }
+        if str_contains(low, "¡") { let s = s + 3 }
+        if str_contains(low, "á") { let s = s + 3 }
+        if str_contains(low, "é") { let s = s + 3 }
+        // hard ES markers
+        if str_contains(low, "ñ") { let s = s + 8 }
+        if str_contains(low, "¿") { let s = s + 8 }
+        if str_contains(low, "¡") { let s = s + 8 }
+    }
+    if str_eq(lang, "it") {
+        if str_contains(low, "è") { let s = s + 3 }
+        if str_contains(low, "ì") { let s = s + 3 }
+        if str_contains(low, "ò") { let s = s + 3 }
+    }
+    return s
+}
+
+fn ml_stop_score(toks: [String], lang: String) -> Int {
+    let n: Int = native_list_len(toks)
+    let s: Int = 0
+    let i: Int = 0
+    while i < n {
+        let w: String = native_list_get(toks, i)
+        if str_eq(lang, "en") { if ml_stop_en(w) { let s = s + 2 } }
+        if str_eq(lang, "es") { if ml_stop_es(w) { let s = s + 2 } }
+        if str_eq(lang, "pt") { if ml_stop_pt(w) { let s = s + 2 } }
+        if str_eq(lang, "it") { if ml_stop_it(w) { let s = s + 2 } }
+        let i = i + 1
+    }
+    return s
+}
+
+fn ml_detect(text: String) -> String {
+    if str_eq(text, "") { return "en" }
+    let low: String = str_to_lower(text)
+    let toks: [String] = cp_tokenize(text)
+    // NOTE: el's overloaded `+` mis-compiles two chained function-call Int operands
+    // as string concat (documented in comprehend_gate.el). Bind each call to an Int
+    // var and add vars one at a time so the addition stays integer.
+    let en: Int = ml_stop_score(toks, "en")
+    let es_s: Int = ml_stop_score(toks, "es")
+    let es_d: Int = ml_dia_score(low, "es")
+    let es: Int = es_s + es_d
+    let pt_s: Int = ml_stop_score(toks, "pt")
+    let pt_d: Int = ml_dia_score(low, "pt")
+    let pt: Int = pt_s + pt_d
+    let it_s: Int = ml_stop_score(toks, "it")
+    let it_d: Int = ml_dia_score(low, "it")
+    let it: Int = it_s + it_d
+
+    let best: String = "en"
+    let bs: Int = en
+    if es > bs { let best = "es"; let bs = es }
+    if pt > bs { let best = "pt"; let bs = pt }
+    if it > bs { let best = "it"; let bs = it }
+    // weak signal -> honest fallback to English
+    if bs < 3 { return "en" }
+    return best
+}
+
+// ── 2. localized fixed phrases (SACRED per-language decline/yes/no) ────────────
+
+fn ml_tr(key: String, lang: String) -> String {
+    if str_eq(key, "no_memory") {
+        if str_eq(lang, "pt") { return "Não tenho isso na minha memória." }
+        if str_eq(lang, "es") { return "No tengo eso en mi memoria." }
+        if str_eq(lang, "it") { return "Non ho quello nella mia memoria." }
+        return "I don't have that in my memory."
+    }
+    if str_eq(key, "parse_fail") {
+        if str_eq(lang, "pt") { return "Não consegui interpretar isso." }
+        if str_eq(lang, "es") { return "No pude interpretar eso." }
+        if str_eq(lang, "it") { return "Non sono riuscito a interpretarlo." }
+        return "I didn't parse that."
+    }
+    if str_eq(key, "yes") {
+        if str_eq(lang, "pt") { return "Sim" }
+        if str_eq(lang, "es") { return "Sí" }
+        if str_eq(lang, "it") { return "Sì" }
+        return "Yes"
+    }
+    if str_eq(key, "no") {
+        if str_eq(lang, "pt") { return "Não" }
+        if str_eq(lang, "es") { return "No" }
+        if str_eq(lang, "it") { return "No" }
+        return "No"
+    }
+    if str_eq(key, "identity") {
+        if str_eq(lang, "pt") { return "Sou o Neuron, o engrama com quem você está falando." }
+        if str_eq(lang, "es") { return "Soy Neuron, el engrama con el que estás hablando." }
+        if str_eq(lang, "it") { return "Sono Neuron, l'engramma con cui stai parlando." }
+        return "I'm Neuron, the engram you're speaking with."
+    }
+    return ""
+}
+
+// ── 3. retrieval term lexicon (PT/ES content term -> EN engram equivalent) ─────
+
+fn ml_term(w: String, lang: String) -> String {
+    if str_eq(lang, "en") { return w }
+    if str_eq(w, "saliência") { return "salience" }
+    if str_eq(w, "saliencia") { return "salience" }
+    if str_eq(w, "memória") { return "memory" }
+    if str_eq(w, "memoria") { return "memory" }
+    if str_eq(w, "geometria") { return "geometry" }
+    if str_eq(w, "geometrias") { return "geometry" }
+    if str_eq(w, "geometrías") { return "geometry" }
+    if str_eq(w, "forma") { return "form" }
+    if str_eq(w, "consolidação") { return "consolidation" }
+    if str_eq(w, "consolidación") { return "consolidation" }
+    if str_eq(w, "aprendizagem") { return "learning" }
+    if str_eq(w, "aprendizaje") { return "learning" }
+    if str_eq(w, "nó") { return "node" }
+    if str_eq(w, "nodo") { return "node" }
+    if str_eq(w, "armazenamento") { return "storage" }
+    if str_eq(w, "almacenamiento") { return "storage" }
+    if str_eq(w, "estrutura") { return "structure" }
+    if str_eq(w, "estructura") { return "structure" }
+    return w
+}
+
+// ── 4. predicate translation (EN lemma -> target infinitive; pass-through) ─────
+
+fn ml_translate_pred(lemma: String, lang: String) -> String {
+    if str_eq(lang, "en") { return lemma }
+    if str_eq(lang, "es") {
+        if str_eq(lemma, "store") { return "almacenar" }
+        if str_eq(lemma, "use") { return "usar" }
+        if str_eq(lemma, "have") { return "tener" }
+        if str_eq(lemma, "be") { return "ser" }
+        if str_eq(lemma, "give") { return "dar" }
+        if str_eq(lemma, "make") { return "hacer" }
+        if str_eq(lemma, "learn") { return "aprender" }
+        if str_eq(lemma, "form") { return "formar" }
+        return lemma
+    }
+    if str_eq(lang, "pt") {
+        if str_eq(lemma, "store") { return "armazenar" }
+        if str_eq(lemma, "use") { return "usar" }
+        if str_eq(lemma, "have") { return "ter" }
+        if str_eq(lemma, "be") { return "ser" }
+        if str_eq(lemma, "give") { return "dar" }
+        if str_eq(lemma, "make") { return "fazer" }
+        if str_eq(lemma, "learn") { return "aprender" }
+        if str_eq(lemma, "form") { return "formar" }
+        return lemma
+    }
+    if str_eq(lang, "it") {
+        if str_eq(lemma, "store") { return "memorizzare" }
+        if str_eq(lemma, "use") { return "usare" }
+        if str_eq(lemma, "have") { return "avere" }
+        if str_eq(lemma, "be") { return "essere" }
+        return lemma
+    }
+    return lemma
+}

elp/src/propositions.el

@@ -0,0 +1,140 @@
+// propositions.el - the READ primitive over the engram's OWN memories, native el.
+//
+// Free memory text -> structured PROPOSITIONS (triples):
+//     (subject, predicate, object, modifiers, polarity, tense, source, confidence)
+//
+// This is comprehension turned inward: the Python reference (propositions.py) ran
+// spaCy's dependency parser over each memory sentence and walked the arcs. Here
+// the spaCy role is filled by the el-native parser (comprehend.el / parse_spec):
+// each sentence is parsed to a meaning-spec, and the spec's roles ARE the triple.
+// Nothing generates text. NEGATION IS SACRED: polarity flows straight from the
+// spec's polarity field and is never dropped or inverted.
+//
+// Depends on: comprehend (parse_spec / parse_spec_lang), grammar (slots_get).
+
+// ── sentence segmentation ─────────────────────────────────────────────────────
+// Split on sentence-final punctuation (. ! ?) and hard newlines. Markdown/long
+// memories are handled shallowly (the reference caps + ranks by query overlap;
+// that ranking belongs to the dialogue layer, not here).
+
+fn prop_is_boundary(c: String) -> Bool {
+    if str_eq(c, ".") { return true }
+    if str_eq(c, "!") { return true }
+    if str_eq(c, "?") { return true }
+    if str_eq(c, "\n") { return true }
+    return false
+}
+
+fn prop_split_sentences(text: String) -> [String] {
+    let out: [String] = native_list_empty()
+    let n: Int = str_len(text)
+    let start: Int = 0
+    let i: Int = 0
+    while i < n {
+        let c: String = str_slice(text, i, i + 1)
+        if prop_is_boundary(c) {
+            let seg: String = str_slice(text, start, i + 1)
+            let trimmed: String = cp_trim_punct(seg)
+            if !str_eq(trimmed, "") {
+                let out = native_list_append(out, seg)
+            }
+            let start = i + 1
+        }
+        let i = i + 1
+    }
+    if start < n {
+        let seg: String = str_slice(text, start, n)
+        let trimmed: String = cp_trim_punct(seg)
+        if !str_eq(trimmed, "") {
+            let out = native_list_append(out, seg)
+        }
+    }
+    return out
+}
+
+// ── spec -> proposition record ────────────────────────────────────────────────
+// A proposition is a slot map (same [String] shape as the spec) with the READ
+// contract keys. Modifiers fold the spec's location + iobj adjuncts.
+
+fn prop_confidence(subject: String, predicate: String, object: String) -> String {
+    if str_eq(predicate, "") { return "0.0" }
+    if str_eq(subject, "") { return "0.4" }
+    if str_eq(object, "") { return "0.7" }
+    return "1.0"
+}
+
+fn prop_modifiers(spec: [String]) -> String {
+    let loc: String = slots_get(spec, "location")
+    let iobj: String = slots_get(spec, "iobj")
+    let parts: [String] = native_list_empty()
+    if !str_eq(loc, "") { let parts = native_list_append(parts, loc) }
+    if !str_eq(iobj, "") { let parts = native_list_append(parts, "to " + iobj) }
+    return str_join(parts, "; ")
+}
+
+fn prop_from_spec(spec: [String], source_id: String) -> [String] {
+    let subject: String   = slots_get(spec, "agent")
+    let predicate: String = slots_get(spec, "predicate")
+    let object: String    = slots_get(spec, "patient")
+    let polarity: String  = slots_get(spec, "polarity")
+    let tense: String     = slots_get(spec, "tense")
+    let mods: String      = prop_modifiers(spec)
+    let conf: String      = prop_confidence(subject, predicate, object)
+
+    let p: [String] = native_list_empty()
+    let p = native_list_append(p, "subject");    let p = native_list_append(p, subject)
+    let p = native_list_append(p, "predicate");  let p = native_list_append(p, predicate)
+    let p = native_list_append(p, "object");     let p = native_list_append(p, object)
+    let p = native_list_append(p, "modifiers");  let p = native_list_append(p, mods)
+    let p = native_list_append(p, "polarity");   let p = native_list_append(p, polarity)
+    let p = native_list_append(p, "tense");      let p = native_list_append(p, tense)
+    let p = native_list_append(p, "source");     let p = native_list_append(p, source_id)
+    let p = native_list_append(p, "confidence"); let p = native_list_append(p, conf)
+    return p
+}
+
+// Extract one proposition from a single sentence (given language).
+fn prop_extract_one_lang(sentence: String, lang: String, source_id: String) -> [String] {
+    let spec: [String] = parse_spec_lang(sentence, lang)
+    return prop_from_spec(spec, source_id)
+}
+
+fn prop_extract_one(sentence: String, source_id: String) -> [String] {
+    return prop_extract_one_lang(sentence, "en", source_id)
+}
+
+// Render a proposition as a compact trace line (repr parity with propositions.py).
+fn prop_repr(p: [String]) -> String {
+    let neg: String = ""
+    if str_eq(slots_get(p, "polarity"), "neg") { let neg = "NOT " }
+    let mods: String = slots_get(p, "modifiers")
+    let modstr: String = ""
+    if !str_eq(mods, "") { let modstr = " [" + mods + "]" }
+    let s: String = "(" + slots_get(p, "subject") + " -" + neg + slots_get(p, "predicate")
+    let s = s + "-> " + slots_get(p, "object") + modstr
+    let s = s + " conf=" + slots_get(p, "confidence") + ")"
+    return s
+}
+
+// Extract all propositions from a memory's text (one per sentence). Returns a
+// flat [String] whose entries are the prop_repr trace lines, in reading order.
+fn prop_extract_lang(text: String, lang: String, source_id: String) -> [String] {
+    let sents: [String] = prop_split_sentences(text)
+    let m: Int = native_list_len(sents)
+    let out: [String] = native_list_empty()
+    let i: Int = 0
+    while i < m {
+        let sent: String = native_list_get(sents, i)
+        let p: [String] = prop_extract_one_lang(sent, lang, source_id)
+        // drop empty parses (no predicate recovered): honest partial, not noise.
+        if !str_eq(slots_get(p, "predicate"), "") {
+            let out = native_list_append(out, prop_repr(p))
+        }
+        let i = i + 1
+    }
+    return out
+}
+
+fn prop_extract(text: String, source_id: String) -> [String] {
+    return prop_extract_lang(text, "en", source_id)
+}

elp/src/realizer.el

@@ -248,6 +248,56 @@ fn add_punct(s: String, intent: String) -> String {
     return s + "."
 }
 
+// ── Polarity-aware negation (SACRED field honored on the generation side) ─────
+//
+// Negation must never be dropped between comprehension and realization.  The
+// meaning-spec carries an explicit "polarity" field ("aff"|"neg") and optional
+// "neg_word" (standalone negative adverb, e.g. "never").  English uses
+// do-support ("did not see") or preverbal adverb ("never fought"); copular "be"
+// takes post-verbal "not"; other languages get a preverbal negator particle.
+
+fn realize_negator(code: String) -> String {
+    if str_eq(code, "es") { return "no" }
+    if str_eq(code, "pt") { return "não" }
+    if str_eq(code, "ca") { return "no" }
+    if str_eq(code, "it") { return "non" }
+    if str_eq(code, "fr") { return "ne" }
+    if str_eq(code, "de") { return "nicht" }
+    if str_eq(code, "ro") { return "nu" }
+    return "not"
+}
+
+fn realize_assert_neg_en(predicate: String, tense: String, person: String, number: String, agent: String, patient: String, iobj: String, location: String, neg_word: String, profile: [String]) -> String {
+    let parts: [String] = native_list_empty()
+    let parts = native_list_append(parts, agent)
+    if !str_eq(neg_word, "") {
+        // adverbial negation: "I never fought the ocean."
+        let verb_surf: String = morph_conjugate(predicate, tense, person, number, profile)
+        let parts = native_list_append(parts, neg_word)
+        let parts = native_list_append(parts, verb_surf)
+    } else {
+        if str_eq(predicate, "be") {
+            // copular: "she was not a monster"
+            let be_form: String = morph_conjugate("be", tense, person, number, profile)
+            let parts = native_list_append(parts, be_form)
+            let parts = native_list_append(parts, "not")
+        } else {
+            // do-support: "she did not see the man"
+            let do_form: String = morph_conjugate("do", tense, person, number, profile)
+            let parts = native_list_append(parts, do_form)
+            let parts = native_list_append(parts, "not")
+            let parts = native_list_append(parts, predicate)
+        }
+    }
+    if !str_eq(patient, "")  { let parts = native_list_append(parts, patient) }
+    if !str_eq(iobj, "") {
+        let parts = native_list_append(parts, "to")
+        let parts = native_list_append(parts, iobj)
+    }
+    if !str_eq(location, "") { let parts = native_list_append(parts, location) }
+    return str_join(parts, " ")
+}
+
 // ── Main realization entry point ──────────────────────────────────────────────
 
 fn realize_lang(form: [String], profile: [String]) -> String {
@@ -284,6 +334,36 @@ fn realize_lang(form: [String], profile: [String]) -> String {
     }
 
     // ── Assertion (declarative) ───────────────────────────────────────────────
+    let polarity: String = slots_get(form, "polarity")
+    let neg_word: String = slots_get(form, "neg_word")
+    let iobj: String     = slots_get(form, "iobj")
+    let code: String     = lang_get(profile, "code")
+
+    // Negative polarity: SACRED — never dropped.
+    if str_eq(polarity, "neg") {
+        if str_eq(code, "en") {
+            let sentence: String = realize_assert_neg_en(predicate, tense, person, number, agent, patient, iobj, location, neg_word, profile)
+            return add_punct(capitalize_first(sentence), "assert")
+        }
+        // Generic non-English: affirmative core with a preverbal negator particle.
+        let neg_particle: String = realize_negator(code)
+        let vp_pair: [String] = realize_vp_lang(predicate, tense, aspect, person, number, profile)
+        let verb_surf: String = native_list_get(vp_pair, 0)
+        let aux_surf: String  = native_list_get(vp_pair, 1)
+        let vp_str: String    = neg_particle + " " + gram_build_vp(verb_surf, aux_surf, profile)
+        let core: String      = gram_order_constituents(agent, vp_str, patient, profile)
+        let parts: [String]   = native_list_empty()
+        let parts = native_list_append(parts, core)
+        if !str_eq(iobj, "") {
+            let parts = native_list_append(parts, "to")
+            let parts = native_list_append(parts, iobj)
+        }
+        if !str_eq(location, "") { let parts = native_list_append(parts, location) }
+        let sentence: String = str_join(parts, " ")
+        return add_punct(capitalize_first(sentence), "assert")
+    }
+
+    // Affirmative.
     let vp_pair: [String] = realize_vp_lang(predicate, tense, aspect, person, number, profile)
     let verb_surf: String = native_list_get(vp_pair, 0)
     let aux_surf: String  = native_list_get(vp_pair, 1)
@@ -293,6 +373,10 @@ fn realize_lang(form: [String], profile: [String]) -> String {
 
     let parts: [String] = native_list_empty()
     let parts = native_list_append(parts, core)
+    if !str_eq(iobj, "") {
+        let parts = native_list_append(parts, "to")
+        let parts = native_list_append(parts, iobj)
+    }
     if !str_eq(location, "") {
         let parts = native_list_append(parts, location)
     }

elp/tests/comprehend_gate.el

@@ -0,0 +1,93 @@
+// comprehend_gate.el - the TELEPHONE TEST in native el (acceptance gate).
+//
+// For each of the 5 acceptance sentences: parse -> spec, realize the spec back
+// to English, re-parse the realized surface, and require the SACRED polarity to
+// survive the round-trip (and to have been extracted correctly in the first
+// place).  Mirrors roundtrip.py's GATE, but fully el-native (no LLM, no spaCy).
+
+fn cp_line(text: String, expected_pol: String) -> String {
+    let spec: [String] = parse_spec(text)
+    let pol_in: String = slots_get(spec, "polarity")
+    let pred: String = slots_get(spec, "predicate")
+    let surf: String = realize(spec)
+    let spec2: [String] = parse_spec(surf)
+    let pol_out: String = slots_get(spec2, "polarity")
+    let status: String = "LOST"
+    if str_eq(pol_in, pol_out) { let status = "PRESERVED" }
+    let okexp: String = "MISMATCH"
+    if str_eq(pol_in, expected_pol) { let okexp = "ok" }
+    let out: String = "IN:  " + text + "\n"
+    let out = out + "  spec: pol=" + pol_in + " pred=" + pred
+    let out = out + " agent=" + slots_get(spec, "agent")
+    let out = out + " pat=" + slots_get(spec, "patient")
+    let out = out + " iobj=" + slots_get(spec, "iobj")
+    let out = out + " loc=" + slots_get(spec, "location")
+    let out = out + " tense=" + slots_get(spec, "tense")
+    let out = out + " negw=" + slots_get(spec, "neg_word")
+    let out = out + " subord=" + slots_get(spec, "subord_conj") + "/" + slots_get(spec, "subord_pred") + "\n"
+    let out = out + "  realized: " + surf + "\n"
+    let out = out + "  reparse:  pol=" + pol_out + "  [" + status + "]  expected=" + expected_pol + " (" + okexp + ")\n"
+    return out
+}
+
+fn cp_preserved(text: String) -> Int {
+    let spec: [String] = parse_spec(text)
+    let pol_in: String = slots_get(spec, "polarity")
+    let surf: String = realize(spec)
+    let spec2: [String] = parse_spec(surf)
+    let pol_out: String = slots_get(spec2, "polarity")
+    if str_eq(pol_in, pol_out) { return 1 }
+    return 0
+}
+
+fn cp_correct(text: String, expected_pol: String) -> Int {
+    let spec: [String] = parse_spec(text)
+    if str_eq(slots_get(spec, "polarity"), expected_pol) { return 1 }
+    return 0
+}
+
+fn run_gate() -> String {
+    let s1: String = "I never fought the ocean."
+    let s2: String = "She did not see the man with the telescope."
+    let s3: String = "The teacher reads the book to the children."
+    let s4: String = "The stupid boy ate the cat because he was a monster."
+    let s5: String = "Time flies like an arrow."
+
+    let rep: String = "==== ELP native telephone test (parse -> realize -> re-parse) ====\n"
+    let rep = rep + cp_line(s1, "neg")
+    let rep = rep + cp_line(s2, "neg")
+    let rep = rep + cp_line(s3, "aff")
+    let rep = rep + cp_line(s4, "aff")
+    let rep = rep + cp_line(s5, "aff")
+
+    // NOTE: accumulate with Int-var + literal increments — el's overloaded `+`
+    // mis-compiles chained function-call int operands as string concat.
+    let pres: Int = 0
+    if cp_preserved(s1) == 1 { let pres = pres + 1 }
+    if cp_preserved(s2) == 1 { let pres = pres + 1 }
+    if cp_preserved(s3) == 1 { let pres = pres + 1 }
+    if cp_preserved(s4) == 1 { let pres = pres + 1 }
+    if cp_preserved(s5) == 1 { let pres = pres + 1 }
+    let corr: Int = 0
+    if cp_correct(s1, "neg") == 1 { let corr = corr + 1 }
+    if cp_correct(s2, "neg") == 1 { let corr = corr + 1 }
+    if cp_correct(s3, "aff") == 1 { let corr = corr + 1 }
+    if cp_correct(s4, "aff") == 1 { let corr = corr + 1 }
+    if cp_correct(s5, "aff") == 1 { let corr = corr + 1 }
+
+    let rep = rep + "-----------------------------------------------------------------\n"
+    let rep = rep + "polarity PRESERVED through round-trip: " + int_to_str(pres) + "/5\n"
+    let rep = rep + "polarity EXTRACTED correctly:          " + int_to_str(corr) + "/5\n"
+    if pres == 5 {
+        if corr == 5 {
+            let rep = rep + "GATE: PASS\n"
+        } else {
+            let rep = rep + "GATE: FAIL (extraction)\n"
+        }
+    } else {
+        let rep = rep + "GATE: FAIL (round-trip)\n"
+    }
+    return rep
+}
+
+println(run_gate())

elp/tests/comprehend_romance_gate.el

@@ -0,0 +1,87 @@
+// comprehend_romance_gate.el - ES / PT native telephone test (SACRED polarity).
+//
+// The spec is language-neutral. This gate proves the Romance front-end extracts
+// SACRED polarity correctly and that negation survives parse -> realize ->
+// re-parse for Spanish and Portuguese (byte-parity of the surface is NOT expected
+// yet — the non-English realizer path is a generic preverbal-negator skeleton).
+
+fn rg_line(text: String, lang: String, expected_pol: String) -> String {
+    let spec: [String] = parse_spec_lang(text, lang)
+    let pol_in: String = slots_get(spec, "polarity")
+    let surf: String = realize(spec)
+    let spec2: [String] = parse_spec_lang(surf, lang)
+    let pol_out: String = slots_get(spec2, "polarity")
+    let status: String = "LOST"
+    if str_eq(pol_in, pol_out) { let status = "PRESERVED" }
+    let okexp: String = "MISMATCH"
+    if str_eq(pol_in, expected_pol) { let okexp = "ok" }
+    let out: String = "IN[" + lang + "]: " + text + "\n"
+    let out = out + "  spec: pol=" + pol_in + " pred=" + slots_get(spec, "predicate")
+    let out = out + " agent=" + slots_get(spec, "agent")
+    let out = out + " pat=" + slots_get(spec, "patient")
+    let out = out + " iobj=" + slots_get(spec, "iobj")
+    let out = out + " loc=" + slots_get(spec, "location")
+    let out = out + " tense=" + slots_get(spec, "tense") + "\n"
+    let out = out + "  realized: " + surf + "\n"
+    let out = out + "  reparse:  pol=" + pol_out + "  [" + status + "]  expected=" + expected_pol + " (" + okexp + ")\n"
+    return out
+}
+
+fn rg_pres(text: String, lang: String) -> Int {
+    let spec: [String] = parse_spec_lang(text, lang)
+    let surf: String = realize(spec)
+    let spec2: [String] = parse_spec_lang(surf, lang)
+    if str_eq(slots_get(spec, "polarity"), slots_get(spec2, "polarity")) { return 1 }
+    return 0
+}
+
+fn rg_corr(text: String, lang: String, expected_pol: String) -> Int {
+    let spec: [String] = parse_spec_lang(text, lang)
+    if str_eq(slots_get(spec, "polarity"), expected_pol) { return 1 }
+    return 0
+}
+
+fn run_romance_gate() -> String {
+    let e1: String = "El niño no comió el pescado."
+    let e2: String = "Yo nunca luché contra el océano."
+    let e3: String = "El profesor lee el libro."
+    let p1: String = "O professor não leu o livro."
+    let p2: String = "Eu nunca lutei contra o oceano."
+    let p3: String = "A menina comeu o peixe."
+
+    let rep: String = "==== ELP Romance telephone test (ES / PT) ====\n"
+    let rep = rep + rg_line(e1, "es", "neg")
+    let rep = rep + rg_line(e2, "es", "neg")
+    let rep = rep + rg_line(e3, "es", "aff")
+    let rep = rep + rg_line(p1, "pt", "neg")
+    let rep = rep + rg_line(p2, "pt", "neg")
+    let rep = rep + rg_line(p3, "pt", "aff")
+
+    let pres: Int = 0
+    if rg_pres(e1, "es") == 1 { let pres = pres + 1 }
+    if rg_pres(e2, "es") == 1 { let pres = pres + 1 }
+    if rg_pres(e3, "es") == 1 { let pres = pres + 1 }
+    if rg_pres(p1, "pt") == 1 { let pres = pres + 1 }
+    if rg_pres(p2, "pt") == 1 { let pres = pres + 1 }
+    if rg_pres(p3, "pt") == 1 { let pres = pres + 1 }
+    let corr: Int = 0
+    if rg_corr(e1, "es", "neg") == 1 { let corr = corr + 1 }
+    if rg_corr(e2, "es", "neg") == 1 { let corr = corr + 1 }
+    if rg_corr(e3, "es", "aff") == 1 { let corr = corr + 1 }
+    if rg_corr(p1, "pt", "neg") == 1 { let corr = corr + 1 }
+    if rg_corr(p2, "pt", "neg") == 1 { let corr = corr + 1 }
+    if rg_corr(p3, "pt", "aff") == 1 { let corr = corr + 1 }
+
+    let rep = rep + "-----------------------------------------------------------------\n"
+    let rep = rep + "polarity PRESERVED through round-trip: " + int_to_str(pres) + "/6\n"
+    let rep = rep + "polarity EXTRACTED correctly:          " + int_to_str(corr) + "/6\n"
+    if pres == 6 {
+        if corr == 6 { let rep = rep + "ROMANCE GATE: PASS\n" }
+        else { let rep = rep + "ROMANCE GATE: FAIL (extraction)\n" }
+    } else {
+        let rep = rep + "ROMANCE GATE: FAIL (round-trip)\n"
+    }
+    return rep
+}
+
+println(run_romance_gate())

elp/tests/multilingual_gate.el

@@ -0,0 +1,43 @@
+// multilingual_gate.el - deterministic language detect + localized-phrase test.
+
+fn mg_det(text: String, want: String) -> String {
+    let got: String = ml_detect(text)
+    let ok: String = "MISMATCH"
+    if str_eq(got, want) { let ok = "ok" }
+    return "  detect(" + got + ") want=" + want + " (" + ok + ")  :: " + text + "\n"
+}
+
+fn mg_ok(text: String, want: String) -> Int {
+    if str_eq(ml_detect(text), want) { return 1 }
+    return 0
+}
+
+fn run_ml_gate() -> String {
+    let t1: String = "Does Neuron use SQLite for storage?"
+    let t2: String = "Neuron, me explica cómo la saliencia forma las geometrías."
+    let t3: String = "O professor não leu o livro na memória."
+    let t4: String = "Che cosa memorizza Neuron nella memoria?"
+
+    let rep: String = "==== ELP multilingual detect + localized phrases ====\n"
+    let rep = rep + mg_det(t1, "en")
+    let rep = rep + mg_det(t2, "es")
+    let rep = rep + mg_det(t3, "pt")
+    let rep = rep + mg_det(t4, "it")
+
+    let rep = rep + "  localized decline (pt): " + ml_tr("no_memory", "pt") + "\n"
+    let rep = rep + "  localized decline (es): " + ml_tr("no_memory", "es") + "\n"
+    let rep = rep + "  term(saliência->en):    " + ml_term("saliência", "pt") + "\n"
+    let rep = rep + "  pred(store->pt):        " + ml_translate_pred("store", "pt") + "\n"
+
+    let ok: Int = 0
+    if mg_ok(t1, "en") == 1 { let ok = ok + 1 }
+    if mg_ok(t2, "es") == 1 { let ok = ok + 1 }
+    if mg_ok(t3, "pt") == 1 { let ok = ok + 1 }
+    if mg_ok(t4, "it") == 1 { let ok = ok + 1 }
+    let rep = rep + "-----------------------------------------------------------------\n"
+    let rep = rep + "language detected correctly: " + int_to_str(ok) + "/4\n"
+    if ok == 4 { let rep = rep + "ML GATE: PASS\n" } else { let rep = rep + "ML GATE: FAIL\n" }
+    return rep
+}
+
+println(run_ml_gate())

elp/tests/propositions_gate.el

@@ -0,0 +1,52 @@
+// propositions_gate.el - the READ primitive over memory text (native el).
+// Proves triples are recovered from free memory text and that SACRED polarity
+// survives extraction (a negative memory must yield a NOT-triple).
+
+fn pg_check(text: String, want_pol: String) -> String {
+    let p: [String] = prop_extract_one(text, "nd-test")
+    let pol: String = slots_get(p, "polarity")
+    let ok: String = "MISMATCH"
+    if str_eq(pol, want_pol) { let ok = "ok" }
+    return "  " + prop_repr(p) + "   pol=" + pol + " expected=" + want_pol + " (" + ok + ")\n"
+}
+
+fn pg_pol_ok(text: String, want_pol: String) -> Int {
+    let p: [String] = prop_extract_one(text, "nd-test")
+    if str_eq(slots_get(p, "polarity"), want_pol) { return 1 }
+    return 0
+}
+
+fn run_prop_gate() -> String {
+    let m1: String = "Neuron stores memories in SQLite."
+    let m2: String = "The engram does not delete a memory."
+    let m3: String = "Salience never drops the negation."
+    let m4: String = "The teacher gives the book to the children."
+
+    let rep: String = "==== ELP proposition extraction (memory text -> triples) ====\n"
+    let rep = rep + pg_check(m1, "aff")
+    let rep = rep + pg_check(m2, "neg")
+    let rep = rep + pg_check(m3, "neg")
+    let rep = rep + pg_check(m4, "aff")
+
+    // multi-sentence memory: one triple per sentence, order preserved
+    let doc: String = "Neuron persists learning. It does not forget the library."
+    let props: [String] = prop_extract(doc, "nd-doc")
+    let rep = rep + "  --- multi-sentence doc (" + int_to_str(native_list_len(props)) + " props) ---\n"
+    let di: Int = 0
+    while di < native_list_len(props) {
+        let rep = rep + "    " + native_list_get(props, di) + "\n"
+        let di = di + 1
+    }
+
+    let ok: Int = 0
+    if pg_pol_ok(m1, "aff") == 1 { let ok = ok + 1 }
+    if pg_pol_ok(m2, "neg") == 1 { let ok = ok + 1 }
+    if pg_pol_ok(m3, "neg") == 1 { let ok = ok + 1 }
+    if pg_pol_ok(m4, "aff") == 1 { let ok = ok + 1 }
+    let rep = rep + "-----------------------------------------------------------------\n"
+    let rep = rep + "SACRED polarity correct on extraction: " + int_to_str(ok) + "/4\n"
+    if ok == 4 { let rep = rep + "PROP GATE: PASS\n" } else { let rep = rep + "PROP GATE: FAIL\n" }
+    return rep
+}
+
+println(run_prop_gate())