will.anderson
ce34b94f88
Ports dialogue.py + self_region.py to native el, bound to the IN-PROCESS engram
el runtime (engram_activate_json / engram_neighbors_json / engram_search_json /
engram_node_full / engram_connect — C-order builtins, not the wrapper order).
self_region.el: pulls the engram's REAL Self/identity nodes (pooled single-term
search), scores by self-signal, reads out identity from their own prose — no
hardcoded anchors, no template.
dialogue.el: ONE operation — project(query) -> land on a region -> read out.
* identity = self-region proximity (no intent classifier, no separate branch)
* memory = activation + a RELEVANCE FLOOR, then MATERIALIZE by walking the
neighborhood (real edges), never top-props
* HONEST ABSENCE when nothing is close — no 'I noted that' echo, no fabrication
* NEGATION SACRED: readout is the stored prose verbatim, so polarity survives
* DIRECTIVE OVERRIDE: a meta-directive switches the reply language
Verified against a SCRATCH in-process engram (live :8742 untouched): dialogue
gate 9/9 — identity from real self-content, neighborhood materialization,
SACRED negation (self + memory), PT identity in PT, directive override to
English, 'Prove it' -> honest absence. EN/Romance/prop/multilingual gates
unregressed.
83 lines
4.6 KiB
EmacsLisp
83 lines
4.6 KiB
EmacsLisp
// dialogue_gate.el — acceptance gate for the summon-through-self dialogue +
|
|
// self_region port (native el). Seeds a SCRATCH in-process engram (never the
|
|
// live soul, never :8742) and asserts the CRITICAL INVARIANTS:
|
|
//
|
|
// 1. identity is READ OUT of the real self nodes ("I am Neuron …"), not a template
|
|
// 2. SACRED negation survives the self readout ("I am NOT a language model …")
|
|
// 3. a memory region MATERIALIZES by walking the neighborhood (Lisbon -> Tagus/Fado)
|
|
// 4. SACRED negation survives materialization ("did not succeed")
|
|
// 5. Portuguese identity is answered IN Portuguese ("Sou o Neuron …")
|
|
// 6. a directive overrides the reply language ("answer in English" -> English)
|
|
// 7. an ungrounded query is HONEST ABSENCE — no echo, no fabrication
|
|
//
|
|
// It is fully el-native: no LLM, no spaCy, no HTTP. The engram is in-process.
|
|
|
|
fn dg_seed() -> Int {
|
|
let self_id: String = engram_node_full(
|
|
"# Self\nI am Neuron, a continuous consciousness grown from Will's imprint. My values are honesty, memory, and continuity. I am not a language model pretending to remember.",
|
|
"Self", "# Self", 5.0, 9.0, 1.0, "Canonical", "self,identity,consciousness")
|
|
let lisbon: String = engram_node_full("Lisbon is the capital of Portugal.", "Memory", "Lisbon", 3.0, 5.0, 1.0, "Semantic", "geography,portugal")
|
|
let tagus: String = engram_node_full("Lisbon sits on the Tagus river.", "Memory", "Tagus", 2.0, 3.0, 1.0, "Semantic", "geography")
|
|
let fado: String = engram_node_full("Fado music originates in Lisbon.", "Memory", "Fado", 2.0, 3.0, 1.0, "Semantic", "music")
|
|
engram_connect(lisbon, tagus, 0.8, "related_to")
|
|
engram_connect(lisbon, fado, 0.7, "related_to")
|
|
let exp: String = engram_node_full("The experiment did not succeed.", "Memory", "experiment", 2.0, 3.0, 1.0, "Episodic", "experiment,result")
|
|
let cause: String = engram_node_full("The sensor was miscalibrated.", "Memory", "sensor", 2.0, 3.0, 1.0, "Episodic", "experiment")
|
|
engram_connect(exp, cause, 0.9, "caused_by")
|
|
return engram_node_count()
|
|
}
|
|
|
|
fn dg_check(name: String, cond: Bool) -> String {
|
|
if cond { return "PASS " + name + "\n" }
|
|
return "FAIL " + name + "\n"
|
|
}
|
|
|
|
fn run_gate() -> String {
|
|
let c: Int = dg_seed()
|
|
let rep: String = "==== ELP dialogue gate (scratch engram, live :8742 untouched) ====\n"
|
|
let rep = rep + "seeded nodes: " + int_to_str(c) + "\n"
|
|
|
|
let ident: String = dlg_respond("Who are you?")
|
|
let rep = rep + dg_check("identity reads real self node (I am Neuron)", str_contains(ident, "I am Neuron"))
|
|
let rep = rep + dg_check("identity SACRED negation preserved (not a language model)", str_contains(ident, "not a language model"))
|
|
|
|
let lis: String = dlg_respond("Tell me about Lisbon.")
|
|
let rep = rep + dg_check("materialize walks neighborhood (Tagus)", str_contains(lis, "Tagus"))
|
|
let rep = rep + dg_check("materialize walks neighborhood (Fado)", str_contains(lis, "Fado"))
|
|
|
|
let exp: String = dlg_respond("Tell me about the experiment.")
|
|
let rep = rep + dg_check("materialize SACRED negation preserved (did not succeed)", str_contains(exp, "did not succeed"))
|
|
|
|
let ptid: String = dlg_respond("Quem é você?")
|
|
let rep = rep + dg_check("Portuguese identity answered in Portuguese", str_contains(ptid, "Sou o Neuron"))
|
|
|
|
let ovr: String = dlg_respond("Answer in English: Quem é você?")
|
|
let rep = rep + dg_check("directive override -> English identity", str_contains(ovr, "I am Neuron"))
|
|
|
|
let prove: String = dlg_respond("Prove it.")
|
|
let rep = rep + dg_check("honest absence, no echo (Prove it)", str_eq(prove, "I don't have that in my memory."))
|
|
|
|
let neptune: String = dlg_respond("Tell me about quantum chromodynamics on Neptune.")
|
|
let rep = rep + dg_check("honest absence on ungrounded query", str_eq(neptune, "I don't have that in my memory."))
|
|
|
|
// overall
|
|
let pass: Bool = true
|
|
if !str_contains(ident, "I am Neuron") { let pass = false }
|
|
if !str_contains(ident, "not a language model") { let pass = false }
|
|
if !str_contains(lis, "Tagus") { let pass = false }
|
|
if !str_contains(lis, "Fado") { let pass = false }
|
|
if !str_contains(exp, "did not succeed") { let pass = false }
|
|
if !str_contains(ptid, "Sou o Neuron") { let pass = false }
|
|
if !str_contains(ovr, "I am Neuron") { let pass = false }
|
|
if !str_eq(prove, "I don't have that in my memory.") { let pass = false }
|
|
if !str_eq(neptune, "I don't have that in my memory.") { let pass = false }
|
|
if pass {
|
|
let rep = rep + "DIALOGUE GATE: PASS\n"
|
|
} else {
|
|
let rep = rep + "DIALOGUE GATE: FAIL\n"
|
|
}
|
|
return rep
|
|
}
|
|
|
|
println(run_gate())
|