Add native speech synthesis and voice-imitation faculty

speech.el: formant/glottal integer DSP synthesis + voice-analyze-by- imitation. voice-profile.el / voice-ingest.el: voice-profile plumbing. accent.el: British-RP as an ingested transform-geometry (explicitly marked provisional/citation-pending by its own comments). organ-read.el: engram read-through for the speech organ. Includes demo/test drivers and non-personal reference data (British-RP phonetics/lexicon derived data, a public-domain LibriVox RP reference recording). Deliberately excludes elp/data/live/ (raw recorded voice + face-photo samples of the repo owner) and the will-*.{json,psv} derived voiceprint files — personal biometric data that shouldn't be committed to a shared repo without an explicit decision from the owner. Also excludes this worktree's elp/src/surface-profile.el, which diverges from the copy in other worktrees (agent-aaf04b0a9714c4070, main) — needs manual reconciliation before landing, left out here to avoid silently picking a version.
Merge pull request 'promote stage -> main: reconciled el runtime (engram search + natives + durable truncation fix + Windows port)' (#82 ) from stage into main
2026-08-15 14:27:52 -05:00 · 2026-07-22 21:44:01 +00:00 · 2026-07-22 21:20:17 +00:00 · 2026-07-22 21:06:36 +00:00 · 2026-07-22 15:56:08 -05:00 · 2026-07-22 15:46:02 -05:00
38 changed files with 2985 additions and 76 deletions
@@ -214,9 +214,18 @@ jobs:
        env:
          GCP_SA_KEY: ${{ secrets.GCP_SA_KEY }}
        run: |
+          # Fail loudly: previously this step had no `set -e`, so an auth or
+          # upload failure was swallowed (step exited 0 on the trailing echo)
+          # and the SDK silently never published. Surface failures now.
+          set -euo pipefail
+          if [ -z "${GCP_SA_KEY:-}" ]; then
+            echo "FATAL: GCP_SA_KEY secret is empty — cannot authenticate to publish" >&2
+            exit 1
+          fi
          echo "${GCP_SA_KEY}" > /tmp/gcp-key.json
          gcloud auth activate-service-account --key-file=/tmp/gcp-key.json
          gcloud config set project neuron-785695
+          echo "Publishing as active account: $(gcloud config get-value account 2>/dev/null)"

          VERSION="${GITHUB_SHA:0:8}"

@@ -268,6 +277,12 @@ jobs:
        # Patches ci-base:dev in-place: pulls the existing image (which has all
        # system deps — Node, Go, gcloud, Docker CLI, etc.) and overlays the freshly
        # built El SDK on top. Keeps the full ci-base rebuild fast and incremental.
+        #
+        # continue-on-error: this is a CI-cache optimization, NOT the release
+        # artifact. It runs Docker (pull/build/push ~600MB) on the host-mode GCE
+        # runner where DinD/Docker availability is fragile. A failure here must
+        # never block or redden the job — the SDK publish above is the deliverable.
+        continue-on-error: true
        if: github.event_name == 'push'
        env:
          GCP_SA_KEY: ${{ secrets.GCP_SA_KEY }}
@@ -212,12 +212,21 @@ jobs:
        env:
          GCP_SA_KEY: ${{ secrets.GCP_SA_KEY }}
        run: |
+          # Fail loudly: previously this step had no `set -e`, so an auth or
+          # upload failure was swallowed (step exited 0 on the trailing echo)
+          # and the SDK silently never published. Surface failures now.
+          set -euo pipefail
+          if [ -z "${GCP_SA_KEY:-}" ]; then
+            echo "FATAL: GCP_SA_KEY secret is empty — cannot authenticate to publish" >&2
+            exit 1
+          fi
          echo "${GCP_SA_KEY}" > /tmp/gcp-key.json
          apt-get install -y -qq apt-transport-https ca-certificates curl
          echo "deb [trusted=yes] https://packages.cloud.google.com/apt cloud-sdk main" > /etc/apt/sources.list.d/google-cloud-sdk.list
          apt-get update -qq && apt-get install -y google-cloud-cli
          gcloud auth activate-service-account --key-file=/tmp/gcp-key.json
          gcloud config set project neuron-785695
+          echo "Publishing as active account: $(gcloud config get-value account 2>/dev/null)"

          VERSION="${GITHUB_SHA:0:8}"

@@ -253,6 +262,12 @@ jobs:
        # Patches ci-base:stage in-place: pulls the existing image (which has all
        # system deps — Node, Go, gcloud, Docker CLI, etc.) and overlays the freshly
        # built El SDK on top. Keeps the full ci-base rebuild fast and incremental.
+        #
+        # continue-on-error: this is a CI-cache optimization, NOT the release
+        # artifact. It runs Docker (pull/build/push ~600MB) on the host-mode GCE
+        # runner where DinD/Docker availability is fragile. A failure here must
+        # never block or redden the job — the SDK publish above is the deliverable.
+        continue-on-error: true
        if: github.event_name == 'push'
        env:
          GCP_SA_KEY: ${{ secrets.GCP_SA_KEY }}
@@ -288,12 +288,21 @@ jobs:
        env:
          GCP_SA_KEY: ${{ secrets.GCP_SA_KEY }}
        run: |
+          # Fail loudly: previously this step had no `set -e`, so an auth or
+          # upload failure was swallowed (step exited 0 on the trailing echo)
+          # and the SDK silently never published. Surface failures now.
+          set -euo pipefail
+          if [ -z "${GCP_SA_KEY:-}" ]; then
+            echo "FATAL: GCP_SA_KEY secret is empty — cannot authenticate to publish" >&2
+            exit 1
+          fi
          echo "${GCP_SA_KEY}" > /tmp/gcp-key.json
          apt-get install -y -qq apt-transport-https ca-certificates curl
          echo "deb [trusted=yes] https://packages.cloud.google.com/apt cloud-sdk main" > /etc/apt/sources.list.d/google-cloud-sdk.list
          apt-get update -qq && apt-get install -y google-cloud-cli
          gcloud auth activate-service-account --key-file=/tmp/gcp-key.json
          gcloud config set project neuron-785695
+          echo "Publishing as active account: $(gcloud config get-value account 2>/dev/null)"

          VERSION="${GITHUB_SHA:0:8}"

@@ -345,6 +354,12 @@ jobs:
        # Patches ci-base:latest in-place: pulls the existing image (which has all
        # system deps — Node, Go, gcloud, Docker CLI, etc.) and overlays the freshly
        # built El SDK on top. Keeps the full ci-base rebuild fast and incremental.
+        #
+        # continue-on-error: this is a CI-cache optimization, NOT the release
+        # artifact. It runs Docker (pull/build/push ~600MB) on the host-mode GCE
+        # runner where DinD/Docker availability is fragile. A failure here must
+        # never block or redden the job — the SDK publish above is the deliverable.
+        continue-on-error: true
        if: github.event_name == 'push'
        env:
          GCP_SA_KEY: ${{ secrets.GCP_SA_KEY }}
@@ -0,0 +1,23 @@
+{
+ "dataset": "british-rp-accent-transform",
+ "primitive_type": "accent_target",
+ "accent": "british-rp",
+ "grounding": "derived",
+ "provenance": "HONEST-DERIVED, COARSE FIRST PASS — NOT transcribed measured RP formants. The exact measured RP/GB tables (Deterding 1997 JIPA 27:47-55; Hawkins & Midgley 2005 JIPA 35:183-199) are the intended ground truth but were gated/figure-only at author time and were NOT transcribed. So these targets are DERIVED: each = the corresponding MEASURED Peterson&Barney(1952) base vowel transformed under the documented, citable RP-vs-GA structural rules of Wells (1982) 'Accents of English' — non-rhoticity (NURSE de-rhoticized: remove low F3), TRAP F2-lowering, LOT/THOUGHT back-rounding (F2 down), GOOSE-fronting (F2 up), GOAT centering. Shift MAGNITUDES are coarse/approximate (first pass), directions are cited. ground:derived (base measured + rule cited). Refine by transcribing Deterding/Hawkins&Midgley. No number is presented as a measured RP value it is not.",
+ "notes": "records with kind=vowel_override REPLACE the base phoneme's formant targets with the DERIVED RP realization. records with kind=rule encode non-formant transforms (non-rhoticity: drop post-vocalic coda /r/). The render composes: base geometry then accent override + rhoticity rule — voice + accent, separable.",
+ "records": [
+  {"key": "IY", "features": {"kind": "vowel_override", "set": "FLEECE"},   "attributes": {"f1": 280, "f2": 2249, "f3": 3000}},
+  {"key": "IH", "features": {"kind": "vowel_override", "set": "KIT"},      "attributes": {"f1": 360, "f2": 2100, "f3": 2550}},
+  {"key": "EH", "features": {"kind": "vowel_override", "set": "DRESS"},    "attributes": {"f1": 560, "f2": 1970, "f3": 2480}},
+  {"key": "AE", "features": {"kind": "vowel_override", "set": "TRAP"},     "attributes": {"f1": 730, "f2": 1590, "f3": 2410}},
+  {"key": "AA", "features": {"kind": "vowel_override", "set": "LOT"},      "attributes": {"f1": 560, "f2": 920,  "f3": 2440}},
+  {"key": "AO", "features": {"kind": "vowel_override", "set": "THOUGHT"},  "attributes": {"f1": 415, "f2": 700,  "f3": 2410}},
+  {"key": "UH", "features": {"kind": "vowel_override", "set": "FOOT"},     "attributes": {"f1": 380, "f2": 1100, "f3": 2240}},
+  {"key": "UW", "features": {"kind": "vowel_override", "set": "GOOSE"},    "attributes": {"f1": 310, "f2": 1650, "f3": 2240}},
+  {"key": "AH", "features": {"kind": "vowel_override", "set": "STRUT"},    "attributes": {"f1": 680, "f2": 1180, "f3": 2390}},
+  {"key": "ER", "features": {"kind": "vowel_override", "set": "NURSE", "rhotic": "no"}, "attributes": {"f1": 550, "f2": 1500, "f3": 2500}},
+  {"key": "AX", "features": {"kind": "vowel_override", "set": "commA"},    "attributes": {"f1": 500, "f2": 1500, "f3": 2500}},
+  {"key": "OW", "features": {"kind": "vowel_override", "set": "GOAT"},     "attributes": {"f1": 450, "f2": 1400, "f3": 2380}},
+  {"key": "R",  "features": {"kind": "rule", "rule": "non_rhotic"},        "attributes": {"drop_coda_r": 1}}
+ ]
+}
@@ -0,0 +1,26 @@
+# british-rp-accent TRANSFORM — INGESTIBLE DATA (a geometry/transform composed
+# onto the base General-American phoneme targets; voice + accent, separable).
+#
+# PROVENANCE — HONEST, COARSE FIRST PASS. These are DERIVED targets, NOT
+# transcribed measured RP formants. Measured RP tables (Deterding 1997 JIPA 27;
+# Hawkins & Midgley 2005 JIPA 35) are the intended ground truth but were gated at
+# author time and NOT transcribed. Each target = the MEASURED Peterson&Barney
+# (1952) base vowel transformed under the documented, citable RP-vs-GA structural
+# rules of Wells (1982): non-rhoticity, TRAP F2-lowering, LOT/THOUGHT back-
+# rounding, GOOSE-fronting, GOAT centering, NURSE de-rhoticization. Shift
+# magnitudes are coarse/approximate; directions are cited. ground=derived.
+# Refine by transcribing the measured RP tables. No value is claimed as measured.
+# Format: KEY|F1|F2|F3|KIND|SET
+IY|280|2249|3000|vowel_override|FLEECE
+IH|360|2100|2550|vowel_override|KIT
+EH|560|1970|2480|vowel_override|DRESS
+AE|730|1590|2410|vowel_override|TRAP
+AA|560|920|2440|vowel_override|LOT
+AO|415|700|2410|vowel_override|THOUGHT
+UH|380|1100|2240|vowel_override|FOOT
+UW|310|1650|2240|vowel_override|GOOSE
+AH|680|1180|2390|vowel_override|STRUT
+ER|550|1500|2500|vowel_override|NURSE-nonrhotic
+AX|500|1500|2500|vowel_override|commA
+OW|450|1400|2380|vowel_override|GOAT
+R|0|0|0|rule|non_rhotic_drop_coda
@@ -0,0 +1,20 @@
+# pronunciation lexicon SOURCE — word -> phoneme sequence, as INGESTIBLE DATA.
+# Pronunciation is linguistic KNOWLEDGE (the language faculty's orthography->
+# phonology map), ingested into the engram, not frozen in code. The render reads
+# a word's phoneme sequence back from the engram. Covers the self-lexicon and the
+# proof sentences; general G2P is the realizer/morphology faculty's remit.
+# Diphthongs are written as two vowel targets (the render's transitions glide
+# between them). Format: word|PH1 PH2 PH3 ...
+i|AA IY
+am|AE M
+neuron|N UW R AA N
+is|IH Z
+memory|M EH M ER IY
+hello|HH EH L OW
+the|DH AH
+a|AH
+remember|R IH M EH M ER
+i'm|AA IY M
+you|Y UW
+here|HH IY R
+will|W IH L
@@ -0,0 +1,528 @@
+{
+ "dataset": "english-phoneme-formants",
+ "primitive_type": "phoneme",
+ "grounding": "extracted",
+ "provenance": "AUDITED per-field. The 10 monophthong-vowel F1/F2/F3 (IY,IH,EH,AE,AA,AO,UH,UW,AH,ER) are the MEASURED adult-male /hVd/ means of Peterson & Barney (1952) JASA 24:175-184, verified vs CRAN phonTools::pb52. AX=neutral uniform-tube resonances (Fant, physics). OW steady target = synthesis convention (diphthong). Consonant loci (M,N,NG,L,R,W,Y,Z,DH,V,S,F,HH) and ALL bandwidths + dur/amp = standard formant-synthesis conventions (Klatt 1980 JASA 67:971), engineering defaults NOT field measurements. No numbers invented/LLM-generated.",
+ "records": [
+  {
+   "key": "IY",
+   "features": {
+    "manner": "vowel",
+    "voiced": "yes",
+    "nasal": "no"
+   },
+   "attributes": {
+    "f1": 270,
+    "f2": 2290,
+    "f3": 3010,
+    "bw1": 60,
+    "bw2": 90,
+    "bw3": 150,
+    "voiced": 1,
+    "nasal": 0,
+    "dur": 130,
+    "amp": 100
+   }
+  },
+  {
+   "key": "IH",
+   "features": {
+    "manner": "vowel",
+    "voiced": "yes",
+    "nasal": "no"
+   },
+   "attributes": {
+    "f1": 390,
+    "f2": 1990,
+    "f3": 2550,
+    "bw1": 70,
+    "bw2": 100,
+    "bw3": 150,
+    "voiced": 1,
+    "nasal": 0,
+    "dur": 110,
+    "amp": 100
+   }
+  },
+  {
+   "key": "EH",
+   "features": {
+    "manner": "vowel",
+    "voiced": "yes",
+    "nasal": "no"
+   },
+   "attributes": {
+    "f1": 530,
+    "f2": 1840,
+    "f3": 2480,
+    "bw1": 80,
+    "bw2": 100,
+    "bw3": 150,
+    "voiced": 1,
+    "nasal": 0,
+    "dur": 130,
+    "amp": 100
+   }
+  },
+  {
+   "key": "AE",
+   "features": {
+    "manner": "vowel",
+    "voiced": "yes",
+    "nasal": "no"
+   },
+   "attributes": {
+    "f1": 660,
+    "f2": 1720,
+    "f3": 2410,
+    "bw1": 90,
+    "bw2": 110,
+    "bw3": 150,
+    "voiced": 1,
+    "nasal": 0,
+    "dur": 150,
+    "amp": 100
+   }
+  },
+  {
+   "key": "AA",
+   "features": {
+    "manner": "vowel",
+    "voiced": "yes",
+    "nasal": "no"
+   },
+   "attributes": {
+    "f1": 730,
+    "f2": 1090,
+    "f3": 2440,
+    "bw1": 90,
+    "bw2": 110,
+    "bw3": 150,
+    "voiced": 1,
+    "nasal": 0,
+    "dur": 150,
+    "amp": 100
+   }
+  },
+  {
+   "key": "AO",
+   "features": {
+    "manner": "vowel",
+    "voiced": "yes",
+    "nasal": "no"
+   },
+   "attributes": {
+    "f1": 570,
+    "f2": 840,
+    "f3": 2410,
+    "bw1": 80,
+    "bw2": 100,
+    "bw3": 150,
+    "voiced": 1,
+    "nasal": 0,
+    "dur": 140,
+    "amp": 100
+   }
+  },
+  {
+   "key": "UH",
+   "features": {
+    "manner": "vowel",
+    "voiced": "yes",
+    "nasal": "no"
+   },
+   "attributes": {
+    "f1": 440,
+    "f2": 1020,
+    "f3": 2240,
+    "bw1": 70,
+    "bw2": 100,
+    "bw3": 150,
+    "voiced": 1,
+    "nasal": 0,
+    "dur": 110,
+    "amp": 100
+   }
+  },
+  {
+   "key": "UW",
+   "features": {
+    "manner": "vowel",
+    "voiced": "yes",
+    "nasal": "no"
+   },
+   "attributes": {
+    "f1": 300,
+    "f2": 870,
+    "f3": 2240,
+    "bw1": 70,
+    "bw2": 90,
+    "bw3": 150,
+    "voiced": 1,
+    "nasal": 0,
+    "dur": 140,
+    "amp": 100
+   }
+  },
+  {
+   "key": "AH",
+   "features": {
+    "manner": "vowel",
+    "voiced": "yes",
+    "nasal": "no"
+   },
+   "attributes": {
+    "f1": 640,
+    "f2": 1190,
+    "f3": 2390,
+    "bw1": 80,
+    "bw2": 100,
+    "bw3": 150,
+    "voiced": 1,
+    "nasal": 0,
+    "dur": 110,
+    "amp": 95
+   }
+  },
+  {
+   "key": "ER",
+   "features": {
+    "manner": "vowel",
+    "voiced": "yes",
+    "nasal": "no"
+   },
+   "attributes": {
+    "f1": 490,
+    "f2": 1350,
+    "f3": 1690,
+    "bw1": 80,
+    "bw2": 100,
+    "bw3": 120,
+    "voiced": 1,
+    "nasal": 0,
+    "dur": 140,
+    "amp": 95
+   }
+  },
+  {
+   "key": "AX",
+   "features": {
+    "manner": "vowel",
+    "voiced": "yes",
+    "nasal": "no"
+   },
+   "attributes": {
+    "f1": 500,
+    "f2": 1500,
+    "f3": 2500,
+    "bw1": 80,
+    "bw2": 100,
+    "bw3": 150,
+    "voiced": 1,
+    "nasal": 0,
+    "dur": 80,
+    "amp": 85
+   }
+  },
+  {
+   "key": "OW",
+   "features": {
+    "manner": "vowel",
+    "voiced": "yes",
+    "nasal": "no"
+   },
+   "attributes": {
+    "f1": 490,
+    "f2": 910,
+    "f3": 2380,
+    "bw1": 80,
+    "bw2": 100,
+    "bw3": 150,
+    "voiced": 1,
+    "nasal": 0,
+    "dur": 140,
+    "amp": 100
+   }
+  },
+  {
+   "key": "M",
+   "features": {
+    "manner": "nasal",
+    "voiced": "yes",
+    "nasal": "yes"
+   },
+   "attributes": {
+    "f1": 250,
+    "f2": 900,
+    "f3": 2200,
+    "bw1": 90,
+    "bw2": 120,
+    "bw3": 180,
+    "voiced": 1,
+    "nasal": 1,
+    "dur": 80,
+    "amp": 60
+   }
+  },
+  {
+   "key": "N",
+   "features": {
+    "manner": "nasal",
+    "voiced": "yes",
+    "nasal": "yes"
+   },
+   "attributes": {
+    "f1": 250,
+    "f2": 1700,
+    "f3": 2600,
+    "bw1": 90,
+    "bw2": 120,
+    "bw3": 180,
+    "voiced": 1,
+    "nasal": 1,
+    "dur": 80,
+    "amp": 60
+   }
+  },
+  {
+   "key": "NG",
+   "features": {
+    "manner": "nasal",
+    "voiced": "yes",
+    "nasal": "yes"
+   },
+   "attributes": {
+    "f1": 250,
+    "f2": 2300,
+    "f3": 2700,
+    "bw1": 90,
+    "bw2": 120,
+    "bw3": 180,
+    "voiced": 1,
+    "nasal": 1,
+    "dur": 80,
+    "amp": 60
+   }
+  },
+  {
+   "key": "L",
+   "features": {
+    "manner": "approximant",
+    "voiced": "yes",
+    "nasal": "no"
+   },
+   "attributes": {
+    "f1": 360,
+    "f2": 1300,
+    "f3": 2600,
+    "bw1": 80,
+    "bw2": 110,
+    "bw3": 160,
+    "voiced": 1,
+    "nasal": 0,
+    "dur": 70,
+    "amp": 80
+   }
+  },
+  {
+   "key": "R",
+   "features": {
+    "manner": "approximant",
+    "voiced": "yes",
+    "nasal": "no"
+   },
+   "attributes": {
+    "f1": 490,
+    "f2": 1350,
+    "f3": 1600,
+    "bw1": 80,
+    "bw2": 110,
+    "bw3": 120,
+    "voiced": 1,
+    "nasal": 0,
+    "dur": 80,
+    "amp": 85
+   }
+  },
+  {
+   "key": "W",
+   "features": {
+    "manner": "approximant",
+    "voiced": "yes",
+    "nasal": "no"
+   },
+   "attributes": {
+    "f1": 300,
+    "f2": 610,
+    "f3": 2200,
+    "bw1": 70,
+    "bw2": 100,
+    "bw3": 160,
+    "voiced": 1,
+    "nasal": 0,
+    "dur": 70,
+    "amp": 80
+   }
+  },
+  {
+   "key": "Y",
+   "features": {
+    "manner": "approximant",
+    "voiced": "yes",
+    "nasal": "no"
+   },
+   "attributes": {
+    "f1": 270,
+    "f2": 2290,
+    "f3": 3010,
+    "bw1": 60,
+    "bw2": 90,
+    "bw3": 150,
+    "voiced": 1,
+    "nasal": 0,
+    "dur": 60,
+    "amp": 80
+   }
+  },
+  {
+   "key": "Z",
+   "features": {
+    "manner": "fricative",
+    "voiced": "yes",
+    "nasal": "no"
+   },
+   "attributes": {
+    "f1": 300,
+    "f2": 1700,
+    "f3": 2500,
+    "bw1": 100,
+    "bw2": 150,
+    "bw3": 200,
+    "voiced": 1,
+    "nasal": 0,
+    "dur": 90,
+    "amp": 55
+   }
+  },
+  {
+   "key": "DH",
+   "features": {
+    "manner": "fricative",
+    "voiced": "yes",
+    "nasal": "no"
+   },
+   "attributes": {
+    "f1": 300,
+    "f2": 1400,
+    "f3": 2500,
+    "bw1": 100,
+    "bw2": 150,
+    "bw3": 200,
+    "voiced": 1,
+    "nasal": 0,
+    "dur": 70,
+    "amp": 55
+   }
+  },
+  {
+   "key": "V",
+   "features": {
+    "manner": "fricative",
+    "voiced": "yes",
+    "nasal": "no"
+   },
+   "attributes": {
+    "f1": 300,
+    "f2": 1000,
+    "f3": 2300,
+    "bw1": 100,
+    "bw2": 150,
+    "bw3": 200,
+    "voiced": 1,
+    "nasal": 0,
+    "dur": 70,
+    "amp": 55
+   }
+  },
+  {
+   "key": "S",
+   "features": {
+    "manner": "fricative",
+    "voiced": "no",
+    "nasal": "no"
+   },
+   "attributes": {
+    "f1": 320,
+    "f2": 1700,
+    "f3": 2500,
+    "bw1": 200,
+    "bw2": 200,
+    "bw3": 250,
+    "voiced": 0,
+    "nasal": 0,
+    "dur": 110,
+    "amp": 45
+   }
+  },
+  {
+   "key": "F",
+   "features": {
+    "manner": "fricative",
+    "voiced": "no",
+    "nasal": "no"
+   },
+   "attributes": {
+    "f1": 300,
+    "f2": 1200,
+    "f3": 2400,
+    "bw1": 200,
+    "bw2": 200,
+    "bw3": 250,
+    "voiced": 0,
+    "nasal": 0,
+    "dur": 100,
+    "amp": 40
+   }
+  },
+  {
+   "key": "HH",
+   "features": {
+    "manner": "fricative",
+    "voiced": "no",
+    "nasal": "no"
+   },
+   "attributes": {
+    "f1": 500,
+    "f2": 1500,
+    "f3": 2500,
+    "bw1": 200,
+    "bw2": 250,
+    "bw3": 300,
+    "voiced": 0,
+    "nasal": 0,
+    "dur": 70,
+    "amp": 40
+   }
+  },
+  {
+   "key": "SIL",
+   "features": {
+    "manner": "silence",
+    "voiced": "no",
+    "nasal": "no"
+   },
+   "attributes": {
+    "f1": 500,
+    "f2": 1500,
+    "f3": 2500,
+    "bw1": 100,
+    "bw2": 100,
+    "bw3": 100,
+    "voiced": 0,
+    "nasal": 0,
+    "dur": 55,
+    "amp": 0
+   }
+  }
+ ]
+}
@@ -0,0 +1,45 @@
+# acoustic-phonetics SOURCE — the learned speech primitives, as INGESTIBLE DATA.
+# NOT audio, NOT code: formant geometry of the phonemes, to be ingested via the
+# ingest organ into the engram as a phoneme manifold. The render reads this
+# geometry back from the engram; nothing is frozen in EL code.
+#
+# PROVENANCE (audited, per-field honesty — no invented numbers):
+#  * The 10 MONOPHTHONG VOWEL formants F1/F2/F3 (IY,IH,EH,AE,AA,AO,UH,UW,AH,ER)
+#    are the MEASURED adult-male means of Peterson & Barney (1952), JASA 24:175-184
+#    — the canonical /hVd/ table, verified digit-for-digit vs CRAN phonTools::pb52.
+#    These are real measured values.
+#  * AX (schwa) F1/F2/F3 = neutral uniform-tube resonances (2n-1)*500 — a PHYSICS
+#    value (Fant), not a P&B measurement.
+#  * OW is a diphthong; its listed steady target is a conventional synthesis value,
+#    not a P&B monophthong measurement.
+#  * CONSONANT loci (M,N,NG,L,R,W,Y,Z,DH,V,S,F,HH) and ALL BANDWIDTHS (B1,B2,B3)
+#    and dur/amp are STANDARD FORMANT-SYNTHESIS conventions (Klatt 1980, JASA 67:971
+#    "Software for a cascade/parallel formant synthesizer") — engineering defaults,
+#    NOT per-phoneme field measurements. Labeled as such, not attributed to P&B.
+# Format: SYM|F1|F2|F3|B1|B2|B3|voiced|nasal|dur_ms|amp|class|example
+IY|270|2290|3010|60|90|150|1|0|130|100|vowel|beet
+IH|390|1990|2550|70|100|150|1|0|110|100|vowel|bit
+EH|530|1840|2480|80|100|150|1|0|130|100|vowel|bet
+AE|660|1720|2410|90|110|150|1|0|150|100|vowel|bat
+AA|730|1090|2440|90|110|150|1|0|150|100|vowel|bot
+AO|570|840|2410|80|100|150|1|0|140|100|vowel|bought
+UH|440|1020|2240|70|100|150|1|0|110|100|vowel|book
+UW|300|870|2240|70|90|150|1|0|140|100|vowel|boot
+AH|640|1190|2390|80|100|150|1|0|110|95|vowel|but
+ER|490|1350|1690|80|100|120|1|0|140|95|vowel|bird
+AX|500|1500|2500|80|100|150|1|0|80|85|vowel|about
+OW|490|910|2380|80|100|150|1|0|140|100|vowel|boat
+M|250|900|2200|90|120|180|1|1|80|60|nasal|map
+N|250|1700|2600|90|120|180|1|1|80|60|nasal|nap
+NG|250|2300|2700|90|120|180|1|1|80|60|nasal|sing
+L|360|1300|2600|80|110|160|1|0|70|80|approximant|lip
+R|490|1350|1600|80|110|120|1|0|80|85|approximant|rip
+W|300|610|2200|70|100|160|1|0|70|80|approximant|wet
+Y|270|2290|3010|60|90|150|1|0|60|80|approximant|yet
+Z|300|1700|2500|100|150|200|1|0|90|55|fricative|zoo
+DH|300|1400|2500|100|150|200|1|0|70|55|fricative|the
+V|300|1000|2300|100|150|200|1|0|70|55|fricative|van
+S|320|1700|2500|200|200|250|0|0|110|45|fricative|see
+F|300|1200|2400|200|200|250|0|0|100|40|fricative|fee
+HH|500|1500|2500|200|250|300|0|0|70|40|fricative|hat
+SIL|500|1500|2500|100|100|100|0|0|55|0|silence|_
@@ -0,0 +1,136 @@
+// accent.el - A British-RP ACCENT as an INGESTED TRANSFORM-GEOMETRY, composed
+// onto the voice (voice (+) accent, SEPARABLE). Reads elp/data/british-accent.psv
+// into an accent MANIFOLD in the engram (override nodes + a shared accent hub),
+// and the render reads the RP formant overrides + the non-rhotic rule back from
+// that geometry. NO accent targets live in code — same discipline as the base
+// phonetics. PROVENANCE NOTE: the RP Hz values are PROVISIONAL (reconstructed-
+// from-knowledge approximations, cite Deterding1997 / Hawkins&Midgley2005 /
+// Wells1982) pending transcription from the published tables — the PIPELINE is
+// the deliverable; exact values are being source-verified separately.
+
+fn ingest_accent(path: String) -> [String] {
+    let content: String = fs_read(path)
+    let lines: [String] = str_split(content, "\n")
+    let nl: Int = native_list_len(lines)
+    let amap: [String] = native_list_empty()
+    let hub: String = engram_node("accent british-rp prov=PROVISIONAL cite=Deterding1997-HawkinsMidgley2005-Wells1982", "Accent", 80)
+    let li: Int = 0
+    while li < nl {
+        let line: String = native_list_get(lines, li)
+        let ll: Int = str_len(line)
+        let skip: Int = 0
+        if ll < 3 {
+            skip = 1
+        }
+        if skip == 0 {
+            let first: Int = str_char_code(line, 0)
+            if first == 35 {
+                skip = 1
+            }
+        }
+        if skip == 0 {
+            let f: [String] = str_split(line, "|")
+            let nf: Int = native_list_len(f)
+            if nf >= 6 {
+                let key: String = native_list_get(f, 0)
+                let f1: String = native_list_get(f, 1)
+                let f2: String = native_list_get(f, 2)
+                let f3: String = native_list_get(f, 3)
+                let kind: String = native_list_get(f, 4)
+                let set: String = native_list_get(f, 5)
+                let cont: String = "accent british-rp " + key + " f1=" + f1 + " f2=" + f2 + " f3=" + f3 + " kind=" + kind + " set=" + set + " prov=PROVISIONAL cite=Deterding1997-HawkinsMidgley2005-Wells1982"
+                let id: String = engram_node(cont, "AccentTarget", 80)
+                amap = native_list_append(amap, key)
+                amap = native_list_append(amap, cont)
+                engram_connect(id, hub, 80, "of_accent")
+            }
+        }
+        li = li + 1
+    }
+    return amap
+}
+
+// RP formant override for a phoneme, read from the accent manifold. Returns
+// [f1,f2,f3] for a vowel_override record, or an empty list if none / a rule.
+fn accent_formants(amap: [String], code: String) -> [Int] {
+    let out: [Int] = native_list_empty()
+    let id: String = sp_map_get(amap, code)
+    if str_eq(id, "") {
+        return out
+    }
+    let j: String = id
+    let isrule: Int = str_index_of(j, "drop_coda")
+    if isrule >= 0 {
+        return out
+    }
+    let f1: Int = parse_uint_from(j, "f1=")
+    if f1 <= 0 {
+        return out
+    }
+    let out = native_list_append(out, f1)
+    let out = native_list_append(out, parse_uint_from(j, "f2="))
+    let out = native_list_append(out, parse_uint_from(j, "f3="))
+    return out
+}
+
+// Is this accent non-rhotic? (reads the R rule node from the manifold)
+fn is_nonrhotic(amap: [String]) -> Int {
+    let id: String = sp_map_get(amap, "R")
+    if str_eq(id, "") {
+        return 0
+    }
+    let hit: Int = str_index_of(id, "drop_coda")
+    if hit >= 0 {
+        return 1
+    }
+    return 0
+}
+
+// Is this symbol a vowel? Membership in the vowel-set derived from the phonetics
+// source's class column (phonological structure — the FORMANT NUMBERS still come
+// from the organ manifold; this is only the categorical class for the rule).
+fn is_vowel_sym(vset: [String], sym: String) -> Int {
+    let n: Int = native_list_len(vset)
+    let i: Int = 0
+    while i < n {
+        if str_eq(native_list_get(vset, i), sym) {
+            return 1
+        }
+        i = i + 1
+    }
+    return 0
+}
+
+// Non-rhotic transform: drop a post-vocalic CODA /R/ — an R whose next non-SIL
+// phoneme is NOT a vowel (a consonant, or end of utterance). Keep INTERVOCALIC/
+// onset R (next non-SIL phoneme is a vowel, e.g. the medial R in N UW R AA N).
+fn apply_rhoticity(codes: [String], vset: [String]) -> [String] {
+    let n: Int = native_list_len(codes)
+    let out: [String] = native_list_empty()
+    let i: Int = 0
+    while i < n {
+        let c: String = native_list_get(codes, i)
+        let keep: Int = 1
+        if str_eq(c, "R") {
+            let jx: Int = i + 1
+            let nextv: Int = 0
+            while jx < n {
+                let ncode: String = native_list_get(codes, jx)
+                if str_eq(ncode, "SIL") {
+                    jx = jx + 1
+                } else {
+                    nextv = is_vowel_sym(vset, ncode)
+                    jx = n + 1000
+                }
+            }
+            if nextv == 0 {
+                keep = 0
+            }
+        }
+        if keep == 1 {
+            out = native_list_append(out, c)
+        }
+        i = i + 1
+    }
+    return out
+}
@@ -0,0 +1,125 @@
+// organ-read.el - Route the render's GEOMETRY READ through the ingest ORGAN's
+// saved engram files (the coordinator's source of truth). For each file we
+// engram_load() it, engram_scan_nodes_json(limit, offset) to get the node array,
+// and cache each node's self-contained CONTENT string keyed by symbol. Because
+// the cached value carries the numbers ("... f1=730 ..."), the cache SURVIVES the
+// store being REPLACED by the next engram_load — so we load+cache phonetics
+// FIRST, then load+cache accent. The .psv path remains a fallback.
+//
+// engram_scan_nodes_json(limit, offset) takes NO query; it returns nodes
+// salience-sorted, so limit must be >= node count and we filter client-side.
+// (engram_search / engram_scan_nodes return len-5 garbage — unused.)
+
+// Find every occurrence of `marker` in the scan JSON; for each, cache
+// sym -> a 150-char content window (enough to hold f1..amp). Duplicates from the
+// node's "content" and "label" fields are harmless (first match wins on read).
+fn organ_cache(j: String, marker: String, mlen: Int, win_len: Int, need: String) -> [String] {
+    let m: [String] = native_list_empty()
+    let jl: Int = str_len(j)
+    let off: Int = 0
+    while off < jl {
+        let rest: String = str_slice(j, off, jl)
+        let p: Int = str_index_of(rest, marker)
+        if p < 0 {
+            off = jl
+        } else {
+            let abs: Int = off + p
+            let win: String = str_slice(j, abs, abs + win_len)
+            let after: String = str_slice(win, mlen, str_len(win))
+            let sp: Int = str_index_of(after, " ")
+            let hasneed: Int = str_index_of(win, need)
+            if sp > 0 {
+                if hasneed >= 0 {
+                    let sym: String = str_slice(after, 0, sp)
+                    m = native_list_append(m, sym)
+                    m = native_list_append(m, win)
+                }
+            }
+            off = abs + mlen
+        }
+    }
+    return m
+}
+
+// Load the phonetics organ file and cache sym -> content. mlen("phoneme ")=8.
+fn organ_pmap(path: String) -> [String] {
+    let ok: Bool = engram_load(path)
+    if ok == false {
+        return native_list_empty()
+    }
+    let j: String = engram_scan_nodes_json(600, 0)
+    return organ_cache(j, "phoneme ", 8, 150, "f1=")
+}
+
+// Load the accent organ file and cache sym -> content. mlen("accent_target ")=14.
+// Vowel overrides carry f1=..; the R rule carries drop_coda_r (need="=" matches
+// both, i.e. any well-formed accent_target field).
+fn organ_amap(path: String) -> [String] {
+    let ok: Bool = engram_load(path)
+    if ok == false {
+        return native_list_empty()
+    }
+    let j: String = engram_scan_nodes_json(600, 0)
+    return organ_cache(j, "accent_target ", 14, 90, "=")
+}
+
+// Vowel-set (categorical class) from the phonetics .psv class column.
+fn organ_vset(path: String) -> [String] {
+    let content: String = fs_read(path)
+    let lines: [String] = str_split(content, "\n")
+    let nl: Int = native_list_len(lines)
+    let v: [String] = native_list_empty()
+    let li: Int = 0
+    while li < nl {
+        let line: String = native_list_get(lines, li)
+        let ok: Int = 1
+        if str_len(line) < 5 {
+            ok = 0
+        }
+        if ok == 1 {
+            if str_char_code(line, 0) == 35 {
+                ok = 0
+            }
+        }
+        if ok == 1 {
+            let f: [String] = str_split(line, "|")
+            if native_list_len(f) >= 12 {
+                if str_eq(native_list_get(f, 11), "vowel") {
+                    v = native_list_append(v, native_list_get(f, 0))
+                }
+            }
+        }
+        li = li + 1
+    }
+    return v
+}
+
+// Word -> phoneme-sequence cache from lexicon.psv (engram-independent).
+fn organ_lex(path: String) -> [String] {
+    let content: String = fs_read(path)
+    let lines: [String] = str_split(content, "\n")
+    let nl: Int = native_list_len(lines)
+    let m: [String] = native_list_empty()
+    let li: Int = 0
+    while li < nl {
+        let line: String = native_list_get(lines, li)
+        let ok: Int = 1
+        if str_len(line) < 3 {
+            ok = 0
+        }
+        if ok == 1 {
+            if str_char_code(line, 0) == 35 {
+                ok = 0
+            }
+        }
+        if ok == 1 {
+            let f: [String] = str_split(line, "|")
+            if native_list_len(f) >= 2 {
+                m = native_list_append(m, native_list_get(f, 0))
+                m = native_list_append(m, native_list_get(f, 1))
+            }
+        }
+        li = li + 1
+    }
+    return m
+}
@@ -0,0 +1,233 @@
+// speech-ingest.el - The native LOAD step of the ingest organ, for the SPEECH
+// primitives. Reads the acoustic-phonetics SOURCE (elp/data/phonetics.psv) and
+// the pronunciation lexicon SOURCE (elp/data/lexicon.psv) and emits a PHONEME
+// MANIFOLD into the engram: one node per phoneme (faithful, provenance-tagged
+// content) + is_a edges to phoneme-class nodes (a discrete manifold, not islands).
+// The render then PULLS phoneme geometry back from the engram via phon_geo —
+// zero phonetic numbers in code. Source -> manifold -> merge; the same output
+// the polymorphic ingest organ will produce and subsume.
+
+// -- small parsing helpers ---------------------------------------------------
+fn sp_map_get(pairs: [String], key: String) -> String {
+    let n: Int = native_list_len(pairs)
+    let i: Int = 0
+    while i < n - 1 {
+        let k: String = native_list_get(pairs, i)
+        if str_eq(k, key) {
+            return native_list_get(pairs, i + 1)
+        }
+        let i = i + 2
+    }
+    return ""
+}
+
+// read the unsigned integer that follows `key` inside string s (e.g. key "F1=")
+fn parse_uint_from(s: String, key: String) -> Int {
+    let idx: Int = str_index_of(s, key)
+    if idx < 0 {
+        return 0
+    }
+    let start: Int = idx + str_len(key)
+    let n: Int = str_len(s)
+    let i: Int = start
+    let val: Int = 0
+    while i < n {
+        let c: Int = str_char_code(s, i)
+        if c >= 48 {
+            if c <= 57 {
+                val = val * 10 + (c - 48)
+                i = i + 1
+            } else {
+                i = n
+            }
+        } else {
+            i = n
+        }
+    }
+    return val
+}
+
+fn clean_word(w: String) -> String {
+    let low: String = str_to_lower(w)
+    let n: Int = str_len(low)
+    let out: String = ""
+    let i: Int = 0
+    while i < n {
+        let c: Int = str_char_code(low, i)
+        if c >= 97 {
+            if c <= 122 {
+                out = out + str_char_at(low, i)
+            }
+        }
+        i = i + 1
+    }
+    return out
+}
+
+// -- INGEST: acoustic-phonetics source -> phoneme manifold in the engram ------
+// Returns the symbol -> node-id index (pmap) the render reads geometry through.
+fn ingest_phonetics(path: String) -> [String] {
+    let content: String = fs_read(path)
+    let lines: [String] = str_split(content, "\n")
+    let nl: Int = native_list_len(lines)
+    let pmap: [String] = native_list_empty()
+    let classmap: [String] = native_list_empty()
+    let li: Int = 0
+    while li < nl {
+        let line: String = native_list_get(lines, li)
+        let ll: Int = str_len(line)
+        let skip: Int = 0
+        if ll < 5 {
+            skip = 1
+        }
+        if skip == 0 {
+            let first: Int = str_char_code(line, 0)
+            if first == 35 {
+                skip = 1
+            }
+        }
+        if skip == 0 {
+            let f: [String] = str_split(line, "|")
+            let nf: Int = native_list_len(f)
+            if nf >= 12 {
+                let sym: String = native_list_get(f, 0)
+                let f1: String = native_list_get(f, 1)
+                let f2: String = native_list_get(f, 2)
+                let f3: String = native_list_get(f, 3)
+                let b1: String = native_list_get(f, 4)
+                let b2: String = native_list_get(f, 5)
+                let b3: String = native_list_get(f, 6)
+                let vo: String = native_list_get(f, 7)
+                let na: String = native_list_get(f, 8)
+                let du: String = native_list_get(f, 9)
+                let am: String = native_list_get(f, 10)
+                let cls: String = native_list_get(f, 11)
+                let cont: String = "phoneme " + sym + " | f1=" + f1 + " f2=" + f2 + " f3=" + f3 + " bw1=" + b1 + " bw2=" + b2 + " bw3=" + b3 + " voiced=" + vo + " nasal=" + na + " dur=" + du + " amp=" + am + " class=" + cls + " src=PetersonBarney1952-Hillenbrand1995"
+                let id: String = engram_node(cont, "Phoneme", 80)
+                pmap = native_list_append(pmap, sym)
+                pmap = native_list_append(pmap, cont)
+                // manifold edge: phoneme is_a class
+                let cid: String = sp_map_get(classmap, cls)
+                if str_eq(cid, "") {
+                    cid = engram_node("phoneme-class " + cls + " src=acoustic-phonetics", "PhonemeClass", 80)
+                    classmap = native_list_append(classmap, cls)
+                    classmap = native_list_append(classmap, cid)
+                }
+                engram_connect(id, cid, 80, "is_a")
+            }
+        }
+        li = li + 1
+    }
+    return pmap
+}
+
+// -- INGEST: pronunciation lexicon source -> word nodes ----------------------
+fn ingest_lexicon(path: String) -> [String] {
+    let content: String = fs_read(path)
+    let lines: [String] = str_split(content, "\n")
+    let nl: Int = native_list_len(lines)
+    let lmap: [String] = native_list_empty()
+    let li: Int = 0
+    while li < nl {
+        let line: String = native_list_get(lines, li)
+        let ll: Int = str_len(line)
+        let skip: Int = 0
+        if ll < 3 {
+            skip = 1
+        }
+        if skip == 0 {
+            let first: Int = str_char_code(line, 0)
+            if first == 35 {
+                skip = 1
+            }
+        }
+        if skip == 0 {
+            let f: [String] = str_split(line, "|")
+            let nf: Int = native_list_len(f)
+            if nf >= 2 {
+                let word: String = native_list_get(f, 0)
+                let seq: String = native_list_get(f, 1)
+                let id: String = engram_node("word " + word + " phonemes " + seq + " src=lexicon", "Pronunciation", 80)
+                lmap = native_list_append(lmap, word)
+                lmap = native_list_append(lmap, seq)
+            }
+        }
+        li = li + 1
+    }
+    return lmap
+}
+
+// -- READ geometry back from the engram (the render's afferent lookup) --------
+// phon_geo(sym) -> [F1,F2,F3,B1,B2,B3,voiced,nasal,dur,amp], parsed from the
+// ingested phoneme node's content. NO formant numbers live in this code.
+fn phon_geo(pmap: [String], sym: String) -> [Int] {
+    let id: String = sp_map_get(pmap, sym)
+    if str_eq(id, "") {
+        id = sp_map_get(pmap, "AX")
+    }
+    let out: [Int] = native_list_empty()
+    if str_eq(id, "") {
+        let out = native_list_append(out, 500)
+        let out = native_list_append(out, 1500)
+        let out = native_list_append(out, 2500)
+        let out = native_list_append(out, 80)
+        let out = native_list_append(out, 100)
+        let out = native_list_append(out, 150)
+        let out = native_list_append(out, 1)
+        let out = native_list_append(out, 0)
+        let out = native_list_append(out, 80)
+        let out = native_list_append(out, 80)
+        return out
+    }
+    let j: String = id
+    let out = native_list_append(out, parse_uint_from(j, "f1="))
+    let out = native_list_append(out, parse_uint_from(j, "f2="))
+    let out = native_list_append(out, parse_uint_from(j, "f3="))
+    let out = native_list_append(out, parse_uint_from(j, "bw1="))
+    let out = native_list_append(out, parse_uint_from(j, "bw2="))
+    let out = native_list_append(out, parse_uint_from(j, "bw3="))
+    let out = native_list_append(out, parse_uint_from(j, "voiced="))
+    let out = native_list_append(out, parse_uint_from(j, "nasal="))
+    let out = native_list_append(out, parse_uint_from(j, "dur="))
+    let out = native_list_append(out, parse_uint_from(j, "amp="))
+    return out
+}
+
+// word -> phoneme codes, read from the ingested lexicon node.
+fn word_phonemes(lmap: [String], word: String) -> [String] {
+    let id: String = sp_map_get(lmap, word)
+    if str_eq(id, "") {
+        let r: [String] = native_list_empty()
+        let r = native_list_append(r, "AX")
+        return r
+    }
+    return str_split(id, " ")
+}
+
+// realized text -> flat phoneme-code sequence (SIL between words + at ends).
+fn text_phonemes(lmap: [String], text: String) -> [String] {
+    let words: [String] = str_split(text, " ")
+    let nw: Int = native_list_len(words)
+    let seq: [String] = native_list_empty()
+    let seq = native_list_append(seq, "SIL")
+    let wi: Int = 0
+    while wi < nw {
+        let raw: String = native_list_get(words, wi)
+        let w: String = clean_word(raw)
+        if str_eq(w, "") {
+            wi = wi + 1
+        } else {
+            let ph: [String] = word_phonemes(lmap, w)
+            let np: Int = native_list_len(ph)
+            let pi: Int = 0
+            while pi < np {
+                let code: String = native_list_get(ph, pi)
+                seq = native_list_append(seq, code)
+                pi = pi + 1
+            }
+            seq = native_list_append(seq, "SIL")
+            wi = wi + 1
+        }
+    }
+    return seq
+}
@@ -0,0 +1,460 @@
+// speech.el - The native SPEECH render path + voice-by-imitation extractor.
+//
+// Speech = the AUDIO surface (surface_profile_audio) rendering LANGUAGE-meaning
+// through a VOICE signature. The realizer's language faculty supplies the words
+// (meaning -> sem_realize -> text); this module turns text -> phonemes (phonetics.el)
+// -> a formant-target track over time -> SUPERPOSES formant resonances over a
+// glottal source (own-core formant synthesis, the exact integer mirror of the
+// music additive superpose) -> own-core PCM/WAV. Two paths:
+//   (1) RENDER:  speak(text, voice) -> spoken WAV.
+//   (2) IMITATE: voice_analyze(pcm) -> a voice signature grabbed BY EAR
+//                (autocorrelation pitch + integer-DFT formant peaks), then render
+//                any new meaning in that voice. An impression, not a corpus.
+// All integer/fixed-point (EL float arithmetic is unusable).
+
+// -- Own-core integer sine (Bhaskara I), phase 0..65535 = one cycle -----------
+fn sp_sin(phase: Int) -> Int {
+    let deg: Int = phase * 360 / 65536
+    let neg: Int = 0
+    if deg > 180 {
+        deg = deg - 180
+        neg = 1
+    }
+    let t: Int = deg * (180 - deg)
+    let num: Int = 32767 * 4 * t
+    let den: Int = 40500 - t
+    let v: Int = num / den
+    if neg == 1 {
+        v = 0 - v
+    }
+    return v
+}
+
+fn sp_cos(phase: Int) -> Int {
+    let p: Int = phase + 16384
+    p = p - (p / 65536) * 65536
+    return sp_sin(p)
+}
+
+// One formant resonance (Lorentzian peak), Q15. Peak 32767 at f=fc.
+fn sp_gain(f: Int, fc: Int, bw: Int) -> Int {
+    let d: Int = f - fc
+    let den: Int = d * d + bw * bw
+    let num: Int = 32767 * bw * bw
+    return num / den
+}
+
+fn sp_isqrt(n: Int) -> Int {
+    if n <= 0 {
+        return 0
+    }
+    let x: Int = n
+    let y: Int = (x + 1) / 2
+    while y < x {
+        x = y
+        y = (x + n / x) / 2
+    }
+    return x
+}
+
+// -- WAV serializer (thin medium; the only non-DSP glue) ---------------------
+fn wav_le16(buf: String, off: Int, v: Int) -> String {
+    let u: Int = v
+    if u < 0 {
+        u = u + 65536
+    }
+    let lo: Int = u - (u / 256) * 256
+    let hi: Int = u / 256
+    let b: String = __str_set_char(buf, off, lo)
+    b = __str_set_char(b, off + 1, hi)
+    return b
+}
+
+fn wav_le32(buf: String, off: Int, v: Int) -> String {
+    let b0: Int = v - (v / 256) * 256
+    let r1: Int = v / 256
+    let b1: Int = r1 - (r1 / 256) * 256
+    let r2: Int = r1 / 256
+    let b2: Int = r2 - (r2 / 256) * 256
+    let b3: Int = r2 / 256
+    let b: String = __str_set_char(buf, off, b0)
+    b = __str_set_char(b, off + 1, b1)
+    b = __str_set_char(b, off + 2, b2)
+    b = __str_set_char(b, off + 3, b3)
+    return b
+}
+
+fn wav_ascii(buf: String, off: Int, s: String) -> String {
+    let n: Int = str_len(s)
+    let i: Int = 0
+    let b: String = buf
+    while i < n {
+        let c: Int = str_char_code(s, i)
+        b = __str_set_char(b, off + i, c)
+        i = i + 1
+    }
+    return b
+}
+
+fn write_wav(samples: [Int], sr: Int, path: String) -> Bool {
+    let ns: Int = native_list_len(samples)
+    let datalen: Int = ns * 2
+    let total: Int = 44 + datalen
+    let buf: String = __str_alloc(total)
+    buf = wav_ascii(buf, 0, "RIFF")
+    buf = wav_le32(buf, 4, 36 + datalen)
+    buf = wav_ascii(buf, 8, "WAVE")
+    buf = wav_ascii(buf, 12, "fmt ")
+    buf = wav_le32(buf, 16, 16)
+    buf = wav_le16(buf, 20, 1)
+    buf = wav_le16(buf, 22, 1)
+    buf = wav_le32(buf, 24, sr)
+    buf = wav_le32(buf, 28, sr * 2)
+    buf = wav_le16(buf, 32, 2)
+    buf = wav_le16(buf, 34, 16)
+    buf = wav_ascii(buf, 36, "data")
+    buf = wav_le32(buf, 40, datalen)
+    let j: Int = 0
+    let off: Int = 44
+    while j < ns {
+        let raw: Int = native_list_get(samples, j)
+        buf = wav_le16(buf, off, raw)
+        off = off + 2
+        j = j + 1
+    }
+    return __fs_write_bytes(path, buf, total)
+}
+
+// One formant resonance as a float Lorentzian peak (own-core physics).
+fn fgain(f: Float, fc: Float, bw: Float) -> Float {
+    let d: Float = f - fc
+    return (bw * bw) / (d * d + bw * bw)
+}
+
+// His PITCH MELODY from measured prosody [f0_median, f0_min, f0_max, declination].
+// A natural statement shape over the utterance: onset rise to the median, a
+// near-flat body (his declination is ~0.6 Hz/s), and a final fall toward f0_min.
+// Follows his melody + range, not a fixed 0.85 decline. gidx/total = position.
+fn prosody_f0(pros: [Int], gidx: Int, total: Int) -> Int {
+    let med: Int = native_list_get(pros, 0)
+    let lo: Int = native_list_get(pros, 1)
+    let hi: Int = native_list_get(pros, 2)
+    let p: Int = gidx * 1000 / total
+    let f0: Int = med
+    if p < 150 {
+        f0 = lo + (med - lo) * p / 150
+    } else {
+        if p > 700 {
+            f0 = med + (lo - med) * (p - 700) / 300
+        } else {
+            f0 = med
+        }
+    }
+    if f0 < lo {
+        f0 = lo
+    }
+    if f0 > hi {
+        f0 = hi
+    }
+    return f0
+}
+
+// -- The render: phoneme codes + voice signature -> normalized PCM samples ----
+// Formant geometry per phoneme is READ FROM THE ENGRAM (pmap) via phon_geo — no
+// table in code. The optional ACCENT map (amap) composes a transform onto the
+// voice (voice (+) accent, separable): RP formant overrides read from the accent
+// manifold + a non-rhotic coda-R drop. Empty amap = base General-American.
+// Synthesis is FLOAT: a real phase accumulator + math_sin, superposition physics.
+fn synth_codes_accent(codes0: [String], voice: [String], pmap: [String], amap: [String], vset: [String], vmap: [String], prosody: [Int]) -> [Int] {
+    let sr: Int = 16000
+    let srf: Float = 16000.0
+    let two_pi: Float = 6.283185307
+    let kf: Int = voice_get_int(voice, "kf")
+    let f0s: Int = voice_get_int(voice, "f0")
+    let f0e: Int = voice_get_int(voice, "f0_end")
+    let durm: Int = voice_get_int(voice, "dur")
+    if kf <= 0 {
+        kf = 1000
+    }
+    if durm <= 0 {
+        durm = 1000
+    }
+    let use_accent: Int = 0
+    if native_list_len(amap) > 0 {
+        use_accent = 1
+    }
+    let codes: [String] = codes0
+    if use_accent == 1 {
+        if is_nonrhotic(amap) == 1 {
+            codes = apply_rhoticity(codes0, vset)
+        }
+    }
+    let nc: Int = native_list_len(codes)
+
+    // pass 1: per-segment sample counts + total
+    let segn: [Int] = native_list_empty()
+    let total: Int = 0
+    let ci: Int = 0
+    while ci < nc {
+        let code: String = native_list_get(codes, ci)
+        let p: [Int] = phon_geo(pmap, code)
+        let durms: Int = native_list_get(p, 8)
+        let ns: Int = durms * 16 * durm / 1000
+        segn = native_list_append(segn, ns)
+        total = total + ns
+        ci = ci + 1
+    }
+    if total <= 0 {
+        total = 1
+    }
+
+    // pass 2: synthesize
+    let samples: [Int] = native_list_empty()
+    let phasef: Float = 0.0
+    let gidx: Int = 0
+    let prevF1: Int = 500 * kf / 1000
+    let prevF2: Int = 1500 * kf / 1000
+    let prevF3: Int = 2500 * kf / 1000
+    let nstate: Int = 22695
+    let maxabs: Int = 1
+
+    let ci2: Int = 0
+    while ci2 < nc {
+        let code: String = native_list_get(codes, ci2)
+        let p: [Int] = phon_geo(pmap, code)
+        let rf1: Int = native_list_get(p, 0)
+        let rf2: Int = native_list_get(p, 1)
+        let rf3: Int = native_list_get(p, 2)
+        if use_accent == 1 {
+            let ov: [Int] = accent_formants(amap, code)
+            if native_list_len(ov) >= 3 {
+                rf1 = native_list_get(ov, 0)
+                rf2 = native_list_get(ov, 1)
+                rf3 = native_list_get(ov, 2)
+            }
+        }
+        // HIS measured vowel target overrides the generic/kf path (absolute Hz —
+        // his formants already encode his vocal tract, so no kf scaling).
+        let usekf: Int = 1
+        if native_list_len(vmap) > 0 {
+            let hv: [Int] = vmap_get(vmap, code)
+            if native_list_len(hv) >= 3 {
+                rf1 = native_list_get(hv, 0)
+                rf2 = native_list_get(hv, 1)
+                rf3 = native_list_get(hv, 2)
+                usekf = 0
+            }
+        }
+        let F1t: Int = rf1 * kf / 1000
+        let F2t: Int = rf2 * kf / 1000
+        let F3t: Int = rf3 * kf / 1000
+        if usekf == 0 {
+            F1t = rf1
+            F2t = rf2
+            F3t = rf3
+        }
+        let B1: Int = native_list_get(p, 3)
+        let B2: Int = native_list_get(p, 4)
+        let B3: Int = native_list_get(p, 5)
+        let voiced: Int = native_list_get(p, 6)
+        let ampv: Int = native_list_get(p, 9)
+        let ns: Int = native_list_get(segn, ci2)
+        let trans: Int = ns / 2
+        if trans > 560 {
+            trans = 560
+        }
+        if trans < 1 {
+            trans = 1
+        }
+        let k: Int = 0
+        while k < ns {
+            let cF1: Int = F1t
+            let cF2: Int = F2t
+            let cF3: Int = F3t
+            if k < trans {
+                cF1 = prevF1 + (F1t - prevF1) * k / trans
+                cF2 = prevF2 + (F2t - prevF2) * k / trans
+                cF3 = prevF3 + (F3t - prevF3) * k / trans
+            }
+            let f0c: Int = f0s + (f0e - f0s) * gidx / total
+            if native_list_len(prosody) >= 3 {
+                f0c = prosody_f0(prosody, gidx, total)
+            }
+            if f0c < 40 {
+                f0c = 40
+            }
+            let env: Int = 32767
+            let ar: Int = 96
+            if k < ar {
+                env = 32767 * k / ar
+            }
+            let tail: Int = ns - k
+            if tail < ar {
+                env = 32767 * tail / ar
+            }
+            let f0cf: Float = int_to_float(f0c)
+            phasef = phasef + two_pi * f0cf / srf
+            if phasef > two_pi {
+                phasef = phasef - two_pi
+            }
+
+            let s: Int = 0
+            if voiced == 1 {
+                let cF1f: Float = int_to_float(cF1)
+                let cF2f: Float = int_to_float(cF2)
+                let cF3f: Float = int_to_float(cF3)
+                let B1f: Float = int_to_float(B1)
+                let B2f: Float = int_to_float(B2)
+                let B3f: Float = int_to_float(B3)
+                let acc: Float = 0.0
+                let h: Int = 1
+                while h <= 50 {
+                    let hf: Float = int_to_float(h)
+                    let fhf: Float = hf * f0cf
+                    if fhf < 7900.0 {
+                        let sv: Float = math_sin(phasef * hf)
+                        let src: Float = 1.0 / hf
+                        let g1: Float = fgain(fhf, cF1f, B1f)
+                        let g2: Float = fgain(fhf, cF2f, B2f)
+                        let g3: Float = fgain(fhf, cF3f, B3f)
+                        let g: Float = g1 + g2 + g3
+                        acc = acc + src * g * sv
+                    }
+                    h = h + 1
+                }
+                s = float_to_int(acc * 4000.0)
+            } else {
+                if ampv > 0 {
+                    nstate = nstate * 1103515245 + 12345
+                    nstate = nstate - (nstate / 2147483648) * 2147483648
+                    if nstate < 0 {
+                        nstate = 0 - nstate
+                    }
+                    let nz: Int = nstate / 32768 - 32768
+                    s = nz
+                }
+            }
+            s = s * ampv / 100
+            s = s * env / 32767
+            samples = native_list_append(samples, s)
+            let a: Int = s
+            if a < 0 {
+                a = 0 - a
+            }
+            if a > maxabs {
+                maxabs = a
+            }
+            gidx = gidx + 1
+            k = k + 1
+        }
+        prevF1 = F1t
+        prevF2 = F2t
+        prevF3 = F3t
+        ci2 = ci2 + 1
+    }
+
+    // normalize to int16 range (~22000 peak)
+    let out: [Int] = native_list_empty()
+    let ntot: Int = native_list_len(samples)
+    let j: Int = 0
+    while j < ntot {
+        let raw: Int = native_list_get(samples, j)
+        let v: Int = raw * 22000 / maxabs
+        out = native_list_append(out, v)
+        j = j + 1
+    }
+    return out
+}
+
+// GA convenience wrapper (no accent) — keeps the base render path.
+fn synth_codes(codes: [String], voice: [String], pmap: [String]) -> [Int] {
+    let noacc: [String] = native_list_empty()
+    let novset: [String] = native_list_empty()
+    let novmap: [String] = native_list_empty()
+    let nopros: [Int] = native_list_empty()
+    return synth_codes_accent(codes, voice, pmap, noacc, novset, novmap, nopros)
+}
+
+// -- Voice-by-imitation: HEAR a PCM sample -> extract the voice signature -----
+// Pitch by autocorrelation; vocal-tract scale (kf) from the F1 formant peak of a
+// heard sustained vowel /AA/ (nominal F1 = 730 Hz) via an integer DFT. The
+// analyzer sees ONLY the PCM samples — never the source signature numbers — so
+// recovery is genuinely by ear.
+fn voice_f0(samples: [Int], sr: Int) -> Int {
+    let n: Int = native_list_len(samples)
+    let start: Int = n / 4
+    let end: Int = n * 3 / 4
+    // bound the analysis window so accumulators can never overflow on long input
+    if end - start > 6000 {
+        end = start + 6000
+    }
+    let minlag: Int = sr / 300
+    let maxlag: Int = sr / 75
+    let best: Int = 0
+    let bestlag: Int = minlag
+    let lag: Int = minlag
+    while lag <= maxlag {
+        let sum: Int = 0
+        let i: Int = start
+        while i < end {
+            let ai: Int = native_list_get(samples, i)
+            let bi: Int = native_list_get(samples, i + lag)
+            sum = sum + ai * bi / 256
+            i = i + 2
+        }
+        if sum > best {
+            best = sum
+            bestlag = lag
+        }
+        lag = lag + 1
+    }
+    if bestlag < 1 {
+        bestlag = 1
+    }
+    return sr / bestlag
+}
+
+fn voice_peak_in_band(samples: [Int], sr: Int, flo: Int, fhi: Int) -> Int {
+    let n: Int = native_list_len(samples)
+    let start: Int = n / 4
+    let end: Int = n * 3 / 4
+    // bound the DFT window: re/im are accumulated /4096, and re*re must stay in
+    // int64 — cap terms so (window/2)*(peak_term) squared cannot overflow.
+    if end - start > 3000 {
+        end = start + 3000
+    }
+    let bestmag: Int = 0
+    let bestf: Int = flo
+    let f: Int = flo
+    while f <= fhi {
+        let re: Int = 0
+        let im: Int = 0
+        let i: Int = start
+        while i < end {
+            let x: Int = native_list_get(samples, i)
+            let ph: Int = i * f * 65536 / sr
+            ph = ph - (ph / 65536) * 65536
+            let cq: Int = sp_cos(ph)
+            let sq: Int = sp_sin(ph)
+            re = re + x * cq / 4096
+            im = im + x * sq / 4096
+            i = i + 2
+        }
+        let mag: Int = re * re + im * im
+        if mag > bestmag {
+            bestmag = mag
+            bestf = f
+        }
+        f = f + 25
+    }
+    return bestf
+}
+
+// Analyze a heard sustained /AA/ -> a full voice signature (by ear).
+fn voice_analyze(samples: [Int], sr: Int) -> [String] {
+    let f0: Int = voice_f0(samples, sr)
+    let f1: Int = voice_peak_in_band(samples, sr, 450, 1150)
+    let kf: Int = 1000 * f1 / 730
+    let f0e: Int = f0 * 85 / 100
+    return voice_new("imitated", f0, f0e, kf, 1000, 1000, 8)
+}
@@ -0,0 +1,244 @@
+// voice-ingest.el - The LIVE VOICE LOOP reshape + ingest-as-geometry.
+//
+// EL cannot read a binary WAV (fs_read NUL-truncates), so the thin-medium DSP
+// extractor is periph's `voiceprint` (autocorr F0 + LPC formants), equivalent to
+// our own voice_analyze. This module: (1) RESHAPE the voiceprint JSON (TEXT) into
+// the organ voice-signature schema; (2) INGEST it as a GEOMETRY manifold in the
+// engram and engram_save it to a file; (3) READ the target signature BACK from
+// that geometry (engram_load + scan + filter), never from the json or a table.
+// HONEST: this reaches for pitch + a coarse vocal-tract scale (kf). It is NOT a
+// clone — no glottal timbre, vowel-space, or articulation is captured.
+
+fn parse_leading_int(s: String) -> Int {
+    let n: Int = str_len(s)
+    let i: Int = 0
+    let v: Int = 0
+    let started: Int = 0
+    while i < n {
+        let c: Int = str_char_code(s, i)
+        if c >= 48 {
+            if c <= 57 {
+                v = v * 10 + (c - 48)
+                started = 1
+                i = i + 1
+            } else {
+                i = n
+            }
+        } else {
+            if started == 1 {
+                i = n
+            } else {
+                i = i + 1
+            }
+        }
+    }
+    return v
+}
+
+// voiceprint JSON -> organ voice-signature source file; returns [f0,f0_end,kf,f1,f2,f3].
+fn reshape_voiceprint(vppath: String, outjson: String) -> [Int] {
+    let j: String = fs_read(vppath)
+    let f0: Int = parse_uint_from(j, "f0_hz\":")
+    let fp: Int = str_index_of(j, "formants_hz")
+    let tail: String = str_slice(j, fp, fp + 120)
+    let br: Int = str_index_of(tail, "[")
+    let arr: String = str_slice(tail, br + 1, str_len(tail))
+    let f1: Int = parse_leading_int(arr)
+    let c1: Int = str_index_of(arr, ",")
+    let a2: String = str_slice(arr, c1 + 1, str_len(arr))
+    let f2: Int = parse_leading_int(a2)
+    let c2: Int = str_index_of(a2, ",")
+    let a3: String = str_slice(a2, c2 + 1, str_len(a2))
+    let f3: Int = parse_leading_int(a3)
+    let f0e: Int = f0 * 85 / 100
+    // derive kf honestly: coarse vocal-tract scale from the formant pattern
+    let t1: Int = 1000 * f1 / 500
+    let t2: Int = 1000 * f2 / 1500
+    let t3: Int = 1000 * f3 / 2500
+    let kf: Int = (t1 + t2 + t3) / 3
+    if kf < 800 {
+        kf = 800
+    }
+    if kf > 1400 {
+        kf = 1400
+    }
+    let js: String = "{\"dataset\":\"will-voice-signature\",\"primitive_type\":\"voice\",\"grounding\":\"measured\",\"provenance\":\"Will live 30s read 2026-08-15 (elp/data/live/will30_clean.wav, 27.0s) SUPERSEDES the coarse 10s sample; F0+formants via periph voiceprint (autocorr+LPC), averaged over his full vowel set. Still the 11-number average: no coarticulation/prosody. COARSE — pitch + vocal-tract scale, NOT a clone.\",\"records\":[{\"key\":\"will\",\"features\":{\"source\":\"live-mic\"},\"attributes\":{\"f0\":" + int_to_str(f0) + ",\"f0_end\":" + int_to_str(f0e) + ",\"kf\":" + int_to_str(kf) + ",\"f1\":" + int_to_str(f1) + ",\"f2\":" + int_to_str(f2) + ",\"f3\":" + int_to_str(f3) + "}}]}"
+    let okw: Bool = fs_write(outjson, js)
+    let r: [Int] = native_list_empty()
+    let r = native_list_append(r, f0)
+    let r = native_list_append(r, f0e)
+    let r = native_list_append(r, kf)
+    let r = native_list_append(r, f1)
+    let r = native_list_append(r, f2)
+    let r = native_list_append(r, f3)
+    return r
+}
+
+// Ingest the signature as a manifold (a set-hub + the will node + a member edge)
+// and engram_save it to a reloadable file. grounding:measured self-declared.
+fn ingest_voice(sig: [Int], savepath: String) -> Int {
+    let f0: Int = native_list_get(sig, 0)
+    let f0e: Int = native_list_get(sig, 1)
+    let kf: Int = native_list_get(sig, 2)
+    let f1: Int = native_list_get(sig, 3)
+    let f2: Int = native_list_get(sig, 4)
+    let f3: Int = native_list_get(sig, 5)
+    let hub: String = engram_node("voice-signature-set will grounding=measured src=periph-voiceprint", "VoiceSet", 90)
+    let cont: String = "voice will | f0=" + int_to_str(f0) + " f0_end=" + int_to_str(f0e) + " kf=" + int_to_str(kf) + " f1=" + int_to_str(f1) + " f2=" + int_to_str(f2) + " f3=" + int_to_str(f3) + " grounding=measured src=periph-voiceprint-30s supersedes=prior-voice-region prov=COARSE-pitch+tractscale-NOT-a-clone"
+    let id: String = engram_node(cont, "Voice", 90)
+    engram_connect(id, hub, 90, "member_of")
+    let oks: Bool = engram_save(savepath)
+    return 1
+}
+
+// READ the target voice back FROM the ingested geometry (engram_load + scan +
+// client-filter for "voice will"). Returns [f0,f0_end,kf,f1,f2,f3] or empty.
+fn load_voice(savepath: String) -> [Int] {
+    let ok: Bool = engram_load(savepath)
+    let r: [Int] = native_list_empty()
+    if ok == false {
+        return r
+    }
+    let j: String = engram_scan_nodes_json(200, 0)
+    let p: Int = str_index_of(j, "voice will ")
+    if p < 0 {
+        return r
+    }
+    let win: String = str_slice(j, p, p + 200)
+    let r = native_list_append(r, parse_uint_from(win, "f0="))
+    let r = native_list_append(r, parse_uint_from(win, "f0_end="))
+    let r = native_list_append(r, parse_uint_from(win, "kf="))
+    let r = native_list_append(r, parse_uint_from(win, "f1="))
+    let r = native_list_append(r, parse_uint_from(win, "f2="))
+    let r = native_list_append(r, parse_uint_from(win, "f3="))
+    return r
+}
+
+// ---- Vowel-space + prosody: ingest-as-geometry + read-back (no source layer) --
+// vowel target lookup from the ingested vowel-space manifold: sym -> [f1,f2,f3].
+fn vmap_get(vmap: [String], code: String) -> [Int] {
+    let out: [Int] = native_list_empty()
+    let id: String = sp_map_get(vmap, code)
+    if str_eq(id, "") {
+        return out
+    }
+    let f1: Int = parse_uint_from(id, "f1=")
+    if f1 <= 0 {
+        return out
+    }
+    let out = native_list_append(out, f1)
+    let out = native_list_append(out, parse_uint_from(id, "f2="))
+    let out = native_list_append(out, parse_uint_from(id, "f3="))
+    return out
+}
+
+// Ingest his measured vowel space + prosody as ONE manifold (VowelSpace hub +
+// per-vowel target nodes + a prosody node) and engram_save it. Fresh empty store
+// per run => set-replace, no duplicate.
+fn ingest_voicegeom(vpath: String, ppath: String, savepath: String) -> Int {
+    let hub: String = engram_node("vowel-space-set will grounding=measured src=lpc-formant-track-30s", "VowelSpace", 90)
+    let content: String = fs_read(vpath)
+    let lines: [String] = str_split(content, "\n")
+    let nl: Int = native_list_len(lines)
+    let li: Int = 0
+    while li < nl {
+        let line: String = native_list_get(lines, li)
+        let ok: Int = 1
+        if str_len(line) < 5 {
+            ok = 0
+        }
+        if ok == 1 {
+            if str_char_code(line, 0) == 35 {
+                ok = 0
+            }
+        }
+        if ok == 1 {
+            let f: [String] = str_split(line, "|")
+            if native_list_len(f) >= 5 {
+                let sym: String = native_list_get(f, 0)
+                let cont: String = "vowel-target will " + sym + " | f1=" + native_list_get(f, 1) + " f2=" + native_list_get(f, 2) + " f3=" + native_list_get(f, 3) + " n=" + native_list_get(f, 4) + " grounding=measured src=lpc-formant-track-30s"
+                let id: String = engram_node(cont, "VowelTarget", 90)
+                engram_connect(id, hub, 90, "member_of")
+            }
+        }
+        li = li + 1
+    }
+    let pc: String = fs_read(ppath)
+    let plines: [String] = str_split(pc, "\n")
+    let pnl: Int = native_list_len(plines)
+    let pi: Int = 0
+    while pi < pnl {
+        let pl: String = native_list_get(plines, pi)
+        let ok2: Int = 1
+        if str_len(pl) < 5 {
+            ok2 = 0
+        }
+        if ok2 == 1 {
+            if str_char_code(pl, 0) == 35 {
+                ok2 = 0
+            }
+        }
+        if ok2 == 1 {
+            let pf: [String] = str_split(pl, "|")
+            if native_list_len(pf) >= 4 {
+                let pcont: String = "prosody will | f0_median=" + native_list_get(pf, 0) + " f0_min=" + native_list_get(pf, 1) + " f0_max=" + native_list_get(pf, 2) + " declination=" + native_list_get(pf, 3) + " src=f0-contour-30s"
+                let pid: String = engram_node(pcont, "Prosody", 90)
+                engram_connect(pid, hub, 90, "prosody_of")
+            }
+        }
+        pi = pi + 1
+    }
+    let oks: Bool = engram_save(savepath)
+    return 1
+}
+
+// Read the vowel-space back from geometry; prosody folded under key __PROSODY__.
+fn load_voicegeom(savepath: String) -> [String] {
+    let m: [String] = native_list_empty()
+    let ok: Bool = engram_load(savepath)
+    if ok == false {
+        return m
+    }
+    let j: String = engram_scan_nodes_json(400, 0)
+    let jl: Int = str_len(j)
+    let off: Int = 0
+    while off < jl {
+        let rest: String = str_slice(j, off, jl)
+        let p: Int = str_index_of(rest, "vowel-target will ")
+        if p < 0 {
+            off = jl
+        } else {
+            let abs: Int = off + p
+            let win: String = str_slice(j, abs, abs + 140)
+            let after: String = str_slice(win, 18, str_len(win))
+            let sp: Int = str_index_of(after, " ")
+            if sp > 0 {
+                let sym: String = str_slice(after, 0, sp)
+                m = native_list_append(m, sym)
+                m = native_list_append(m, win)
+            }
+            off = abs + 18
+        }
+    }
+    let pp: Int = str_index_of(j, "prosody will ")
+    if pp >= 0 {
+        let pwin: String = str_slice(j, pp, pp + 160)
+        m = native_list_append(m, "__PROSODY__")
+        m = native_list_append(m, pwin)
+    }
+    return m
+}
+
+// Prosody stats [f0_median, f0_min, f0_max, declination] read from geometry.
+fn prosody_from(vmap: [String]) -> [Int] {
+    let out: [Int] = native_list_empty()
+    let id: String = sp_map_get(vmap, "__PROSODY__")
+    if str_eq(id, "") {
+        return out
+    }
+    let out = native_list_append(out, parse_uint_from(id, "f0_median="))
+    let out = native_list_append(out, parse_uint_from(id, "f0_min="))
+    let out = native_list_append(out, parse_uint_from(id, "f0_max="))
+    let out = native_list_append(out, parse_uint_from(id, "declination="))
+    return out
+}
@@ -0,0 +1,85 @@
+// voice-profile.el - The VOICE signature as a pluggable PROFILE.
+//
+// Exact mirror of surface-profile.el / language-profile.el: a voice is a
+// [String] slot-map read via voice_get, the SAME mechanism the realizer uses
+// for language and surface. Where an instrument signature (a few dozen numbers)
+// is the timbre of a musical tone, a VOICE signature is the timbre of the vocal
+// tract — the instrument that renders LANGUAGE-meaning as SPEECH on the audio
+// surface. Physics (source-filter), not a recorded corpus.
+//
+// The signature is a few numbers, all integer (EL float arithmetic is unusable):
+//   name    - label
+//   f0      - base pitch, Hz (glottal source rate at utterance start)
+//   f0_end  - pitch at utterance end (declination -> falling = declarative)
+//   kf      - formant scale in PER-MILLE (1000 = x1.0). Encodes vocal-tract
+//             length: shorter tract (child/female) -> higher kf. Scales every
+//             phoneme's nominal formant: F_actual = F_nominal * kf / 1000.
+//   dur     - speaking-rate multiplier in per-mille (1000 = nominal; >1000 slower)
+//   tilt    - source spectral tilt (per-mille; higher = darker/steeper rolloff)
+//   breath  - breathiness 0..100 (aspiration mixed into the source)
+//
+// A voice is grabbed BY EAR (voice_analyze in speech.el extracts these numbers
+// from a short PCM sample — an impression, not 10h of training), or declared.
+
+fn voice_new(name: String, f0: Int, f0_end: Int, kf: Int, dur: Int, tilt: Int, breath: Int) -> [String] {
+    let r: [String] = native_list_empty()
+    let r = native_list_append(r, "name")
+    let r = native_list_append(r, name)
+    let r = native_list_append(r, "f0")
+    let r = native_list_append(r, int_to_str(f0))
+    let r = native_list_append(r, "f0_end")
+    let r = native_list_append(r, int_to_str(f0_end))
+    let r = native_list_append(r, "kf")
+    let r = native_list_append(r, int_to_str(kf))
+    let r = native_list_append(r, "dur")
+    let r = native_list_append(r, int_to_str(dur))
+    let r = native_list_append(r, "tilt")
+    let r = native_list_append(r, int_to_str(tilt))
+    let r = native_list_append(r, "breath")
+    let r = native_list_append(r, int_to_str(breath))
+    return r
+}
+
+// Accessor — identical convention to surface_get / lang_get.
+fn voice_get(profile: [String], key: String) -> String {
+    let n: Int = native_list_len(profile)
+    let i: Int = 0
+    while i < n - 1 {
+        let k: String = native_list_get(profile, i)
+        if str_eq(k, key) {
+            return native_list_get(profile, i + 1)
+        }
+        let i = i + 2
+    }
+    return ""
+}
+
+fn voice_get_int(profile: [String], key: String) -> Int {
+    let s: String = voice_get(profile, key)
+    if str_eq(s, "") {
+        return 0
+    }
+    return str_to_int(s)
+}
+
+// -- Built-in voices ---------------------------------------------------------
+
+// Neuron's own voice: calm, precise, androgynous-neutral. Low-ish base pitch,
+// gentle declination, near-neutral vocal-tract length.
+fn voice_neuron() -> [String] {
+    return voice_new("neuron", 112, 96, 1020, 1000, 1000, 6)
+}
+
+// Will's voice signature, built from the INGESTED geometry (f0/f0_end/kf read
+// back from the will-voice manifold — passed in, never hardcoded). Composable
+// with an accent transform exactly like voice_neuron() (voice (+) accent).
+fn voice_will(f0: Int, f0_end: Int, kf: Int) -> [String] {
+    return voice_new("will", f0, f0_end, kf, 1000, 1000, 6)
+}
+
+// A deliberately DISTINCT target voice for the imitation proof: higher pitch,
+// shorter vocal tract (kf=1.20) -> a clearly different speaker. Neuron will
+// HEAR a sample of this voice and reconstruct these numbers by ear.
+fn voice_target_a() -> [String] {
+    return voice_new("target_a", 178, 150, 1200, 950, 1000, 10)
+}
@@ -0,0 +1,45 @@
+// speech-accent-demo.el - PROOF: Neuron speaks with a BRITISH accent, where the
+// accent is a TRANSFORM composed onto the voice (voice (+) accent, separable),
+// INGESTED as geometry (not a table). Same voice, accent toggled on/off = RP/GA.
+
+fn main() {
+    let outdir: String = "/Users/will/Development/neuron-technologies/foundation/el/.claude/worktrees/agent-acc02900ef4ade35e/elp/tests/examples/out/"
+
+    // LEARN: base phonetics + lexicon + the British-RP accent transform, all as
+    // ingested geometry (source -> manifold -> engram).
+    let pmap: [String] = ingest_phonetics("elp/data/phonetics.psv")
+    let lmap: [String] = ingest_lexicon("elp/data/lexicon.psv")
+    let amap: [String] = ingest_accent("elp/data/british-accent.psv")
+    println("[learn] phonemes=" + int_to_str(native_list_len(pmap) / 2) + " words=" + int_to_str(native_list_len(lmap) / 2) + " accent_targets=" + int_to_str(native_list_len(amap) / 2))
+
+    let neuron: [String] = voice_neuron()
+    let noaccent: [String] = native_list_empty()
+
+    // -- Sentence 1: "I am Neuron." from meaning ----------------------------
+    let fr1: [String] = sem_frame("describe", "I", "Neuron", "")
+    let t1: String = sem_realize(fr1)
+    let c1: [String] = text_phonemes(lmap, t1)
+    println("[s1] " + t1 + " :: " + list_join(c1, " "))
+
+    // separability: SAME voice, accent OFF (GA) vs ON (RP)
+    let ga: [Int] = synth_codes_accent(c1, neuron, pmap, noaccent)
+    let okga: Bool = write_wav(ga, 16000, outdir + "ga-neuron.wav")
+    let br1: [Int] = synth_codes_accent(c1, neuron, pmap, amap)
+    let okb1: Bool = write_wav(br1, 16000, outdir + "british-neuron.wav")
+
+    // -- Sentence 2: showcases NON-RHOTICITY --------------------------------
+    let fr2: [String] = sem_frame("describe", "I", "here", "")
+    let t2: String = sem_realize(fr2)
+    let c2: [String] = text_phonemes(lmap, t2)
+    let c2rp: [String] = apply_rhoticity(c2, pmap)
+    println("[s2] " + t2 + " :: GA=" + list_join(c2, " ") + "  RP=" + list_join(c2rp, " "))
+    let br2: [Int] = synth_codes_accent(c2, neuron, pmap, amap)
+    let okb2: Bool = write_wav(br2, 16000, outdir + "british-2.wav")
+
+    // show an RP override read straight from the accent geometry
+    let ovAA: [Int] = accent_formants(amap, "AA")
+    if native_list_len(ovAA) >= 3 {
+        println("[accent-geometry] AA(LOT) RP f1=" + int_to_str(native_list_get(ovAA, 0)) + " f2=" + int_to_str(native_list_get(ovAA, 1)) + " (base GA 730/1090) [PROVISIONAL]")
+    }
+    println("[done] ga-neuron=" + bool_to_str(okga) + " british-neuron=" + bool_to_str(okb1) + " british-2=" + bool_to_str(okb2))
+}
@@ -0,0 +1,69 @@
+// speech-demo.el - PROOF: Neuron speaks from MEANING, rendered through INGESTED
+// phonetic geometry, own-core, plus voice-by-IMITATION. Built by concatenating
+// the elp realizer + voice-profile + speech-ingest + speech, then this main.
+//
+//   LEARN   : ingest acoustic-phonetics + lexicon SOURCES -> phoneme manifold in
+//             the engram (source -> manifold -> merge).
+//   MEANING : sem_frame("describe","I","Neuron","") -> sem_realize -> "I am Neuron."
+//   PHONES  : words -> phoneme codes, READ from the ingested lexicon geometry.
+//   RENDER  : superpose formant resonances (read from engram) over a glottal
+//             source -> own-core PCM/WAV, in Neuron's own voice.
+//   IMITATE : HEAR a short sample of a different voice -> extract its signature
+//             by ear (autocorrelation pitch + integer-DFT formant) -> render new
+//             speech in that voice. An impression, not a corpus.
+
+fn speak_report(tag: String, codes: [String], voice: [String], pmap: [String], path: String) -> [Int] {
+    let s: [Int] = synth_codes(codes, voice, pmap)
+    let ok: Bool = write_wav(s, 16000, path)
+    println(tag + " samples=" + int_to_str(native_list_len(s)) + " ok=" + bool_to_str(ok) + " -> " + path)
+    return s
+}
+
+fn main() {
+    let outdir: String = "/private/tmp/claude-501/-Users-will/6531446d-bc27-4095-930b-e04777c3db4f/scratchpad/"
+
+    // -- LEARN: ingest the speech primitives as geometry --------------------
+    let pmap: [String] = ingest_phonetics("elp/data/phonetics.psv")
+    let lmap: [String] = ingest_lexicon("elp/data/lexicon.psv")
+    let saved: Bool = engram_save(outdir + "phoneme-manifold.json")
+    println("[learn] phonemes=" + int_to_str(native_list_len(pmap) / 2) + " words=" + int_to_str(native_list_len(lmap) / 2) + " manifold_saved=" + bool_to_str(saved))
+
+    // sanity: show that AA's formants came from ingested geometry, not code
+    let aa: [Int] = phon_geo(pmap, "AA")
+    let aaF1: Int = native_list_get(aa, 0)
+    let aaF2: Int = native_list_get(aa, 1)
+    println("[read-geometry] AA F1=" + int_to_str(aaF1) + " F2=" + int_to_str(aaF2) + " (parsed from engram node)")
+
+    // -- MEANING -> WORDS via the realizer's language faculty ----------------
+    let frame: [String] = sem_frame("describe", "I", "Neuron", "")
+    let text: String = sem_realize(frame)
+    println("[meaning->text] " + text)
+
+    // -- WORDS -> PHONEMES (read from ingested lexicon geometry) --------------
+    let codes: [String] = text_phonemes(lmap, text)
+    println("[phonemes] " + list_join(codes, " "))
+
+    // -- RENDER in Neuron's own voice ----------------------------------------
+    let neuron: [String] = voice_neuron()
+    let s1: [Int] = speak_report("[speak neuron]", codes, neuron, pmap, outdir + "neuron.wav")
+
+    // -- IMITATION: hear a distinct voice, recover its signature, re-render ---
+    let vA: [String] = voice_target_a()
+    let hcodes: [String] = native_list_empty()
+    hcodes = native_list_append(hcodes, "SIL")
+    let z: Int = 0
+    while z < 6 {
+        hcodes = native_list_append(hcodes, "AA")
+        z = z + 1
+    }
+    hcodes = native_list_append(hcodes, "SIL")
+    let heard: [Int] = synth_codes(hcodes, vA, pmap)
+    let okh: Bool = write_wav(heard, 16000, outdir + "heard.wav")
+
+    let vB: [String] = voice_analyze(heard, 16000)
+    println("[imitate] heard ACTUAL   f0=" + voice_get(vA, "f0") + " kf=" + voice_get(vA, "kf"))
+    println("[imitate] heard RECOVERED f0=" + voice_get(vB, "f0") + " kf=" + voice_get(vB, "kf") + " (extracted by ear from PCM)")
+    let s2: [Int] = speak_report("[speak imitation]", codes, vB, pmap, outdir + "imitation.wav")
+
+    println("[done] rendered from meaning + ingested geometry; imitation from a heard sample.")
+}
@@ -0,0 +1,48 @@
+// speech-organ-demo.el - PROOF: the render now reads its phoneme + accent
+// GEOMETRY from the ingest ORGAN's saved engram files (engram_load +
+// engram_scan_nodes_json + cache), not a same-run hand-load. The British accent
+// is still a composed transform-geometry (voice (+) accent, separable). Numbers
+// come from the organ manifold; the .psv supplies only categorical vowel-class.
+
+fn main() {
+    let outdir: String = "/Users/will/Development/neuron-technologies/foundation/el/.claude/worktrees/agent-acc02900ef4ade35e/elp/tests/examples/out/"
+
+    // engram-independent caches from source (survive engram_load replacement)
+    let vset: [String] = organ_vset("elp/data/phonetics.psv")
+    let lmap: [String] = organ_lex("elp/data/lexicon.psv")
+    // ORGAN read: phonetics FIRST (cache), THEN accent (engram_load replaces store)
+    let pmap: [String] = organ_pmap("elp/data/phonetics-formants.engram.json")
+    let amap: [String] = organ_amap("elp/data/british-accent.engram.json")
+    println("[organ] phon_syms=" + int_to_str(native_list_len(pmap) / 2) + " accent_syms=" + int_to_str(native_list_len(amap) / 2) + " vowels=" + int_to_str(native_list_len(vset)) + " words=" + int_to_str(native_list_len(lmap) / 2))
+
+    // prove the numbers came from the organ node content
+    let g: [Int] = phon_geo(pmap, "AA")
+    println("[organ-read] phoneme AA f1=" + int_to_str(native_list_get(g, 0)) + " f2=" + int_to_str(native_list_get(g, 1)) + " f3=" + int_to_str(native_list_get(g, 2)) + " (P&B1952 MEASURED)")
+    let ov: [Int] = accent_formants(amap, "AA")
+    if native_list_len(ov) >= 3 {
+        println("[organ-read] accent AA(LOT) f1=" + int_to_str(native_list_get(ov, 0)) + " f2=" + int_to_str(native_list_get(ov, 1)) + " (DERIVED RP, PROVISIONAL)")
+    }
+    println("[organ-read] non_rhotic=" + int_to_str(is_nonrhotic(amap)))
+
+    let neuron: [String] = voice_neuron()
+    let noacc: [String] = native_list_empty()
+
+    // Sentence 1: "I am Neuron." from meaning; GA vs RP = separable toggle
+    let t1: String = sem_realize(sem_frame("describe", "I", "Neuron", ""))
+    let c1: [String] = text_phonemes(lmap, t1)
+    println("[s1] " + t1 + " :: " + list_join(c1, " "))
+    let ga: [Int] = synth_codes_accent(c1, neuron, pmap, noacc, vset)
+    let okga: Bool = write_wav(ga, 16000, outdir + "ga-neuron-organ.wav")
+    let br1: [Int] = synth_codes_accent(c1, neuron, pmap, amap, vset)
+    let okb1: Bool = write_wav(br1, 16000, outdir + "british-neuron-organ.wav")
+
+    // Sentence 2: non-rhoticity showcase
+    let t2: String = sem_realize(sem_frame("describe", "I", "here", ""))
+    let c2: [String] = text_phonemes(lmap, t2)
+    let c2rp: [String] = apply_rhoticity(c2, vset)
+    println("[s2] " + t2 + " :: GA=" + list_join(c2, " ") + "  RP=" + list_join(c2rp, " "))
+    let br2: [Int] = synth_codes_accent(c2, neuron, pmap, amap, vset)
+    let okb2: Bool = write_wav(br2, 16000, outdir + "british-2-organ.wav")
+
+    println("[done] ga-organ=" + bool_to_str(okga) + " british-organ=" + bool_to_str(okb1) + " british-2-organ=" + bool_to_str(okb2))
+}
@@ -0,0 +1,31 @@
+// speech-voice-demo.el - LIVE VOICE LOOP (stand-in test). Capture -> voiceprint
+// -> reshape -> INGEST AS GEOMETRY -> read the target back FROM geometry -> the
+// EL projector renders a line reaching for that voice. Stand-in "Will" = the
+// voiceprint of imitation.wav. HONEST: pitch + coarse vocal-tract scale, NOT a clone.
+
+fn main() {
+    let outdir: String = "/Users/will/Development/neuron-technologies/foundation/el/.claude/worktrees/agent-acc02900ef4ade35e/elp/tests/examples/out/"
+    let vp: String = "/private/tmp/claude-501/-Users-will/6531446d-bc27-4095-930b-e04777c3db4f/scratchpad/will-voiceprint.json"
+
+    // 1+2: reshape voiceprint JSON -> organ voice-signature source
+    let sig0: [String] = native_list_empty()
+    let sig: [Int] = reshape_voiceprint(vp, "elp/data/will-voice.json")
+    // 3: ingest as geometry + engram_save a reloadable manifold file
+    let ig: Int = ingest_voice(sig, "elp/data/will-voice.engram.json")
+    // 4: READ the target back FROM geometry (engram_load + scan + filter)
+    let g: [Int] = load_voice("elp/data/will-voice.engram.json")
+    println("[voice-geometry] read from manifold: f0=" + int_to_str(native_list_get(g, 0)) + " f0_end=" + int_to_str(native_list_get(g, 1)) + " kf=" + int_to_str(native_list_get(g, 2)) + " f1=" + int_to_str(native_list_get(g, 3)) + " f2=" + int_to_str(native_list_get(g, 4)) + " f3=" + int_to_str(native_list_get(g, 5)) + " (measured, COARSE — not a clone)")
+
+    // phoneme geometry from the organ (loaded AFTER the voice sig is cached in EL)
+    let pmap: [String] = organ_pmap("elp/data/phonetics-formants.engram.json")
+    let lmap: [String] = organ_lex("elp/data/lexicon.psv")
+
+    // 5: render a line FROM MEANING in Will's voice
+    let vw: [String] = voice_will(native_list_get(g, 0), native_list_get(g, 1), native_list_get(g, 2))
+    let t: String = sem_realize(sem_frame("greet", "Will", "", ""))
+    let codes: [String] = text_phonemes(lmap, t)
+    println("[render] \"" + t + "\" :: " + list_join(codes, " ") + "  in voice=will f0=" + int_to_str(voice_get_int(vw, "f0")) + " kf=" + int_to_str(voice_get_int(vw, "kf")))
+    let samples: [Int] = synth_codes(codes, vw, pmap)
+    let ok: Bool = write_wav(samples, 16000, outdir + "will-reply.wav")
+    println("[done] will-reply.wav=" + bool_to_str(ok))
+}
@@ -0,0 +1,48 @@
+// speech-voice-demo2.el - LIVE VOICE LOOP on Will's richer 30s read, with a
+// GEOMETRIC SET-REPLACE of the voice_will manifold (supersede the coarse 10s
+// region, insert the 30s region — no duplicate node, no per-node CRUD; Will's
+// standing rule f999c5ff). HONEST: 30s steadies the 11-number average over more
+// of his vowels, but it is still one formant triple with no coarticulation or
+// prosody — closer but still synthetic, not a clone.
+
+fn main() {
+    let outdir: String = "/Users/will/Development/neuron-technologies/foundation/el/.claude/worktrees/agent-acc02900ef4ade35e/elp/tests/examples/out/"
+    let vp: String = "/private/tmp/claude-501/-Users-will/6531446d-bc27-4095-930b-e04777c3db4f/scratchpad/will30-voiceprint.json"
+    let manifest: String = "elp/data/will-voice.engram.json"
+
+    // --- SET-REPLACE step 1: read the PRIOR region (text read of the manifold
+    //     file — no engram_load, so the store stays clean) and report what is
+    //     being superseded. ---
+    let prior: String = fs_read(manifest)
+    let pp: Int = str_index_of(prior, "voice will ")
+    if pp >= 0 {
+        let pw: String = str_slice(prior, pp, pp + 200)
+        println("[set-replace] superseding PRIOR voice region: f0=" + int_to_str(parse_uint_from(pw, "f0=")) + " kf=" + int_to_str(parse_uint_from(pw, "kf=")) + " f1=" + int_to_str(parse_uint_from(pw, "f1=")))
+    }
+
+    // --- step 2: reshape the 30s voiceprint -> organ voice-signature source ---
+    let sig: [Int] = reshape_voiceprint(vp, "elp/data/will-voice.json")
+
+    // --- step 3: INSERT the fresh 30s region into an EMPTY engram and save ->
+    //     wholesale replaces the manifold file (old region dropped, not edited,
+    //     not duplicated). This is the geometric set-replace. ---
+    let ig: Int = ingest_voice(sig, manifest)
+
+    // --- step 4: READ the new target BACK from geometry ---
+    let g: [Int] = load_voice(manifest)
+    println("[voice-geometry] new region read from manifold: f0=" + int_to_str(native_list_get(g, 0)) + " f0_end=" + int_to_str(native_list_get(g, 1)) + " kf=" + int_to_str(native_list_get(g, 2)) + " f1=" + int_to_str(native_list_get(g, 3)) + " f2=" + int_to_str(native_list_get(g, 4)) + " f3=" + int_to_str(native_list_get(g, 5)) + " (measured 30s, COARSE — not a clone)")
+
+    // phoneme + lexicon geometry from the organ (loaded after the voice sig is
+    // cached in EL, since engram_load replaces the store)
+    let pmap: [String] = organ_pmap("elp/data/phonetics-formants.engram.json")
+    let lmap: [String] = organ_lex("elp/data/lexicon.psv")
+
+    // --- step 5: render a fresh reply FROM MEANING in the 30s Will voice ---
+    let vw: [String] = voice_will(native_list_get(g, 0), native_list_get(g, 1), native_list_get(g, 2))
+    let t: String = sem_realize(sem_frame("greet", "Will", "", ""))
+    let codes: [String] = text_phonemes(lmap, t)
+    println("[render] \"" + t + "\" :: " + list_join(codes, " ") + "  in voice=will f0=" + int_to_str(voice_get_int(vw, "f0")) + " kf=" + int_to_str(voice_get_int(vw, "kf")))
+    let samples: [Int] = synth_codes(codes, vw, pmap)
+    let ok: Bool = write_wav(samples, 16000, outdir + "will-reply2.wav")
+    println("[done] will-reply2.wav=" + bool_to_str(ok))
+}
@@ -0,0 +1,37 @@
+// speech-voicegeom-demo.el - THE JUMP: render Will's VOWEL SPACE + PROSODY
+// (measured over 30s), not the single 11-number average. His vowels land at HIS
+// targets; pitch follows HIS melody. All read back FROM the ingested geometry.
+// INTERIM: the geometry was Python-measured (measure_voice.py, numpy LPC/F0) —
+// to be superseded by the engram-measures-audio path. No source layer.
+
+fn main() {
+    let outdir: String = "/Users/will/Development/neuron-technologies/foundation/el/.claude/worktrees/agent-acc02900ef4ade35e/elp/tests/examples/out/"
+
+    // 1: ingest vowel space + prosody as geometry (empty store -> save; set-replace)
+    let ig: Int = ingest_voicegeom("elp/data/will-vowelspace.psv", "elp/data/will-prosody.psv", "elp/data/will-voicegeom.engram.json")
+    // kf (vocal-tract scale for consonants) from the earlier will-voice manifold
+    let sigv: [Int] = load_voice("elp/data/will-voice.engram.json")
+    let kf: Int = native_list_get(sigv, 2)
+    // 2: read vowel space + prosody back FROM geometry
+    let vmap: [String] = load_voicegeom("elp/data/will-voicegeom.engram.json")
+    let pros: [Int] = prosody_from(vmap)
+    println("[geometry] vowels=" + int_to_str((native_list_len(vmap) - 2) / 2) + " prosody f0_median=" + int_to_str(native_list_get(pros, 0)) + " f0_min=" + int_to_str(native_list_get(pros, 1)) + " f0_max=" + int_to_str(native_list_get(pros, 2)) + " kf=" + int_to_str(kf))
+    let ehv: [Int] = vmap_get(vmap, "EH")
+    let ihv: [Int] = vmap_get(vmap, "IH")
+    println("[his-vowels] EH=" + int_to_str(native_list_get(ehv, 0)) + "/" + int_to_str(native_list_get(ehv, 1)) + " IH=" + int_to_str(native_list_get(ihv, 0)) + "/" + int_to_str(native_list_get(ihv, 1)))
+
+    // phoneme geometry from the organ (loaded AFTER caches are in EL)
+    let pmap: [String] = organ_pmap("elp/data/phonetics-formants.engram.json")
+    let lmap: [String] = organ_lex("elp/data/lexicon.psv")
+
+    // 3+4: render FROM MEANING in his-vowels + his-prosody voice
+    let vw: [String] = voice_will(native_list_get(pros, 0), native_list_get(pros, 1), kf)
+    let noacc: [String] = native_list_empty()
+    let novset: [String] = native_list_empty()
+    let t: String = sem_realize(sem_frame("greet", "Will", "", ""))
+    let codes: [String] = text_phonemes(lmap, t)
+    println("[render] \"" + t + "\" :: " + list_join(codes, " "))
+    let samples: [Int] = synth_codes_accent(codes, vw, pmap, noacc, novset, vmap, pros)
+    let ok: Bool = write_wav(samples, 16000, outdir + "will-reply3.wav")
+    println("[done] will-reply3.wav=" + bool_to_str(ok))
+}
@@ -81,7 +81,7 @@ jobs:
      # Link to produce the engram binary
      - name: Link engram binary
        run: |
-          cc -std=c11 -O2 \
+          cc -std=c11 -O2 -DHAVE_CURL \
            -I /usr/local/lib/el \
            -o dist/engram \
            dist/engram.c \
@@ -88,7 +88,7 @@ jobs:
      # Link to produce the engram binary
      - name: Link engram binary
        run: |
-          cc -std=c11 -O2 \
+          cc -std=c11 -O2 -DHAVE_CURL \
            -I /usr/local/lib/el \
            -o dist/engram \
            dist/engram.c \
@@ -62,7 +62,7 @@ jobs:
      # Link to produce the engram binary
      - name: Link engram binary
        run: |
-          cc -std=c11 -O2 \
+          cc -std=c11 -O2 -DHAVE_CURL \
            -I /usr/local/lib/el \
            -o dist/engram \
            dist/engram.c \
@@ -17,6 +17,16 @@
 //   4. Append dep to order after all its transitive deps
 //   5. Deduplicate: skip already-ordered vessels

+// ── Cross-module forward declarations ─────────────────────────────────────────
+// Defined in sibling epm modules; resolved at link time. The `extern fn` decls
+// give elc the C prototypes so generated install.c compiles cleanly under strict
+// compilers (gcc>=14 / clang) that reject implicit function declarations.
+extern fn manifest_name(src: String) -> String                        // manifest.el
+extern fn manifest_deps(src: String) -> String                        // manifest.el
+extern fn registry_token() -> String                                  // registry.el
+extern fn registry_find(name: String, version: String) -> String     // registry.el
+extern fn registry_latest_version(name: String) -> String            // registry.el
+
 // ── Install paths ─────────────────────────────────────────────────────────────

 // packages_dir returns the root directory for installed vessels.
@@ -14,6 +14,15 @@
 //   EPM_REGISTRY_ORG — org name that hosts vessel repos (default: neuron-technologies)
 //   EPM_TOKEN      — Gitea personal access token (required for publish)

+// ── Cross-module forward declarations ─────────────────────────────────────────
+// These symbols are defined in sibling epm modules or the El runtime and are
+// resolved at link time. The `extern fn` decls give elc the C prototype so the
+// generated registry.c compiles cleanly under strict compilers (gcc>=14 / clang)
+// that reject implicit function declarations. Signature arity must match the
+// definition; return/param types are informational (all lower to el_val_t).
+extern fn config(key: String) -> String          // El runtime builtin
+extern fn read_installed() -> String              // install.el
+
 // ── Config helpers ────────────────────────────────────────────────────────────

 // registry_api_url returns the Gitea API base URL with no trailing slash.
@@ -6,6 +6,15 @@
 // Depends on: registry.el (registry_latest_version, registry_find),
 //             install.el  (read_installed, install_vessel, installed_version)

+// ── Cross-module forward declarations ─────────────────────────────────────────
+// Defined in sibling epm modules; resolved at link time. The `extern fn` decls
+// give elc the C prototypes so generated update.c compiles cleanly under strict
+// compilers (gcc>=14 / clang) that reject implicit function declarations.
+extern fn read_installed() -> String                                  // install.el
+extern fn installed_version(name: String) -> String                   // install.el
+extern fn install_vessel(name: String, version: String) -> Bool      // install.el
+extern fn registry_latest_version(name: String) -> String            // registry.el
+
 // ── Semver helpers ────────────────────────────────────────────────────────────

 // semver_part extracts the Nth dot-separated component from a semver string.
@@ -75,6 +75,7 @@ static inline void* el_win_dlsym(void* handle, const char* name) {
 #include <direct.h>            /* _mkdir */
 #define mkdir(path, mode) _mkdir(path)     /* POSIX mkdir(path,mode) → _mkdir(path) */
 #define timegm _mkgmtime                   /* UTC tm → time_t */
+#define fsync(fd) _commit(fd)              /* no fsync() on Windows; _commit() (<io.h>) is the equiv */

 /* setenv/unsetenv: not in the Windows CRT; map to _putenv_s / SetEnvironmentVariable. */
 static inline int setenv(const char* name, const char* value, int overwrite) {
@@ -82,8 +82,14 @@ static _Thread_local ElArena _tl_arena = {NULL, 0, 0};
 static _Thread_local int     _tl_arena_active = 0;

 /* Binary-safe fs_read length — set by fs_read, consumed by http_send_response.
- * Allows serving PNGs and other binary files without strlen truncation. */
-static _Thread_local size_t  _tl_fs_read_len  = 0;
+ * Allows serving PNGs and other binary files without strlen truncation.
+ * PAIRED with the buffer pointer it describes: the length may only be applied
+ * to the exact buffer fs_read returned. Without the pairing, any handler that
+ * fs_read a file and then WRAPPED it into a larger response had that response
+ * truncated to the file's length (Content-Length lied AND the send stopped
+ * short) — the safety-contact onboarding trap, 2026-07-17. */
+static _Thread_local size_t      _tl_fs_read_len  = 0;
+static _Thread_local const char* _tl_fs_read_buf  = NULL;

 static void el_arena_track(char* p) {
    if (!_tl_arena_active || !p) return;
@@ -101,6 +107,8 @@ static void el_arena_track(char* p) {
 void el_request_start(void) {
    _tl_arena.count  = 0;
    _tl_arena_active = 1;
+    _tl_fs_read_len  = 0;     /* never let a previous request's file length */
+    _tl_fs_read_buf  = NULL;  /* leak into this response's byte accounting  */
 }

 /* Called by http_worker after the El handler returns and the response is sent.
@@ -1484,11 +1492,14 @@ static void http_send_response(int fd, const char* body) {
    }

    const char* eff_body = is_envelope ? env_body : body;
-    /* Use the real byte count from fs_read if available (handles binary files
-     * with embedded null bytes — PNG, WOFF2, etc.). Fall back to strlen for
-     * normal text/JSON responses where _tl_fs_read_len is 0. */
-    size_t blen = (_tl_fs_read_len > 0) ? _tl_fs_read_len : strlen(eff_body);
+    /* Use the real byte count from fs_read ONLY when this body IS the exact
+     * buffer fs_read returned (binary files with embedded null bytes — PNG,
+     * WOFF2, etc.). Any other body — wrapped, enveloped, or derived — must be
+     * measured with strlen, or it is truncated/over-read to the file's size. */
+    size_t blen = (_tl_fs_read_len > 0 && eff_body == _tl_fs_read_buf)
+                      ? _tl_fs_read_len : strlen(eff_body);
    _tl_fs_read_len = 0;  /* consume — one-shot per response */
+    _tl_fs_read_buf = NULL;
    int head_only = _tl_http_head_only;

    JsonBuf hdrs; jb_init(&hdrs);
@@ -1568,11 +1579,22 @@ static void* http_worker(void* arg) {
            const char* rs = EL_CSTR(r);
            /* Copy response out BEFORE arena teardown.
             * For binary files, _tl_fs_read_len holds the real byte count —
-             * use memcpy instead of strdup so null bytes are preserved. */
-            size_t rlen = _tl_fs_read_len > 0 ? _tl_fs_read_len : (rs ? strlen(rs) : 0);
+             * use memcpy instead of strdup so null bytes are preserved.
+             * The stored length applies ONLY when the response IS the exact
+             * fs_read buffer; a wrapped/derived response must use strlen or
+             * it gets truncated (or over-read) to the file's length. */
+            size_t rlen;
+            if (_tl_fs_read_len > 0 && rs && rs == _tl_fs_read_buf) {
+                rlen = _tl_fs_read_len;   /* raw file bytes — binary-safe */
+            } else {
+                rlen = rs ? strlen(rs) : 0;
+                _tl_fs_read_len = 0;      /* hint doesn't describe this body */
+                _tl_fs_read_buf = NULL;
+            }
            response = malloc(rlen + 1);
            if (response && rs) { memcpy(response, rs, rlen); response[rlen] = '\0'; }
            else if (response) { response[0] = '\0'; }
+            if (_tl_fs_read_len > 0) _tl_fs_read_buf = response; /* hint follows the copy */
        } else {
            response = el_strdup_persist("el-runtime: no http handler registered");
        }
@@ -1822,10 +1844,20 @@ static void* http_worker_v2(void* arg) {
            el_val_t hmap = http_build_headers_map(hdr_block ? hdr_block : "");
            el_val_t r = h(EL_STR(dispatch_method), EL_STR(path), hmap, EL_STR(body));
            const char* rs = EL_CSTR(r);
-            size_t rlen = _tl_fs_read_len > 0 ? _tl_fs_read_len : (rs ? strlen(rs) : 0);
+            /* Same pairing rule as the v1 worker: the fs_read length is only
+             * trustworthy for the exact buffer fs_read returned. */
+            size_t rlen;
+            if (_tl_fs_read_len > 0 && rs && rs == _tl_fs_read_buf) {
+                rlen = _tl_fs_read_len;   /* raw file bytes — binary-safe */
+            } else {
+                rlen = rs ? strlen(rs) : 0;
+                _tl_fs_read_len = 0;      /* hint doesn't describe this body */
+                _tl_fs_read_buf = NULL;
+            }
            response = malloc(rlen + 1);
            if (response && rs) { memcpy(response, rs, rlen); response[rlen] = '\0'; }
            else if (response) { response[0] = '\0'; }
+            if (_tl_fs_read_len > 0) _tl_fs_read_buf = response; /* hint follows the copy */
            el_release(hmap);
        } else {
            response = el_strdup_persist(
@@ -1963,8 +1995,9 @@ void http_serve_async(el_val_t port, el_val_t handler) {
    int sock = socket(AF_INET6, SOCK_STREAM, 0);
    if (sock < 0) { perror("socket"); return; }
    int yes = 1; int no = 0;
-    setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes));
-    setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, &no, sizeof(no));
+    /* Win32/mingw setsockopt takes optval as (const char*); the cast is portable on POSIX too. */
+    setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (const char*)&yes, sizeof(yes));
+    setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, (const char*)&no, sizeof(no));
    struct sockaddr_in6 addr;
    memset(&addr, 0, sizeof(addr));
    addr.sin6_family = AF_INET6;
@@ -2023,6 +2056,7 @@ el_val_t http_response(el_val_t status, el_val_t headers_json, el_val_t body) {
 el_val_t fs_read(el_val_t pathv) {
    const char* path = EL_CSTR(pathv);
    _tl_fs_read_len = 0;
+    _tl_fs_read_buf = NULL;
    if (!path) return el_wrap_str(el_strdup(""));
    FILE* f = fopen(path, "rb");
    if (!f) return el_wrap_str(el_strdup(""));
@@ -2034,6 +2068,7 @@ el_val_t fs_read(el_val_t pathv) {
    size_t got = fread(buf, 1, (size_t)sz, f);
    buf[got] = '\0';
    _tl_fs_read_len = got;   /* store real byte count for binary-safe send */
+    _tl_fs_read_buf = buf;   /* ...valid ONLY for this exact buffer */
    fclose(f);
    return el_wrap_str(buf);
 }
@@ -3576,8 +3611,10 @@ el_val_t json_get_raw(el_val_t json_str, el_val_t key) {
    const char* k    = EL_CSTR(key);
    const char* p = json_find_key(json, k);
    /* Clear fs_read binary-length hint — result is a fresh null-terminated
-     * string, not the raw file bytes, so Content-Length must use strlen. */
+     * string, not the raw file bytes, so Content-Length must use strlen.
+     * (Kept although the pointer pairing now makes this redundant.) */
    _tl_fs_read_len = 0;
+    _tl_fs_read_buf = NULL;
    if (!p) return el_wrap_str(el_strdup(""));
    const char* end = json_skip_value(p);
    size_t n = (size_t)(end - p);
@@ -6895,6 +6932,243 @@ static int engram_rank_cmp(const void* a, const void* b) {
    return 0;
 }

+/* ══════════════════════════════════════════════════════════════════════════
+ * SEMANTIC SEARCH LAYER — nomic-embed-text via Ollama /api/embeddings
+ * ──────────────────────────────────────────────────────────────────────────
+ * Augments the lexical (istr_contains) matcher with dense-vector retrieval.
+ * Node content and the query are embedded through a local Ollama server;
+ * nodes are ranked by cosine similarity and UNIONED with lexical hits. This
+ * lets a paraphrase query surface a node whose words never appear in it.
+ *
+ * DEGRADABLE BY DESIGN. The whole layer is gated on HAVE_CURL plus a one-shot
+ * runtime probe of the embedding endpoint. If curl is not compiled in, or
+ * Ollama is unreachable, or ENGRAM_SEMANTIC=0, every entry point returns
+ * "no semantic signal" and callers fall back to pure lexical behaviour —
+ * byte-for-byte the pre-existing search.
+ *
+ * CACHE. Node embeddings are computed lazily on first use and cached in
+ * process memory keyed by node id, with an FNV-1a content hash for
+ * invalidation (edited content re-embeds). The query is embedded once per
+ * search call. This is what "avoid re-embedding the whole graph every query"
+ * buys us: a warm cache serves cosine from RAM. (A cold process still pays
+ * O(N) embed calls the first time each node is scanned — persisting the cache
+ * to a snapshot sidecar is the documented next step, not done here.)
+ *
+ * nomic task prefixes ("search_query:" / "search_document:") are applied
+ * because nomic-embed-text is trained with them; they materially improve
+ * retrieval separation (empirically: paraphrase 0.72 vs distractors <0.48).
+ *
+ * ENV:
+ *   ENGRAM_SEMANTIC       "0" disables; unset/other = auto-probe
+ *   ENGRAM_EMBED_URL      default http://localhost:11434/api/embeddings
+ *   ENGRAM_EMBED_MODEL    default nomic-embed-text
+ *   ENGRAM_SEMANTIC_MIN   cosine threshold for a pure-semantic match (def 0.6)
+ * ════════════════════════════════════════════════════════════════════════ */
+
+static double engram_semantic_min(void) {
+    static double v = -1.0;
+    if (v >= 0.0) return v;
+    const char* s = getenv("ENGRAM_SEMANTIC_MIN");
+    double d = 0.6;
+    if (s && *s) { char* e = NULL; double t = strtod(s, &e);
+                   if (e != s && t >= 0.0 && t <= 1.0) d = t; }
+    v = d; return v;
+}
+
+#ifdef HAVE_CURL
+
+typedef struct { char* id; uint64_t hash; float* vec; int dim; } EngramEmbEntry;
+static EngramEmbEntry* g_emb_items = NULL;
+static int64_t g_emb_count = 0, g_emb_cap = 0;
+static int g_emb_state = 0;   /* 0=unprobed, 1=available, -1=disabled */
+
+static uint64_t engram_fnv1a(const char* s) {
+    uint64_t h = 1469598103934665603ULL;
+    if (s) for (const unsigned char* p = (const unsigned char*)s; *p; p++) {
+        h ^= *p; h *= 1099511628211ULL;
+    }
+    return h;
+}
+
+/* Parse "embedding":[f,f,...] from an Ollama response. malloc'd vec, or NULL. */
+static float* engram_parse_embedding(const char* json, int* out_dim) {
+    if (!json) return NULL;
+    const char* p = strstr(json, "\"embedding\"");
+    if (!p) return NULL;
+    p = strchr(p, '[');
+    if (!p) return NULL;
+    p++;
+    int cap = 1024, n = 0;
+    float* v = malloc((size_t)cap * sizeof(float));
+    if (!v) return NULL;
+    while (*p && *p != ']') {
+        while (*p == ' ' || *p == '\t' || *p == '\n' || *p == '\r' || *p == ',') p++;
+        if (*p == ']' || !*p) break;
+        char* e = NULL;
+        double d = strtod(p, &e);
+        if (e == p) break;
+        if (n >= cap) { cap *= 2; float* nv = realloc(v, (size_t)cap * sizeof(float));
+                        if (!nv) { free(v); return NULL; } v = nv; }
+        v[n++] = (float)d;
+        p = e;
+    }
+    if (n == 0) { free(v); return NULL; }
+    *out_dim = n;
+    return v;
+}
+
+/* JSON-escape src into a malloc'd buffer (no surrounding quotes). */
+static char* engram_json_escape(const char* src) {
+    if (!src) src = "";
+    size_t n = strlen(src);
+    char* out = malloc(n * 2 + 1);
+    if (!out) return NULL;
+    size_t j = 0;
+    for (size_t i = 0; i < n; i++) {
+        unsigned char c = (unsigned char)src[i];
+        if      (c == '"')  { out[j++] = '\\'; out[j++] = '"'; }
+        else if (c == '\\') { out[j++] = '\\'; out[j++] = '\\'; }
+        else if (c == '\n') { out[j++] = '\\'; out[j++] = 'n'; }
+        else if (c == '\r') { out[j++] = '\\'; out[j++] = 'r'; }
+        else if (c == '\t') { out[j++] = '\\'; out[j++] = 't'; }
+        else if (c < 0x20)  { /* drop other control bytes */ }
+        else                { out[j++] = (char)c; }
+    }
+    out[j] = '\0';
+    return out;
+}
+
+/* Embed `prefix+text` via Ollama. Returns malloc'd vec (caller frees), or NULL. */
+static float* engram_embed_raw(const char* prefix, const char* text, int* out_dim) {
+    if (!text) return NULL;
+    const char* url = getenv("ENGRAM_EMBED_URL");
+    if (!url || !*url) url = "http://localhost:11434/api/embeddings";
+    const char* model = getenv("ENGRAM_EMBED_MODEL");
+    if (!model || !*model) model = "nomic-embed-text";
+    /* Bound content length to keep latency/memory sane on huge nodes. */
+    char* trunc = NULL;
+    size_t maxlen = 8192;
+    if (strlen(text) > maxlen) {
+        trunc = malloc(maxlen + 1);
+        if (trunc) { memcpy(trunc, text, maxlen); trunc[maxlen] = '\0'; text = trunc; }
+    }
+    char* esc_prefix = engram_json_escape(prefix ? prefix : "");
+    char* esc = engram_json_escape(text);
+    free(trunc);
+    if (!esc || !esc_prefix) { free(esc); free(esc_prefix); return NULL; }
+    size_t blen = strlen(esc) + strlen(esc_prefix) + strlen(model) + 64;
+    char* body = malloc(blen);
+    if (!body) { free(esc); free(esc_prefix); return NULL; }
+    snprintf(body, blen, "{\"model\":\"%s\",\"prompt\":\"%s%s\"}", model, esc_prefix, esc);
+    free(esc); free(esc_prefix);
+
+    CURL* c = curl_easy_init();
+    if (!c) { free(body); return NULL; }
+    HttpBuf rb; httpbuf_init(&rb);
+    struct curl_slist* h = curl_slist_append(NULL, "Content-Type: application/json");
+    char errbuf[CURL_ERROR_SIZE]; errbuf[0] = '\0';
+    curl_easy_setopt(c, CURLOPT_URL, url);
+    curl_easy_setopt(c, CURLOPT_WRITEFUNCTION, http_write_cb);
+    curl_easy_setopt(c, CURLOPT_WRITEDATA, &rb);
+    curl_easy_setopt(c, CURLOPT_POST, 1L);
+    curl_easy_setopt(c, CURLOPT_POSTFIELDS, body);
+    curl_easy_setopt(c, CURLOPT_POSTFIELDSIZE, (long)strlen(body));
+    curl_easy_setopt(c, CURLOPT_HTTPHEADER, h);
+    curl_easy_setopt(c, CURLOPT_TIMEOUT_MS, el_http_timeout_ms());
+    curl_easy_setopt(c, CURLOPT_NOSIGNAL, 1L);
+    curl_easy_setopt(c, CURLOPT_ERRORBUFFER, errbuf);
+    CURLcode rc = curl_easy_perform(c);
+    curl_slist_free_all(h);
+    curl_easy_cleanup(c);
+    free(body);
+    if (rc != CURLE_OK) { free(rb.data); return NULL; }
+    float* v = engram_parse_embedding(rb.data, out_dim);
+    free(rb.data);
+    return v;
+}
+
+/* One-shot probe: is semantic search available? Caches the verdict. */
+static int engram_semantic_enabled(void) {
+    if (g_emb_state != 0) return g_emb_state == 1;
+    const char* s = getenv("ENGRAM_SEMANTIC");
+    if (s && strcmp(s, "0") == 0) { g_emb_state = -1; return 0; }
+    int dim = 0;
+    float* v = engram_embed_raw("search_query: ", "probe", &dim);
+    if (v && dim > 0) { free(v); g_emb_state = 1; return 1; }
+    free(v);
+    g_emb_state = -1; return 0;
+}
+
+/* Embed the query. Returns malloc'd vec (caller frees), or NULL if semantic off. */
+static float* engram_embed_query(const char* q, int* dim) {
+    if (!engram_semantic_enabled()) return NULL;
+    if (!q || !*q) return NULL;
+    return engram_embed_raw("search_query: ", q, dim);
+}
+
+/* Cached node embedding. Returns a pointer OWNED BY THE CACHE — do not free. */
+static const float* engram_node_vec(EngramNode* n, int* out_dim) {
+    if (!n || !n->id) return NULL;
+    uint64_t h = engram_fnv1a(n->content);
+    for (int64_t i = 0; i < g_emb_count; i++) {
+        if (g_emb_items[i].id && strcmp(g_emb_items[i].id, n->id) == 0) {
+            if (g_emb_items[i].hash == h && g_emb_items[i].vec) {
+                *out_dim = g_emb_items[i].dim; return g_emb_items[i].vec;
+            }
+            /* content changed → re-embed in place */
+            int dim = 0;
+            float* v = engram_embed_raw("search_document: ", n->content ? n->content : "", &dim);
+            if (!v) return NULL;
+            free(g_emb_items[i].vec);
+            g_emb_items[i].vec = v; g_emb_items[i].dim = dim; g_emb_items[i].hash = h;
+            *out_dim = dim; return v;
+        }
+    }
+    int dim = 0;
+    float* v = engram_embed_raw("search_document: ", n->content ? n->content : "", &dim);
+    if (!v) return NULL;
+    if (g_emb_count >= g_emb_cap) {
+        int64_t nc = g_emb_cap ? g_emb_cap * 2 : 256;
+        EngramEmbEntry* ni = realloc(g_emb_items, (size_t)nc * sizeof(EngramEmbEntry));
+        if (!ni) { free(v); return NULL; }
+        g_emb_items = ni; g_emb_cap = nc;
+    }
+    g_emb_items[g_emb_count].id   = strdup(n->id);
+    g_emb_items[g_emb_count].hash = h;
+    g_emb_items[g_emb_count].vec  = v;
+    g_emb_items[g_emb_count].dim  = dim;
+    g_emb_count++;
+    *out_dim = dim; return v;
+}
+
+static double engram_cosine(const float* a, const float* b, int dim) {
+    double dot = 0, na = 0, nb = 0;
+    for (int i = 0; i < dim; i++) { dot += (double)a[i] * b[i];
+                                    na  += (double)a[i] * a[i];
+                                    nb  += (double)b[i] * b[i]; }
+    if (na <= 0 || nb <= 0) return 0.0;
+    return dot / (sqrt(na) * sqrt(nb));
+}
+
+/* Cosine of node n against the query vector; 0 if unavailable / dim mismatch. */
+static double engram_node_cosine(EngramNode* n, const float* qvec, int qdim) {
+    if (!qvec || qdim <= 0) return 0.0;
+    int ndim = 0;
+    const float* nv = engram_node_vec(n, &ndim);
+    if (!nv || ndim != qdim) return 0.0;
+    return engram_cosine(qvec, nv, qdim);
+}
+
+#else  /* !HAVE_CURL — semantic layer compiled out; callers stay pure-lexical.
+        * Only the two boundary functions the always-compiled search/activate
+        * code calls are stubbed; the query embed always yields NULL so every
+        * cosine is 0 and every caller collapses to lexical-only. */
+static float* engram_embed_query(const char* q, int* dim) { (void)q; (void)dim; return NULL; }
+static double engram_node_cosine(EngramNode* n, const float* qvec, int qdim) {
+    (void)n; (void)qvec; (void)qdim; return 0.0;
+}
+#endif /* HAVE_CURL */
+
 el_val_t engram_search(el_val_t query, el_val_t limit) {
    EngramStore* g = engram_get();
    const char* q = EL_CSTR(query);
@@ -6905,8 +7179,15 @@ el_val_t engram_search(el_val_t query, el_val_t limit) {
    char toks[ENGRAM_MAX_QTOKENS][ENGRAM_QTOK_LEN];
    int ntok = engram_tokenize_query(q, toks, ENGRAM_MAX_QTOKENS);
    if (ntok == 0) return lst;
+    /* Semantic augmentation: embed the query once; a node is a hit if it covers
+     * >=1 query token (tokenized-lexical, #66) OR its cosine clears the
+     * threshold (#67). qvec is NULL (cosine 0) when semantic is unavailable →
+     * pure tokenized-lexical, byte-identical to the lexical-only behaviour. */
+    int qdim = 0;
+    float* qvec = engram_embed_query(q, &qdim);
+    double sem_min = engram_semantic_min();
    EngramRankEntry* hits = malloc((size_t)g->node_count * sizeof(EngramRankEntry));
-    if (!hits) return lst;
+    if (!hits) { free(qvec); return lst; }
    int64_t nhits = 0;
    for (int64_t i = 0; i < g->node_count; i++) {
        EngramNode* n = &g->nodes[i];
@@ -6916,20 +7197,24 @@ el_val_t engram_search(el_val_t query, el_val_t limit) {
         * + engram_compile_layered_json — that's the legitimate path. */
        if (engram_layer_is_transparent(n->layer_id)) continue;
        int sc = engram_node_match_score(n, toks, ntok);
-        if (sc > 0) {
+        double sem = qvec ? engram_node_cosine(n, qvec, qdim) : 0.0;
+        if (sc > 0 || sem >= sem_min) {
            hits[nhits].idx      = i;
            hits[nhits].score    = sc;
            hits[nhits].salience = n->salience;
            nhits++;
        }
    }
-    /* Rank by distinct tokens matched (desc) then salience (desc), then cap. */
+    /* Rank by distinct tokens matched (desc) then salience (desc), then cap.
+     * Pure-semantic hits (token score 0) sort after every lexical hit — a
+     * lexical ∪ semantic union with lexical precedence. */
    qsort(hits, (size_t)nhits, sizeof(EngramRankEntry), engram_rank_cmp);
    int64_t end = nhits < lim ? nhits : lim;
    for (int64_t k = 0; k < end; k++) {
        lst = el_list_append(lst, engram_node_to_map(&g->nodes[hits[k].idx]));
    }
    free(hits);
+    free(qvec);
    return lst;
 }

@@ -7279,21 +7564,31 @@ el_val_t engram_activate(el_val_t query, el_val_t depth) {
    if (!seeds) {
        free(best_bg); free(best_hops); free(reached); return out;
    }
-    /* Tokenize once: a node seeds if it matches ANY query token, and its seed
-     * activation is scaled by token coverage (fraction of distinct query
-     * tokens it contains) so a node matching all words seeds more strongly
-     * than one matching a single word. Single-word queries → coverage 1.0,
-     * identical to the prior whole-query behavior. */
+    /* Tokenized + semantic seeding: a node seeds if it covers >=1 query token
+     * (tokenized-lexical, #66) OR its cosine clears the threshold (#67). A
+     * lexical seed's activation is scaled by token coverage (fraction of
+     * distinct query tokens covered) so a node matching all words seeds more
+     * strongly than one matching a single word; single-word queries → coverage
+     * 1.0. A pure-semantic seed (no token match) is instead down-weighted by
+     * its cosine so paraphrase matches spread without overpowering exact seeds.
+     * q_vec is NULL (cosine 0) when semantic is unavailable → the seed set is
+     * exactly the tokenized-lexical one. q_vec is freed right after this loop
+     * so the many downstream early-returns need no cleanup change. */
    char toks[ENGRAM_MAX_QTOKENS][ENGRAM_QTOK_LEN];
    int ntok = engram_tokenize_query(q, toks, ENGRAM_MAX_QTOKENS);
+    int q_dim = 0;
+    float* q_vec = engram_embed_query(q, &q_dim);
+    double q_sem_min = engram_semantic_min();
    for (int64_t i = 0; i < g->node_count; i++) {
        EngramNode* n = &g->nodes[i];
        int sc = engram_node_match_score(n, toks, ntok);
-        if (sc > 0) {
+        double sem = q_vec ? engram_node_cosine(n, q_vec, q_dim) : 0.0;
+        if (sc > 0 || sem >= q_sem_min) {
            double tdecay = engram_temporal_decay(n, now_ms);
            double dampen = engram_activation_dampen(n);
-            double cover  = ntok > 0 ? (double)sc / (double)ntok : 1.0;
-            double act    = n->salience * tdecay * dampen * cover;
+            double act    = n->salience * tdecay * dampen;
+            if (sc > 0) act *= (ntok > 0 ? (double)sc / (double)ntok : 1.0);
+            else        act *= sem;  /* pure-semantic seed: down-weight by cosine */
            seeds[seed_count].idx        = i;
            seeds[seed_count].act        = act;
            seeds[seed_count].created_at = n->created_at;
@@ -7303,6 +7598,7 @@ el_val_t engram_activate(el_val_t query, el_val_t depth) {
            reached[i]   = 1;
        }
    }
+    free(q_vec);
    /* Compute mean seed created_at for temporal proximity bonus. */
    int64_t seed_epoch = 0;
    if (seed_count > 0) {
@@ -7854,6 +8150,35 @@ el_val_t engram_get_node_json(el_val_t id) {
    return el_wrap_str(jb_finish(&b));
 }

+/* engram_get_node_by_label — find the first node whose label field exactly
+ * matches the given string. Returns the node as a JSON object string, or "{}"
+ * if no match is found.
+ *
+ * Used by chat.el to retrieve well-known nodes (e.g. "conv:history",
+ * "session:summary") by their stable label rather than by ID, which is immune
+ * to vector index drift across restarts.
+ *
+ * Exact match (strcmp, not istr_contains) because labels like "conv:history"
+ * must not collide with nodes whose content happens to contain that substring.
+ *
+ * Backported verbatim (idiom-adapted to jb_finish) from release runtime
+ * v1.0.0-20260501 to unblock the soul regen link: chat.el references this
+ * native but the current runtime lacked its definition. */
+el_val_t engram_get_node_by_label(el_val_t label) {
+    const char* lbl = EL_CSTR(label);
+    if (!lbl || !*lbl) return el_wrap_str(el_strdup("{}"));
+    EngramStore* g = engram_get();
+    for (int64_t i = 0; i < g->node_count; i++) {
+        EngramNode* n = &g->nodes[i];
+        if (n->label && strcmp(n->label, lbl) == 0) {
+            JsonBuf b; jb_init(&b);
+            engram_emit_node_json(&b, n);
+            return el_wrap_str(jb_finish(&b));
+        }
+    }
+    return el_wrap_str(el_strdup("{}"));
+}
+
 el_val_t engram_search_json(el_val_t query, el_val_t limit) {
    EngramStore* g = engram_get();
    const char* q = EL_CSTR(query);
@@ -7861,39 +8186,50 @@ el_val_t engram_search_json(el_val_t query, el_val_t limit) {
    if (lim <= 0) lim = 100;
    JsonBuf b; jb_init(&b);
    jb_putc(&b, '[');
-    int first = 1;
-    if (q && *q) {
+    if (q && *q && g->node_count > 0) {
+        /* Collect candidates from the UNION of tokenized-lexical and semantic
+         * matches, score each, rank by score, emit the top `lim`. A node is a
+         * candidate if it covers >=1 query token (tokenized-lexical, #66) OR its
+         * query cosine clears the threshold (#67). Lexical score is the distinct
+         * token count (>=1), so any lexical hit outranks a pure-semantic hit
+         * (cosine < 1); pure-semantic hits are scored by cosine alone. When
+         * semantic is unavailable qvec is NULL, sem is 0, only tokenized-lexical
+         * hits are collected, and the stable insertion sort preserves order. */
        char toks[ENGRAM_MAX_QTOKENS][ENGRAM_QTOK_LEN];
        int ntok = engram_tokenize_query(q, toks, ENGRAM_MAX_QTOKENS);
-        if (ntok > 0) {
-            EngramRankEntry* hits =
-                malloc((size_t)g->node_count * sizeof(EngramRankEntry));
-            if (hits) {
-                int64_t nhits = 0;
-                for (int64_t i = 0; i < g->node_count; i++) {
-                    EngramNode* n = &g->nodes[i];
-                    /* Filter transparent layers — same as engram_search. */
-                    if (engram_layer_is_transparent(n->layer_id)) continue;
-                    int sc = engram_node_match_score(n, toks, ntok);
-                    if (sc > 0) {
-                        hits[nhits].idx      = i;
-                        hits[nhits].score    = sc;
-                        hits[nhits].salience = n->salience;
-                        nhits++;
-                    }
+        int qdim = 0;
+        float* qvec = engram_embed_query(q, &qdim);
+        double sem_min = engram_semantic_min();
+        typedef struct { int64_t idx; double score; } Cand;
+        Cand* cand = malloc((size_t)g->node_count * sizeof(Cand));
+        if (cand) {
+            int64_t nc = 0;
+            for (int64_t i = 0; i < g->node_count; i++) {
+                EngramNode* n = &g->nodes[i];
+                if (engram_layer_is_transparent(n->layer_id)) continue;
+                int sc = engram_node_match_score(n, toks, ntok);
+                double sem = qvec ? engram_node_cosine(n, qvec, qdim) : 0.0;
+                if (sc > 0 || sem >= sem_min) {
+                    cand[nc].idx   = i;
+                    cand[nc].score = (double)sc + sem;
+                    nc++;
                }
-                /* Rank by distinct tokens matched (desc) then salience (desc). */
-                qsort(hits, (size_t)nhits, sizeof(EngramRankEntry),
-                      engram_rank_cmp);
-                int64_t end = nhits < lim ? nhits : lim;
-                for (int64_t k = 0; k < end; k++) {
-                    if (!first) jb_putc(&b, ',');
-                    engram_emit_node_json(&b, &g->nodes[hits[k].idx]);
-                    first = 0;
-                }
-                free(hits);
            }
+            /* Insertion sort by score desc; stable for equal scores. */
+            for (int64_t i = 1; i < nc; i++) {
+                Cand k = cand[i]; int64_t j = i - 1;
+                while (j >= 0 && cand[j].score < k.score) { cand[j + 1] = cand[j]; j--; }
+                cand[j + 1] = k;
+            }
+            int first = 1;
+            for (int64_t i = 0; i < nc && i < lim; i++) {
+                if (!first) jb_putc(&b, ',');
+                engram_emit_node_json(&b, &g->nodes[cand[i].idx]);
+                first = 0;
+            }
+            free(cand);
        }
+        free(qvec);
    }
    jb_putc(&b, ']');
    return el_wrap_str(jb_finish(&b));
@@ -632,6 +632,7 @@ el_val_t  engram_load(el_val_t path);
 * can pass results straight through without round-tripping ElList/ElMap
 * through json_stringify. */
 el_val_t  engram_get_node_json(el_val_t id);
+el_val_t  engram_get_node_by_label(el_val_t label);
 el_val_t  engram_search_json(el_val_t query, el_val_t limit);
 el_val_t  engram_scan_nodes_json(el_val_t limit, el_val_t offset);
 el_val_t  engram_scan_nodes_by_type_json(el_val_t node_type, el_val_t limit, el_val_t offset);
@@ -1072,6 +1072,7 @@ el_val_t __engram_save(el_val_t path)                       { return engram_save
 el_val_t __engram_load(el_val_t path)                       { return engram_load(path); }

 el_val_t __engram_get_node_json(el_val_t id)               { return engram_get_node_json(id); }
+el_val_t __engram_get_node_by_label(el_val_t label)        { return engram_get_node_by_label(label); }

 el_val_t __engram_search_json(el_val_t query, el_val_t limit) {
    return engram_search_json(query, limit);
@@ -226,6 +226,7 @@ el_val_t  __engram_activate(el_val_t query, el_val_t depth);
 el_val_t  __engram_save(el_val_t path);
 el_val_t  __engram_load(el_val_t path);
 el_val_t  __engram_get_node_json(el_val_t id);
+el_val_t  __engram_get_node_by_label(el_val_t label);
 el_val_t  __engram_search_json(el_val_t query, el_val_t limit);
 el_val_t  __engram_scan_nodes_json(el_val_t limit, el_val_t offset);
 el_val_t  __engram_scan_nodes_by_type_json(el_val_t node_type, el_val_t limit, el_val_t offset);
@@ -2670,6 +2670,7 @@ fn builtin_arity(name: String) -> Int {
    if str_eq(name, "engram_save") { return 1 }
    if str_eq(name, "engram_load") { return 1 }
    if str_eq(name, "engram_get_node_json") { return 1 }
+    if str_eq(name, "engram_get_node_by_label") { return 1 }
    if str_eq(name, "engram_search_json") { return 2 }
    if str_eq(name, "engram_scan_nodes_json") { return 2 }
    if str_eq(name, "engram_neighbors_json") { return 3 }
@@ -0,0 +1,186 @@
+#ifndef EL_PLATFORM_WIN_H
+#define EL_PLATFORM_WIN_H
+/*
+ * el_platform_win.h — Windows OS-boundary shim for el_runtime.c.
+ *
+ * Branch: feat/windows-el-runtime. Included ONLY when _WIN32 is defined; the POSIX build is
+ * untouched. Goal: let el_runtime.c (a BSD-sockets / dlfcn / fork host) compile and link with
+ * mingw-w64 into a native neuron.exe, with no behavioural change to the Linux/macOS build.
+ *
+ * What it maps:
+ *   - sockets  : winsock2 (same call names: socket/bind/listen/accept/recv/send/setsockopt).
+ *                Sockets close with closesocket() (see el_closesocket), and the stack must be
+ *                started once with WSAStartup — done automatically via a load-time constructor.
+ *   - dlsym    : el_runtime.c uses dlsym(RTLD_DEFAULT, name) to resolve callback/tool symbols
+ *                exported by the main module. Windows equivalent: GetProcAddress on the process
+ *                module. Link the soul with -Wl,--export-all-symbols so the symbols are findable.
+ *   - popen    : mapped to _popen/_pclose.
+ *   - threads  : UNCHANGED. mingw-w64 ships winpthreads, so <pthread.h> + -lpthread just work.
+ */
+
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#include <windows.h>
+#include <io.h>
+#include <process.h>
+
+/* Portable headers mingw-w64 provides (verified present). */
+#include <stdarg.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <strings.h>   /* strcasecmp */
+#include <ctype.h>
+#include <math.h>
+#include <time.h>
+#include <sys/time.h>  /* mingw-w64 provides gettimeofday here */
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <dirent.h>
+#include <errno.h>
+#include <pthread.h>
+
+/* ── socket close ─────────────────────────────────────────────────────────── */
+/* Winsock closes sockets with closesocket(), not close() (close() is for file fds). The POSIX
+   build defines the same helper as close() so the call sites are identical across platforms. */
+static inline int el_closesocket(SOCKET s) { return closesocket(s); }
+
+/* ── setsockopt optval type ───────────────────────────────────────────────── */
+/* Winsock's setsockopt takes optval as (const char*); POSIX takes (const void*), so el_runtime.c
+   passes &int directly. GCC 14+ makes that an error under -Wincompatible-pointer-types. Wrap it so
+   the runtime's POSIX-style call sites compile unchanged (defined before the macro so the wrapper
+   itself resolves to the real winsock setsockopt). */
+static inline int el_setsockopt(SOCKET s, int level, int optname, const void* optval, int optlen) {
+    return setsockopt(s, level, optname, (const char*)optval, optlen);
+}
+#define setsockopt(s, l, o, v, n) el_setsockopt((s), (l), (o), (v), (int)(n))
+
+/* ── winsock init (once, at load) ─────────────────────────────────────────── */
+static void el__win_net_init(void) {
+    static int inited = 0;
+    if (!inited) { WSADATA w; WSAStartup(MAKEWORD(2, 2), &w); inited = 1; }
+}
+__attribute__((constructor)) static void el__win_ctor(void) { el__win_net_init(); }
+
+/* ── dlsym → GetProcAddress ───────────────────────────────────────────────── */
+#ifndef RTLD_DEFAULT
+#define RTLD_DEFAULT ((void*)0)
+#endif
+static inline void* el_win_dlsym(void* handle, const char* name) {
+    (void)handle;
+    return (void*)(uintptr_t)GetProcAddress(GetModuleHandleA(NULL), name);
+}
+#define dlsym(h, n) el_win_dlsym((h), (n))
+
+/* ── popen / pclose ───────────────────────────────────────────────────────── */
+#define popen  _popen
+#define pclose _pclose
+
+/* ── misc POSIX → Win32 shims ─────────────────────────────────────────────── */
+#include <direct.h>            /* _mkdir */
+#define mkdir(path, mode) _mkdir(path)     /* POSIX mkdir(path,mode) → _mkdir(path) */
+#define timegm _mkgmtime                   /* UTC tm → time_t */
+
+/* setenv/unsetenv: not in the Windows CRT; map to _putenv_s / SetEnvironmentVariable. */
+static inline int setenv(const char* name, const char* value, int overwrite) {
+    (void)overwrite;
+    return _putenv_s(name, value ? value : "");
+}
+static inline int unsetenv(const char* name) {
+    /* _putenv_s(name, "") sets VAR="" rather than removing it.
+     * SetEnvironmentVariableA(name, NULL) truly deletes it from the Win32
+     * env block; then we sync the CRT cache with _putenv("NAME=").       */
+    SetEnvironmentVariableA(name, NULL);
+    size_t len = strlen(name);
+    char *buf = (char*)malloc(len + 2);
+    if (!buf) return -1;
+    memcpy(buf, name, len);
+    buf[len] = '=';
+    buf[len + 1] = '\0';
+    _putenv(buf);
+    free(buf);
+    return 0;
+}
+
+/* nanosleep — not available in MSVC/UCRT; approximate with Sleep(). */
+static inline int el_nanosleep(const struct timespec *req, struct timespec *rem) {
+    (void)rem;
+    DWORD ms = (DWORD)((req->tv_sec * 1000ULL) + (req->tv_nsec / 1000000ULL));
+    Sleep(ms ? ms : 1);
+    return 0;
+}
+#define nanosleep(req, rem) el_nanosleep((req), (rem))
+
+/* localtime_r/gmtime_r: Windows offers localtime_s/gmtime_s with reversed arg order. */
+static inline struct tm* localtime_r(const time_t* t, struct tm* out) {
+    return localtime_s(out, t) == 0 ? out : (struct tm*)0;
+}
+static inline struct tm* gmtime_r(const time_t* t, struct tm* out) {
+    return gmtime_s(out, t) == 0 ? out : (struct tm*)0;
+}
+
+/* ── libcurl: degradable stubs for the curl-less Windows build ─────────────── */
+/* The curl-less validation build (WITH_CURL=0) links no libcurl. el_runtime.c uses libcurl
+ * unconditionally for its HTTP client / LLM layer; these stubs let it compile and link so the
+ * runtime, HTTP *server*, graph and memory work natively on Windows. Live outbound HTTP/LLM calls
+ * degrade to a runtime error (curl_easy_perform returns an error) — matching the documented
+ * curl-less contract. When HAVE_CURL is defined (WITH_CURL=1) the real <curl/curl.h> is used and
+ * this whole block is compiled out. POSIX never sees this header, so the POSIX build is untouched. */
+#ifndef HAVE_CURL
+
+typedef void CURL;
+typedef int  CURLcode;
+
+#define CURLE_OK                    0
+#define CURLE_HTTP_RETURNED_ERROR   22
+#define CURL_ERROR_SIZE             256
+
+/* Option ids: values are irrelevant to the no-op setopt below; kept distinct for readability. */
+#define CURLOPT_URL              10002
+#define CURLOPT_WRITEFUNCTION    20011
+#define CURLOPT_WRITEDATA        10001
+#define CURLOPT_POSTFIELDS       10015
+#define CURLOPT_POSTFIELDSIZE      120
+#define CURLOPT_POST                47
+#define CURLOPT_HTTPHEADER       10023
+#define CURLOPT_TIMEOUT_MS         155
+#define CURLOPT_NOSIGNAL            99
+#define CURLOPT_USERAGENT        10018
+#define CURLOPT_FOLLOWLOCATION      52
+#define CURLOPT_ERRORBUFFER      10010
+#define CURLOPT_CUSTOMREQUEST    10036
+#define CURLOPT_FAILONERROR         45
+
+struct curl_slist { char* data; struct curl_slist* next; };
+
+static inline struct curl_slist* curl_slist_append(struct curl_slist* list, const char* s) {
+    struct curl_slist* node = (struct curl_slist*)malloc(sizeof(struct curl_slist));
+    if (!node) return list;
+    node->data = s ? strdup(s) : NULL;
+    node->next = NULL;
+    if (!list) return node;
+    struct curl_slist* p = list;
+    while (p->next) p = p->next;
+    p->next = node;
+    return list;
+}
+static inline void curl_slist_free_all(struct curl_slist* list) {
+    while (list) { struct curl_slist* n = list->next; free(list->data); free(list); list = n; }
+}
+
+static inline CURL* curl_easy_init(void) { return (CURL*)malloc(1); }
+static inline CURLcode curl_easy_setopt(CURL* h, int opt, ...) { (void)h; (void)opt; return CURLE_OK; }
+static inline CURLcode curl_easy_perform(CURL* h) { (void)h; return 7 /* CURLE_COULDNT_CONNECT */; }
+static inline void curl_easy_cleanup(CURL* h) { free(h); }
+static inline const char* curl_easy_strerror(CURLcode c) {
+    (void)c; return "libcurl not built in (curl-less build)";
+}
+
+#endif /* !HAVE_CURL */
+
+#endif /* EL_PLATFORM_WIN_H */
@@ -21,6 +21,10 @@

 #include "el_runtime.h"

+#ifdef _WIN32
+/* Windows OS-boundary shim (winsock/dlsym/popen). Threading stays on <pthread.h> (winpthreads). */
+#include "el_platform_win.h"
+#else
 #include <stdarg.h>
 #include <strings.h>     /* strcasecmp */
 #include <stdint.h>
@@ -42,7 +46,16 @@
 #include <dirent.h>
 #include <errno.h>
 #include <pthread.h>
+/* On POSIX, sockets close with the same close() as files; el_platform_win.h supplies the Windows
+   variant. Defined here so the socket call sites are identical across platforms. */
+static inline int el_closesocket(int s) { return close(s); }
+#endif
+/* libcurl: present on POSIX and on the WITH_CURL Windows build; absent on the curl-less Windows
+   validation build, where el_platform_win.h supplies degradable stubs. On POSIX (_WIN32 undefined)
+   this is always taken, so the POSIX build is unchanged. */
+#if !defined(_WIN32) || defined(HAVE_CURL)
 #include <curl/curl.h>
+#endif

 /* ── Internal allocators ─────────────────────────────────────────────────── */

@@ -71,8 +84,14 @@ static _Thread_local ElArena _tl_arena = {NULL, 0, 0};
 static _Thread_local int     _tl_arena_active = 0;

 /* Binary-safe fs_read length — set by fs_read, consumed by http_send_response.
- * Allows serving PNGs and other binary files without strlen truncation. */
-static _Thread_local size_t  _tl_fs_read_len  = 0;
+ * Allows serving PNGs and other binary files without strlen truncation.
+ * PAIRED with the buffer pointer it describes: the length may only be applied
+ * to the exact buffer fs_read returned. Without the pairing, any handler that
+ * fs_read a file and then WRAPPED it into a larger response had that response
+ * truncated to the file's length (Content-Length lied AND the send stopped
+ * short) — the safety-contact onboarding trap, 2026-07-17. */
+static _Thread_local size_t      _tl_fs_read_len  = 0;
+static _Thread_local const char* _tl_fs_read_buf  = NULL;

 static void el_arena_track(char* p) {
    if (!_tl_arena_active || !p) return;
@@ -90,6 +109,8 @@ static void el_arena_track(char* p) {
 void el_request_start(void) {
    _tl_arena.count  = 0;
    _tl_arena_active = 1;
+    _tl_fs_read_len  = 0;     /* never let a previous request's file length */
+    _tl_fs_read_buf  = NULL;  /* leak into this response's byte accounting  */
 }

 /* Called by http_worker after the El handler returns and the response is sent.
@@ -1403,11 +1424,14 @@ static void http_send_response(int fd, const char* body) {
    }

    const char* eff_body = is_envelope ? env_body : body;
-    /* Use the real byte count from fs_read if available (handles binary files
-     * with embedded null bytes — PNG, WOFF2, etc.). Fall back to strlen for
-     * normal text/JSON responses where _tl_fs_read_len is 0. */
-    size_t blen = (_tl_fs_read_len > 0) ? _tl_fs_read_len : strlen(eff_body);
+    /* Use the real byte count from fs_read ONLY when this body IS the exact
+     * buffer fs_read returned (binary files with embedded null bytes — PNG,
+     * WOFF2, etc.). Any other body — wrapped, enveloped, or derived — must be
+     * measured with strlen, or it is truncated/over-read to the file's size. */
+    size_t blen = (_tl_fs_read_len > 0 && eff_body == _tl_fs_read_buf)
+                      ? _tl_fs_read_len : strlen(eff_body);
    _tl_fs_read_len = 0;  /* consume — one-shot per response */
+    _tl_fs_read_buf = NULL;
    int head_only = _tl_http_head_only;

    JsonBuf hdrs; jb_init(&hdrs);
@@ -1457,12 +1481,20 @@ static void http_send_response(int fd, const char* body) {
 }

 typedef struct {
+#ifdef _WIN32
+    SOCKET fd;
+#else
    int fd;
+#endif
 } HttpWorkerArg;

 static void* http_worker(void* arg) {
    HttpWorkerArg* a = (HttpWorkerArg*)arg;
+#ifdef _WIN32
+    SOCKET fd = a->fd;
+#else
    int fd = a->fd;
+#endif
    free(a);
    char *method = NULL, *path = NULL, *body = NULL;
    if (http_read_request(fd, &method, &path, &body, NULL) == 0) {
@@ -1479,11 +1511,22 @@ static void* http_worker(void* arg) {
            const char* rs = EL_CSTR(r);
            /* Copy response out BEFORE arena teardown.
             * For binary files, _tl_fs_read_len holds the real byte count —
-             * use memcpy instead of strdup so null bytes are preserved. */
-            size_t rlen = _tl_fs_read_len > 0 ? _tl_fs_read_len : (rs ? strlen(rs) : 0);
+             * use memcpy instead of strdup so null bytes are preserved.
+             * The stored length applies ONLY when the response IS the exact
+             * fs_read buffer; a wrapped/derived response must use strlen or
+             * it gets truncated (or over-read) to the file's length. */
+            size_t rlen;
+            if (_tl_fs_read_len > 0 && rs && rs == _tl_fs_read_buf) {
+                rlen = _tl_fs_read_len;   /* raw file bytes — binary-safe */
+            } else {
+                rlen = rs ? strlen(rs) : 0;
+                _tl_fs_read_len = 0;      /* hint doesn't describe this body */
+                _tl_fs_read_buf = NULL;
+            }
            response = malloc(rlen + 1);
            if (response && rs) { memcpy(response, rs, rlen); response[rlen] = '\0'; }
            else if (response) { response[0] = '\0'; }
+            if (_tl_fs_read_len > 0) _tl_fs_read_buf = response; /* hint follows the copy */
        } else {
            response = el_strdup_persist("el-runtime: no http handler registered");
        }
@@ -1494,7 +1537,7 @@ static void* http_worker(void* arg) {
        free(response);
    }
    free(method); free(path); free(body);
-    close(fd);
+    el_closesocket(fd);
    /* release a slot */
    pthread_mutex_lock(&_http_conn_mu);
    _http_conn_active--;
@@ -1524,14 +1567,18 @@ void http_serve(el_val_t port, el_val_t handler) {
    addr.sin6_addr = in6addr_any;
    addr.sin6_port = htons((uint16_t)p);
    if (bind(sock, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
-        perror("bind"); close(sock); return;
+        perror("bind"); el_closesocket(sock); return;
    }
-    if (listen(sock, 64) < 0) { perror("listen"); close(sock); return; }
+    if (listen(sock, 64) < 0) { perror("listen"); el_closesocket(sock); return; }
    fprintf(stderr, "[http] listening on [::]:%d (dual-stack)\n", p);
    while (1) {
        struct sockaddr_in6 cli;
        socklen_t clen = sizeof(cli);
+#ifdef _WIN32
+        SOCKET cfd = accept(sock, (struct sockaddr*)&cli, &clen);
+#else
        int cfd = accept(sock, (struct sockaddr*)&cli, &clen);
+#endif
        if (cfd < 0) {
            if (errno == EINTR) continue;
            perror("accept"); break;
@@ -1543,11 +1590,11 @@ void http_serve(el_val_t port, el_val_t handler) {
        _http_conn_active++;
        pthread_mutex_unlock(&_http_conn_mu);
        HttpWorkerArg* arg = malloc(sizeof(HttpWorkerArg));
-        if (!arg) { close(cfd); continue; }
+        if (!arg) { el_closesocket(cfd); continue; }
        arg->fd = cfd;
        pthread_t tid;
        if (pthread_create(&tid, NULL, http_worker, arg) != 0) {
-            close(cfd); free(arg);
+            el_closesocket(cfd); free(arg);
            pthread_mutex_lock(&_http_conn_mu);
            _http_conn_active--;
            pthread_cond_signal(&_http_conn_cv);
@@ -1556,7 +1603,7 @@ void http_serve(el_val_t port, el_val_t handler) {
        }
        pthread_detach(tid);
    }
-    close(sock);
+    el_closesocket(sock);
 }

 /* ── http_serve_async — non-blocking HTTP server ─────────────────────────── */
@@ -1792,7 +1839,11 @@ static el_val_t http_build_headers_map(const char* hdr_block) {

 static void* http_worker_v2(void* arg) {
    HttpWorkerArg* a = (HttpWorkerArg*)arg;
+#ifdef _WIN32
+    SOCKET fd = a->fd;
+#else
    int fd = a->fd;
+#endif
    free(a);
    char *method = NULL, *path = NULL, *body = NULL, *hdr_block = NULL;
    if (http_read_request(fd, &method, &path, &body, &hdr_block) == 0) {
@@ -1805,10 +1856,20 @@ static void* http_worker_v2(void* arg) {
            el_val_t hmap = http_build_headers_map(hdr_block ? hdr_block : "");
            el_val_t r = h(EL_STR(dispatch_method), EL_STR(path), hmap, EL_STR(body));
            const char* rs = EL_CSTR(r);
-            size_t rlen = _tl_fs_read_len > 0 ? _tl_fs_read_len : (rs ? strlen(rs) : 0);
+            /* Same pairing rule as the v1 worker: the fs_read length is only
+             * trustworthy for the exact buffer fs_read returned. */
+            size_t rlen;
+            if (_tl_fs_read_len > 0 && rs && rs == _tl_fs_read_buf) {
+                rlen = _tl_fs_read_len;   /* raw file bytes — binary-safe */
+            } else {
+                rlen = rs ? strlen(rs) : 0;
+                _tl_fs_read_len = 0;      /* hint doesn't describe this body */
+                _tl_fs_read_buf = NULL;
+            }
            response = malloc(rlen + 1);
            if (response && rs) { memcpy(response, rs, rlen); response[rlen] = '\0'; }
            else if (response) { response[0] = '\0'; }
+            if (_tl_fs_read_len > 0) _tl_fs_read_buf = response; /* hint follows the copy */
            el_release(hmap);
        } else {
            response = el_strdup_persist(
@@ -1822,7 +1883,7 @@ static void* http_worker_v2(void* arg) {
        free(response);
    }
    free(method); free(path); free(body); free(hdr_block);
-    close(fd);
+    el_closesocket(fd);
    pthread_mutex_lock(&_http_conn_mu);
    _http_conn_active--;
    pthread_cond_signal(&_http_conn_cv);
@@ -1852,14 +1913,18 @@ void http_serve_v2(el_val_t port, el_val_t handler) {
    addr.sin6_addr = in6addr_any;
    addr.sin6_port = htons((uint16_t)p);
    if (bind(sock, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
-        perror("bind"); close(sock); return;
+        perror("bind"); el_closesocket(sock); return;
    }
-    if (listen(sock, 64) < 0) { perror("listen"); close(sock); return; }
+    if (listen(sock, 64) < 0) { perror("listen"); el_closesocket(sock); return; }
    fprintf(stderr, "[http v2] listening on [::]:%d (dual-stack)\n", p);
    while (1) {
        struct sockaddr_in6 cli;
        socklen_t clen = sizeof(cli);
+#ifdef _WIN32
+        SOCKET cfd = accept(sock, (struct sockaddr*)&cli, &clen);
+#else
        int cfd = accept(sock, (struct sockaddr*)&cli, &clen);
+#endif
        if (cfd < 0) {
            if (errno == EINTR) continue;
            perror("accept"); break;
@@ -1871,11 +1936,11 @@ void http_serve_v2(el_val_t port, el_val_t handler) {
        _http_conn_active++;
        pthread_mutex_unlock(&_http_conn_mu);
        HttpWorkerArg* arg = malloc(sizeof(HttpWorkerArg));
-        if (!arg) { close(cfd); continue; }
+        if (!arg) { el_closesocket(cfd); continue; }
        arg->fd = cfd;
        pthread_t tid;
        if (pthread_create(&tid, NULL, http_worker_v2, arg) != 0) {
-            close(cfd); free(arg);
+            el_closesocket(cfd); free(arg);
            pthread_mutex_lock(&_http_conn_mu);
            _http_conn_active--;
            pthread_cond_signal(&_http_conn_cv);
@@ -1884,7 +1949,7 @@ void http_serve_v2(el_val_t port, el_val_t handler) {
        }
        pthread_detach(tid);
    }
-    close(sock);
+    el_closesocket(sock);
 }

 /* Build the response envelope a 4-arg handler can return. We hand-write
@@ -1924,6 +1989,7 @@ el_val_t http_response(el_val_t status, el_val_t headers_json, el_val_t body) {
 el_val_t fs_read(el_val_t pathv) {
    const char* path = EL_CSTR(pathv);
    _tl_fs_read_len = 0;
+    _tl_fs_read_buf = NULL;
    if (!path) return el_wrap_str(el_strdup(""));
    FILE* f = fopen(path, "rb");
    if (!f) return el_wrap_str(el_strdup(""));
@@ -1935,6 +2001,7 @@ el_val_t fs_read(el_val_t pathv) {
    size_t got = fread(buf, 1, (size_t)sz, f);
    buf[got] = '\0';
    _tl_fs_read_len = got;   /* store real byte count for binary-safe send */
+    _tl_fs_read_buf = buf;   /* ...valid ONLY for this exact buffer */
    fclose(f);
    return el_wrap_str(buf);
 }
@@ -2029,6 +2096,23 @@ el_val_t exec(el_val_t cmdv) {
 el_val_t exec_bg(el_val_t cmdv) {
    const char* cmd = EL_CSTR(cmdv);
    if (!cmd || !*cmd) return el_wrap_str(el_strdup(""));
+#ifdef _WIN32
+    /* Windows: no fork/exec. Launch a detached `cmd /c <command>` with no console window via
+       CreateProcess (DETACHED_PROCESS | CREATE_NO_WINDOW). Returns the PID as a string, "" on fail.
+       Mirrors the POSIX branch: child runs independently, caller is not blocked. */
+    char cmdline[8192];
+    snprintf(cmdline, sizeof(cmdline), "cmd.exe /c %s", cmd);
+    STARTUPINFOA si; ZeroMemory(&si, sizeof(si)); si.cb = sizeof(si);
+    PROCESS_INFORMATION pi; ZeroMemory(&pi, sizeof(pi));
+    BOOL ok = CreateProcessA(NULL, cmdline, NULL, NULL, FALSE,
+                             DETACHED_PROCESS | CREATE_NO_WINDOW, NULL, NULL, &si, &pi);
+    if (!ok) return el_wrap_str(el_strdup(""));
+    char pidbuf[32];
+    snprintf(pidbuf, sizeof(pidbuf), "%lu", (unsigned long)pi.dwProcessId);
+    CloseHandle(pi.hProcess);
+    CloseHandle(pi.hThread);
+    return el_wrap_str(el_strdup(pidbuf));
+#else
    pid_t pid = fork();
    if (pid < 0) {
        /* fork failed */
@@ -2051,6 +2135,7 @@ el_val_t exec_bg(el_val_t cmdv) {
    char pidbuf[32];
    snprintf(pidbuf, sizeof(pidbuf), "%d", (int)pid);
    return el_wrap_str(el_strdup(pidbuf));
+#endif
 }

 el_val_t fs_list(el_val_t pathv) {
@@ -3305,8 +3390,10 @@ el_val_t json_get_raw(el_val_t json_str, el_val_t key) {
    const char* k    = EL_CSTR(key);
    const char* p = json_find_key(json, k);
    /* Clear fs_read binary-length hint — result is a fresh null-terminated
-     * string, not the raw file bytes, so Content-Length must use strlen. */
+     * string, not the raw file bytes, so Content-Length must use strlen.
+     * (Kept although the pointer pairing now makes this redundant.) */
    _tl_fs_read_len = 0;
+    _tl_fs_read_buf = NULL;
    if (!p) return el_wrap_str(el_strdup(""));
    const char* end = json_skip_value(p);
    size_t n = (size_t)(end - p);
@@ -4178,7 +4265,12 @@ static int _el_decompose_earth(el_caltime_t* ct, struct tm* tm_out, int* abbr_le
    localtime_r(&s, &tm);
    *tm_out = tm;
    if (abbr_buf && abbr_cap > 0) {
+        /* mingw's struct tm has no tm_zone (BSD/glibc extension); no abbrev available there. */
+#ifdef _WIN32
+        const char* z_str = "";
+#else
        const char* z_str = tm.tm_zone ? tm.tm_zone : "";
+#endif
        size_t n = strlen(z_str);
        if (n >= abbr_cap) n = abbr_cap - 1;
        memcpy(abbr_buf, z_str, n);
@@ -758,6 +758,18 @@ el_val_t trace_span_start(el_val_t name);
 el_val_t trace_span_end(el_val_t span_handle);
 el_val_t emit_event(el_val_t name, el_val_t duration_ms);

+/* ── Runtime symbols required by the soul modules ──────────────────────────── */
+/* All implemented in el_runtime.c but omitted from this release header; the soul dist modules
+ * reference them directly, so the public header must export them. Declarations only — mirrors the
+ * mainline el_runtime.h and is platform-independent (no behavioural change to the POSIX build). */
+typedef el_val_t (*http_handler_fn)(el_val_t method, el_val_t path, el_val_t body);
+typedef el_val_t (*http_handler4_fn)(el_val_t method, el_val_t path, el_val_t body, el_val_t headers);
+el_val_t  el_arena_push(void);
+el_val_t  el_arena_pop(el_val_t mark);
+void      http_serve_async(el_val_t port, el_val_t handler);
+el_val_t  engram_get_node_by_label(el_val_t label);
+el_val_t  engram_prune_telemetry(el_val_t older_than_ms);
+
 #ifdef __cplusplus
 }
 #endif
Author	SHA1	Message	Date
bigmerge	b7e2c580a8	Add native speech synthesis and voice-imitation faculty El SDK CI - dev / build-and-test (pull_request) Successful in 6m28s Details speech.el: formant/glottal integer DSP synthesis + voice-analyze-by- imitation. voice-profile.el / voice-ingest.el: voice-profile plumbing. accent.el: British-RP as an ingested transform-geometry (explicitly marked provisional/citation-pending by its own comments). organ-read.el: engram read-through for the speech organ. Includes demo/test drivers and non-personal reference data (British-RP phonetics/lexicon derived data, a public-domain LibriVox RP reference recording). Deliberately excludes elp/data/live/ (raw recorded voice + face-photo samples of the repo owner) and the will-*.{json,psv} derived voiceprint files — personal biometric data that shouldn't be committed to a shared repo without an explicit decision from the owner. Also excludes this worktree's elp/src/surface-profile.el, which diverges from the copy in other worktrees (agent-aaf04b0a9714c4070, main) — needs manual reconciliation before landing, left out here to avoid silently picking a version.	2026-08-15 14:27:52 -05:00
will.anderson	d71fc4c1c0	Merge pull request 'promote stage -> main: reconciled el runtime (engram search + natives + durable truncation fix + Windows port)' (#82 ) from stage into main El SDK Release / build-and-release (push) Successful in 8m31s Details El SDK CI - dev / build-and-test (pull_request) Successful in 8m41s Details	2026-07-22 21:44:01 +00:00
will.anderson	a118d19393	Merge pull request 'promote dev -> stage: el cluster (#66 engram + #79 truncation fix + release-runtime Windows port)' (#81 ) from dev into stage El SDK CI - stage / build-and-test (push) Successful in 7m58s Details El SDK Release / build-and-release (pull_request) Successful in 4m16s Details	2026-07-22 21:20:17 +00:00
will.anderson	c6aa1e5c53	Merge pull request 'Land el cluster: #66 engram search + natives, #79 truncation fix, + release-runtime Windows port (reconciled)' (#80 ) from reconcile/el-cluster-windows-runtime into dev El SDK CI - dev / build-and-test (push) Successful in 8m3s Details El SDK CI - stage / build-and-test (pull_request) Successful in 4m25s Details Land el cluster (#66 + #79 + release-runtime Windows-port reconciliation) into dev	2026-07-22 21:06:36 +00:00
will.anderson	ff577391f2	reconcile(release-runtime): Windows-port + complete v1.0.0 release runtime so the desktop soul cross-compiles El SDK CI - dev / build-and-test (pull_request) Successful in 7m7s Details The desktop soul (neuron/dist) compiles against the v1.0.0-20260501 release runtime. After #66 landed the engram natives (tokenized/ranked search, engram_prune_telemetry) and #79 the durable truncation fix into this runtime, two gaps remained before it could cross-compile the Windows brain: 1. Windows OS boundary: the release runtime had no Win32 path. Ported the same _WIN32-guarded shim the mainline runtime carries (#69): #ifdef _WIN32 -> el_platform_win.h (winsock/dlsym/popen + WSAStartup ctor), SOCKET fd guards and el_closesocket() at every socket site, CreateProcessA for exec_bg, the tm_zone/mingw guard, an el_setsockopt optval wrapper (GCC14), and curl-less libcurl stubs. Every change is _WIN32/HAVE_CURL-gated — the POSIX build is byte-identical (gcc -fsyntax-only clean; native behaviour unchanged). 2. Header exports: the release el_runtime.h omitted symbols the soul dist calls that are defined in this runtime's .c — the http_handler_fn/http_handler4_fn typedefs and el_arena_push/pop, engram_prune_telemetry, engram_get_node_by_label. Declaration-only, POSIX-neutral; fixes implicit-declaration/unknown-type errors under the C11 mingw build. Result: x86_64-w64-mingw32-gcc compiles el_runtime.c + all 48 soul modules clean; POSIX gcc -fsyntax-only clean. This is the Windows-port PR the runtime needed on main (the release-runtime counterpart to #69), landed via stage.	2026-07-22 15:56:08 -05:00
will.anderson	ee0d5f9b97	Merge #79 : durable HTTP response-truncation fix, both runtimes (via stage)	2026-07-22 15:46:02 -05:00
will.anderson	391bd818ea	Merge #66 : tokenized+ranked engram lexical search + engram natives (via stage)	2026-07-22 15:45:54 -05:00
will.anderson	43636aed99	runtime: pair fs_read length hint with its buffer in BOTH runtimes — kill response truncation for good El SDK Release / build-and-release (pull_request) Failing after 7s Details The binary-safe fs_read length (_tl_fs_read_len) was consumed by the HTTP response path for ANY body, even when a handler wrapped a smaller file into a larger reply. Content-Length then lied AND the send stopped short: the safety-contact (988) routes returned 178 of 208/218 bytes, cut mid-'set_at' — unparseable JSON. The desktop app read that as failure. On Windows the shipped brain is an OLD build without even the per-handler workaround, so EVERY reply truncated: the app can't read confirmations and refuses the new user. Durable fix: pair the length hint with the exact buffer pointer it describes (_tl_fs_read_buf). Apply the raw byte count ONLY when the response IS that buffer (binary file serving stays correct); every wrapped/enveloped/derived body is measured with strlen. Reset both at request start and in fs_read / json_get_raw. This also closes the stale-hint heap over-read (a length larger than a later body would read past it out the socket) that a plain max() leaves open — so this class of bug dies on every platform, not just where a handler happened to be patched. Applied identically to the mainline runtime (lang/el-compiler/runtime) AND the frozen release runtime (lang/releases/v1.0.0-20260501) the desktop souls compile against — the release copy still carried the raw leak, which is why the Windows brain kept truncating. Same proven approach as PR #78 (Tim Lingo), extended to cover the release runtime and rebased onto current main. Both runtimes: gcc -fsyntax-only clean.	2026-07-22 15:04:25 -05:00
will.anderson	2baa0b9a41	Merge pull request 'release: promote stage -> main (ci publish hardening for sdk-release)' (#77 ) from stage into main El SDK Release / build-and-release (push) Successful in 7m55s Details	2026-07-15 21:21:28 +00:00
will.anderson	6a8b2461cd	Merge pull request 'release: promote dev -> stage (ci publish hardening for stage/main)' (#76 ) from dev into stage El SDK CI - stage / build-and-test (push) Successful in 8m19s Details El SDK Release / build-and-release (pull_request) Failing after 13m1s Details	2026-07-15 21:16:11 +00:00
will.anderson	bcb356fe69	Merge pull request 'ci(stage,main): decouple ci-base rebuild, make SDK publish fail loudly' (#75 ) from hotfix/ci-stage-main-publish-hardening into dev El SDK CI - stage / build-and-test (pull_request) Successful in 4m27s Details El SDK CI - dev / build-and-test (push) Failing after 14m3s Details	2026-07-15 21:15:27 +00:00
will.anderson	dd7827059a	ci(stage,main): decouple ci-base rebuild, make SDK publish fail loudly El SDK CI - dev / build-and-test (pull_request) Failing after 14m30s Details Mirror the PR #72 fix (applied to ci-dev.yaml) onto ci-stage.yaml and sdk-release.yaml. The stage and prod release jobs reported FAILURE even when the el-runtime-c/-h publish SUCCEEDED, because the ancillary ci-base Docker rebuild (a CI-cache optimization on the fragile host-mode GCE runner) reddened the whole job. - Rebuild ci-base step: continue-on-error: true — never blocks/reddens the job; the SDK publish is the deliverable. - Publish step: set -euo pipefail + empty-key guard + active-account echo so a real publish failure still fails loud and is diagnosable.	2026-07-15 16:14:50 -05:00
will.anderson	208e36c899	Merge pull request 'release: promote stage -> main (tokenized search, get_node_by_label, epm fix, win portability)' (#74 ) from stage into main El SDK Release / build-and-release (push) Successful in 8m23s Details	2026-07-15 18:24:39 +00:00
will.anderson	b97ce74d1f	Merge pull request 'release: promote dev -> stage (tokenized search, get_node_by_label, epm fix)' (#73 ) from dev into stage El SDK CI - stage / build-and-test (push) Failing after 8m45s Details El SDK Release / build-and-release (pull_request) Successful in 4m1s Details	2026-07-15 17:20:11 +00:00
will.anderson	155a449c4e	Merge pull request 'ci(dev): make SDK publish fail loudly, decouple ci-base rebuild' (#72 ) from hotfix/ci-dev-publish-hardening into dev El SDK CI - dev / build-and-test (push) Successful in 8m56s Details El SDK CI - stage / build-and-test (pull_request) Successful in 4m10s Details	2026-07-15 16:34:14 +00:00
will.anderson	4696fd6833	ci(dev): make SDK publish fail loudly, decouple ci-base rebuild El SDK CI - dev / build-and-test (pull_request) Successful in 8m51s Details The dev push build went green-then-red while nothing published: the Publish step had no set -e, so an auth/upload failure exited 0 (silent no-publish), while the ci-base rebuild (set -euo pipefail + Docker on the host-mode runner) hard-failed the job. Add set -euo pipefail + an empty-key guard + active-account echo to the Publish step so failures surface with a retrievable log, and mark the ci-base cache rebuild continue-on-error so the fragile Docker step can never block the actual SDK artifact publish.	2026-07-15 11:33:37 -05:00
will.anderson	581a351fb1	Merge pull request 'integrate: stack PRs #65–#69 (elc OOM guard, tokenized+semantic engram search, get_node_by_label, win portability) for green CI' (#71 ) from hotfix/stage-elc-engram-integration into dev El SDK CI - dev / build-and-test (push) Failing after 14m31s Details	2026-07-15 15:49:57 +00:00
will.anderson	8ce8656de2	epm: declare cross-module callees as extern fn so strict compilers accept generated C El SDK CI - dev / build-and-test (pull_request) Successful in 7m33s Details epm's sibling modules (registry/install/update) call functions defined in other modules and in the El runtime (config, read_installed, registry_find, manifest_deps, manifest_name, registry_latest_version, registry_token, install_vessel, installed_version) without importing them, so elc emits no C prototype for those calls. gcc<=13 treated the resulting implicit declarations as warnings; gcc>=14 and clang reject them as hard errors, which is why the "Build epm" CI step fails and blocks the whole dev/stage pipeline. Add `extern fn` forward declarations -- El's own separate-compilation mechanism -- for each cross-module callee at the top of registry/install/update. This gives elc the correct C prototype in every generated translation unit, so the calls compile cleanly and still resolve at link time. Simply suppressing -Wimplicit-function-declaration would be unsafe: an implicit int return truncates the 64-bit pointer returns of config/registry_find into a latent crash, so declaring the true signatures is the correct fix. Localized to epm; touches neither elc nor the runtime.	2026-07-15 10:14:43 -05:00
will.anderson	1e49560f1f	Merge remote-tracking branch 'origin/feat/engram-semantic-search' into hotfix/stage-elc-engram-integration El SDK CI - dev / build-and-test (pull_request) Failing after 14m39s Details # Conflicts: # lang/el-compiler/runtime/el_runtime.c	2026-07-15 09:33:05 -05:00
will.anderson	e8f0b5a9de	Merge remote-tracking branch 'origin/fix/engram-lexical-tokenized-search' into hotfix/stage-elc-engram-integration	2026-07-15 09:28:44 -05:00
will.anderson	40287c4cfc	Merge remote-tracking branch 'origin/hotfix/win-runtime-portability' into hotfix/stage-elc-engram-integration	2026-07-15 09:28:44 -05:00
will.anderson	0481bea44d	Merge remote-tracking branch 'origin/hotfix/runtime-engram-get-node-by-label' into hotfix/stage-elc-engram-integration	2026-07-15 09:28:44 -05:00
will.anderson	9d565ca080	Merge remote-tracking branch 'origin/hotfix/elc-fixes' into hotfix/stage-elc-engram-integration	2026-07-15 09:28:44 -05:00
will.anderson	4773dd0aa2	runtime: make Windows soul reproducible from a clean el checkout El SDK Release / build-and-release (pull_request) Failing after 16s Details Two el_runtime portability defects only ever lived in staged local copies used to hand-build neuron-ui PR #136's curl-enabled Windows neuron.exe. gcc 15 promotes both to hard errors, so a clean el checkout cannot rebuild that soul. Upstream the minimal fixes so the build is reproducible: - http_serve_async: cast setsockopt optval to (const char). Win32/mingw setsockopt wants const char, not int*; the cast is a no-op on POSIX and matches the four already-cast sites elsewhere in this file. - engram_save persist path: map fsync -> _commit in the _WIN32-only el_platform_win.h (io.h already included). Windows has no fsync(); the POSIX path is untouched.	2026-07-15 04:24:08 -05:00
will.anderson	6b9d9e6c4a	Add engram_get_node_by_label runtime native to unblock soul link El SDK Release / build-and-release (pull_request) Failing after 22s Details chat.el calls the runtime native engram_get_node_by_label to fetch well-known nodes (conv:history, session:summary) by stable label rather than by ID — immune to vector-index drift across restarts. The current runtime never defined it, so the regenerated dist/soul.c fails to link. Backport the function verbatim (idiom-adapted to jb_finish) from release runtime v1.0.0-20260501 and register it as an EL builtin exactly like its siblings: runtime definition + prototype, __-prefixed seed wrapper + prototype, and codegen arity entry. No search-site code is touched.	2026-07-15 04:07:33 -05:00
will.anderson	b4967af13e	feat(engram): semantic search layer via nomic-embed-text (cosine ∪ lexical) Lexical istr_contains alone can't surface a node whose words don't appear in the query. This adds an optional dense-vector layer: node content and the query are embedded through Ollama (nomic-embed-text), and nodes are ranked by cosine similarity unioned with lexical hits, so a paraphrase query reaches the right node. Wired into all three query entry points in el_runtime.c: - engram_search_json (HTTP /api/search): collect lexical ∪ semantic candidates, score (lexical base 1.0 + cosine; pure-semantic = cosine), rank, emit top-N. Stable sort preserves old order when semantic is off. - engram_search (internal el_val twin): lexical ∪ semantic union. - engram_activate seed loop (HTTP /api/activate): a node seeds if it lexically matches OR clears the cosine threshold; pure-semantic seeds enter scaled by cosine so paraphrase spreads without overpowering. Degradable by design: the whole layer is gated on HAVE_CURL plus a one-shot runtime probe. If curl is compiled out, Ollama is unreachable, or ENGRAM_SEMANTIC=0, every entry point yields zero semantic signal and callers fall back byte-for-byte to the pre-existing lexical search. Node embeddings are cached in process memory keyed by node id with an FNV-1a content hash for invalidation; the query is embedded once per call — so the graph is not re-embedded on every query. nomic task prefixes (search_query:/search_document:) are applied for retrieval separation. Build steps gain -DHAVE_CURL so the engram artifact compiles the layer in (-lcurl was already linked). Env: ENGRAM_SEMANTIC, ENGRAM_EMBED_URL, ENGRAM_EMBED_MODEL, ENGRAM_SEMANTIC_MIN (cosine threshold, default 0.6).	2026-07-14 18:48:16 -05:00
will.anderson	2b2a1246e7	Merge pull request 'runtime: fix the memory-leak + write-corruption pair in el_runtime.c' (#64 ) from hotfix/el-runtime-leak-and-persist into main El SDK Release / build-and-release (push) Failing after 10m52s Details	2026-07-13 21:23:31 +00:00
will.anderson	5c41c66a0f	Merge pull request 'fix(windows): guard el_mem_check with _WIN32 — rusage is POSIX-only' (#60 ) from fix/windows-rusage-guard into stage El SDK CI - stage / build-and-test (push) Failing after 13m21s Details fix(windows): guard el_mem_check with _WIN32 — rusage is POSIX-only	2026-06-25 16:48:13 +00:00