soul: engram-store wiring (soul client path) + elc-fold source fixes

- soul.el/memory.el: ENGRAM_STORE-gated store boot/checkpoint (client path) + fix a
  latent memory.el segfault (engram_save returns Int, was str_eq'd as a pointer).
- sessions.el/safety.el/chat.el: fix malformed El constructs that hung the elc fold
  (unterminated string literals, block-expression, undefined distill_transcript).

.gitea/workflows/ci.yaml

@@ -9,8 +9,10 @@ on:
       - main
   workflow_dispatch:
 
-# Same group as deploy-gke so builds and deploys queue behind each other.
-# Prevents concurrent Docker daemon exhaustion on the single GCE runner.
+# Serialize all activity on the single GCE runner.
+# With build+deploy in the same workflow, a new push queues a single
+# workflow instance — not two competing ones — so the deploy job is
+# never orphaned by a cancellation race.
 concurrency:
   group: neuron-runner
   cancel-in-progress: false
@@ -29,12 +31,6 @@ jobs:
       - name: Checkout
         uses: actions/checkout@v4
 
-      - name: Checkout foundation/el (ELP source for soul.el imports)
-        run: |
-          git clone https://git.neuralplatform.ai/neuron-technologies/el.git \
-            --depth=1 --branch=main \
-            ../foundation/el
-
       - name: Install build dependencies
         run: |
           apt-get update -qq
@@ -43,7 +39,7 @@ jobs:
             > /etc/apt/sources.list.d/google-cloud-sdk.list
           apt-get update -qq && apt-get install -y google-cloud-cli
 
-      - name: Download El SDK from Artifact Registry
+      - name: Download El runtime from Artifact Registry
         env:
           GCP_SA_KEY: ${{ secrets.GCP_SA_KEY }}
         run: |
@@ -51,10 +47,12 @@ jobs:
           gcloud auth activate-service-account --key-file=/tmp/gcp-key.json
           gcloud config set project neuron-785695
 
-          rm -rf /opt/el/dist /opt/el/runtime
-          mkdir -p /opt/el/dist/platform /opt/el/dist/bin /opt/el/runtime
+          rm -rf /opt/el/runtime
+          mkdir -p /opt/el/runtime
 
-          # Get latest version of each package
+          # Get latest version of each runtime package (elc/elb not needed — we compile
+          # dist/soul.c directly; running elb on Linux OOM-kills the runner, and we
+          # always use the repo's pre-built soul.c anyway).
           get_latest() {
             gcloud artifacts versions list \
               --repository=foundation-prod \
@@ -66,22 +64,10 @@ jobs:
               --format="value(name)" 2>/dev/null | awk -F/ '{print $NF}'
           }
 
-          ELC_VER=$(get_latest el-elc)
-          ELB_VER=$(get_latest el-elb)
           RC_VER=$(get_latest el-runtime-c)
           RH_VER=$(get_latest el-runtime-h)
 
-          echo "Downloading elc@${ELC_VER} elb@${ELB_VER} runtime@${RC_VER}"
-
-          gcloud artifacts generic download \
-            --repository=foundation-prod --location=us-central1 --project=neuron-785695 \
-            --package=el-elc --version="${ELC_VER}" \
-            --destination=/opt/el/dist/platform/
-
-          gcloud artifacts generic download \
-            --repository=foundation-prod --location=us-central1 --project=neuron-785695 \
-            --package=el-elb --version="${ELB_VER}" \
-            --destination=/opt/el/dist/bin/
+          echo "Downloading runtime@${RC_VER}"
 
           gcloud artifacts generic download \
             --repository=foundation-prod --location=us-central1 --project=neuron-785695 \
@@ -93,39 +79,20 @@ jobs:
             --package=el-runtime-h --version="${RH_VER}" \
             --destination=/opt/el/runtime/
 
-          # Downloaded files keep original names; rename to canonical paths
-          mv /opt/el/dist/platform/elc* /opt/el/dist/platform/elc 2>/dev/null || true
-          mv /opt/el/dist/bin/elb*       /opt/el/dist/bin/elb      2>/dev/null || true
           mv /opt/el/runtime/el_runtime.c* /opt/el/runtime/el_runtime.c 2>/dev/null || true
           mv /opt/el/runtime/el_runtime.h* /opt/el/runtime/el_runtime.h 2>/dev/null || true
-
-          chmod +x /opt/el/dist/platform/elc /opt/el/dist/bin/elb
-          echo "El SDK ready"
-          /opt/el/dist/platform/elc --version || true
+          echo "El runtime ready: $(ls /opt/el/runtime/)"
 
       - name: Build neuron soul binary
         run: |
-          ELB=/opt/el/dist/bin/elb
-          ELC=/opt/el/dist/platform/elc
           RUNTIME=/opt/el/runtime
 
-          # Preserve the pre-compiled dist/soul.c from the repo before running elb.
-          # elb may overwrite it during compilation; we always want the repo version
-          # since it contains the patched self-contained translation unit (all modules
-          # inlined, workspace scope fix, agentic dedup fix, etc.).
-          cp dist/soul.c /tmp/soul.c.prebuilt
-
-          # Compile all El modules to C via elb.
-          # elb fails at link on Linux (GNU ld rejects duplicate strong symbols that
-          # macOS ld accepts silently) — that's expected and captured with || true.
-          $ELB --elc=$ELC --runtime=$RUNTIME/el_runtime.c || true
-
-          # Restore the repo's self-contained soul.c — elb may have overwritten it
-          # with a partial (non-inlined) version that lacks module-level definitions.
-          cp /tmp/soul.c.prebuilt dist/soul.c
-
-          # Compile the self-contained translation unit.  No --allow-multiple-definition
-          # needed since soul.c inlines all modules.
+          # Compile the self-contained translation unit directly from dist/soul.c.
+          # dist/soul.c is the authoritative combined unit maintained in the repo —
+          # regenerated on macOS by running elb (which succeeds on arm64/macOS ld but
+          # fails on Linux due to duplicate strong symbols). We skip the elb step here
+          # entirely: elb on Linux would OOM the runner (elc uses 24GB+ virtual memory
+          # on a 16GB host) and we always restore from the repo's soul.c anyway.
           mkdir -p dist
           cc -O2 -DHAVE_CURL \
             -I$RUNTIME \
@@ -163,3 +130,220 @@ jobs:
 
           echo "Published neuron-soul@${VERSION}"
           rm -f /tmp/gcp-key.json
+
+  deploy:
+    runs-on: ubuntu-latest
+    needs: build
+    # Only deploy on push to main, not on PRs or manual workflow_dispatch without intent.
+    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+
+    env:
+      USE_GKE_GCLOUD_AUTH_PLUGIN: "True"
+
+    steps:
+      - name: Free disk space
+        run: |
+          df -h /
+          docker system prune -af --volumes 2>/dev/null || true
+          rm -rf /tmp/.act-* /tmp/act-* 2>/dev/null || true
+          df -h /
+
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Install dependencies
+        run: |
+          apt-get update -qq
+          apt-get install -y --no-install-recommends \
+            ca-certificates curl apt-transport-https kubectl
+          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 google-cloud-cli-gke-gcloud-auth-plugin
+
+      - name: Authenticate to GCP
+        env:
+          GCP_SA_KEY: ${{ secrets.GCP_SA_KEY }}
+        run: |
+          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
+          gcloud auth configure-docker us-central1-docker.pkg.dev --quiet
+
+      - name: Get GKE credentials
+        run: |
+          gcloud container clusters get-credentials neuron-platform \
+            --region=us-central1 \
+            --project=neuron-785695
+
+      - name: Determine image tag and slot
+        id: vars
+        run: |
+          # GITEA_SHA is set by the Gitea runner; fall back to GITHUB_SHA for
+          # compatibility with older Forgejo/Gitea versions.
+          RAW_SHA="${GITEA_SHA:-${GITHUB_SHA:-}}"
+          SHA="${RAW_SHA:0:8}"
+          if [ -z "$SHA" ]; then
+            # Last resort: read from git directly
+            SHA=$(git rev-parse --short=8 HEAD 2>/dev/null || echo "unknown")
+          fi
+          IMAGE="us-central1-docker.pkg.dev/neuron-785695/neuron-api/neuron-soul:${SHA}"
+          echo "sha=${SHA}" >> "$GITEA_OUTPUT"
+          echo "image=${IMAGE}" >> "$GITEA_OUTPUT"
+
+          # Determine which slot is currently idle (0 replicas = idle slot)
+          # If both are at 0 (fresh deploy), default to blue
+          BLUE_REPLICAS=$(kubectl get deployment/neuron-mcp-blue \
+            -n neuron-prod \
+            -o jsonpath='{.spec.replicas}' 2>/dev/null || echo "0")
+          GREEN_REPLICAS=$(kubectl get deployment/neuron-mcp-green \
+            -n neuron-prod \
+            -o jsonpath='{.spec.replicas}' 2>/dev/null || echo "0")
+
+          echo "  Blue replicas: ${BLUE_REPLICAS}"
+          echo "  Green replicas: ${GREEN_REPLICAS}"
+
+          if [ "${GREEN_REPLICAS}" -eq 0 ] && [ "${BLUE_REPLICAS}" -gt 0 ]; then
+            SLOT="green"
+          elif [ "${BLUE_REPLICAS}" -eq 0 ] && [ "${GREEN_REPLICAS}" -gt 0 ]; then
+            SLOT="blue"
+          else
+            # Fresh cluster or both idle — deploy to blue first
+            SLOT="blue"
+          fi
+
+          echo "slot=${SLOT}" >> "$GITEA_OUTPUT"
+          echo "  Deploying to slot: ${SLOT}"
+
+      - name: Prepare build artifacts
+        run: |
+          # Pre-download soul binary and El SDK so the Dockerfile can COPY them
+          # from the build context instead of authenticating inside the build.
+          mkdir -p build-artifacts
+
+          # ── soul binary ────────────────────────────────────────────────────────
+          # The build job (same workflow run) just published this version.
+          SOUL_VER=$(gcloud artifacts versions list \
+            --repository=foundation-prod \
+            --location=us-central1 \
+            --project=neuron-785695 \
+            --package=neuron-soul \
+            --sort-by="~createTime" \
+            --limit=1 \
+            --format="value(name)" 2>/dev/null | awk -F/ '{print $NF}')
+          echo "Downloading neuron-soul@${SOUL_VER}"
+          gcloud artifacts generic download \
+            --repository=foundation-prod \
+            --location=us-central1 \
+            --project=neuron-785695 \
+            --package=neuron-soul \
+            --version="${SOUL_VER}" \
+            --destination=build-artifacts/
+          mv build-artifacts/neuron* build-artifacts/neuron 2>/dev/null || true
+          chmod +x build-artifacts/neuron
+
+          # ── El SDK (for engram source compilation inside the Docker build) ────
+          ELC_VER=$(gcloud artifacts versions list \
+            --repository=foundation-prod --location=us-central1 --project=neuron-785695 \
+            --package=el-elc --sort-by="~createTime" --limit=1 \
+            --format="value(name)" 2>/dev/null | awk -F/ '{print $NF}')
+          gcloud artifacts generic download \
+            --repository=foundation-prod --location=us-central1 --project=neuron-785695 \
+            --package=el-elc --version="${ELC_VER}" --destination=build-artifacts/
+          mv build-artifacts/elc* build-artifacts/elc 2>/dev/null || true
+          chmod +x build-artifacts/elc
+
+          RC_VER=$(gcloud artifacts versions list \
+            --repository=foundation-prod --location=us-central1 --project=neuron-785695 \
+            --package=el-runtime-c --sort-by="~createTime" --limit=1 \
+            --format="value(name)" 2>/dev/null | awk -F/ '{print $NF}')
+          gcloud artifacts generic download \
+            --repository=foundation-prod --location=us-central1 --project=neuron-785695 \
+            --package=el-runtime-c --version="${RC_VER}" --destination=build-artifacts/
+          mv build-artifacts/el_runtime.c* build-artifacts/el_runtime.c 2>/dev/null || true
+
+          RH_VER=$(gcloud artifacts versions list \
+            --repository=foundation-prod --location=us-central1 --project=neuron-785695 \
+            --package=el-runtime-h --sort-by="~createTime" --limit=1 \
+            --format="value(name)" 2>/dev/null | awk -F/ '{print $NF}')
+          gcloud artifacts generic download \
+            --repository=foundation-prod --location=us-central1 --project=neuron-785695 \
+            --package=el-runtime-h --version="${RH_VER}" --destination=build-artifacts/
+          mv build-artifacts/el_runtime.h* build-artifacts/el_runtime.h 2>/dev/null || true
+
+          echo "Build artifacts ready:"
+          ls -lh build-artifacts/
+
+      - name: Clone engram source for Docker build context
+        run: |
+          # The Dockerfile builds engram from source (no published AR package).
+          # Clone the engram repo into ./engram/ so it's available in the build context.
+          git clone http://34.31.145.131/neuron-technologies/engram.git \
+            --depth=1 --branch=main \
+            engram
+          echo "Engram source ready at ./engram/src/server.el"
+
+      - name: Build and push Docker image
+        run: |
+          IMAGE="${{ steps.vars.outputs.image }}"
+
+          echo "Building ${IMAGE}..."
+          docker build \
+            --tag "${IMAGE}" \
+            --tag "us-central1-docker.pkg.dev/neuron-785695/neuron-api/neuron-soul:latest" \
+            .
+
+          echo "Pushing ${IMAGE}..."
+          docker push "${IMAGE}"
+          docker push "us-central1-docker.pkg.dev/neuron-785695/neuron-api/neuron-soul:latest"
+
+      - name: Blue-green deploy to GKE
+        run: |
+          chmod +x scripts/blue-green-deploy.sh
+          scripts/blue-green-deploy.sh \
+            --image "${{ steps.vars.outputs.image }}" \
+            --slot "${{ steps.vars.outputs.slot }}"
+
+      - name: Update infrastructure manifests
+        if: success()
+        env:
+          INFRA_GIT_TOKEN: ${{ secrets.INFRA_GIT_TOKEN }}
+        run: |
+          SLOT="${{ steps.vars.outputs.slot }}"
+          if [ "$SLOT" = "blue" ]; then IDLE="green"; else IDLE="blue"; fi
+
+          git clone "http://${INFRA_GIT_TOKEN}@34.31.145.131/neuron-technologies/infrastructure.git" \
+            --depth=1 --branch=main /tmp/infra-update
+
+          cd /tmp/infra-update
+
+          DEPLOY_DIR="platform/k8s/neuron-mcp"
+          sed -i "s/^  replicas: .*/  replicas: 1/" "${DEPLOY_DIR}/deployment-${SLOT}.yaml"
+          sed -i "s/^  replicas: .*/  replicas: 0/" "${DEPLOY_DIR}/deployment-${IDLE}.yaml"
+          echo "  deployment-${SLOT}.yaml: replicas set to 1"
+          echo "  deployment-${IDLE}.yaml: replicas set to 0"
+
+          git config user.email "ci@neurontechnologies.ai"
+          git config user.name "Neuron CI"
+          git add "${DEPLOY_DIR}/deployment-blue.yaml" "${DEPLOY_DIR}/deployment-green.yaml"
+          git diff --staged --quiet && { echo "No manifest changes needed"; exit 0; }
+          git commit -m "ci: neuron-mcp replica sync after blue-green swap to ${SLOT}"
+          git push origin main
+          echo "Infrastructure manifests updated: ${SLOT}=1, ${IDLE}=0"
+
+      - name: Verify deployment
+        run: |
+          SLOT="${{ steps.vars.outputs.slot }}"
+          echo "Verifying neuron-mcp-${SLOT} is healthy..."
+          kubectl rollout status deployment/"neuron-mcp-${SLOT}" \
+            --namespace=neuron-prod \
+            --timeout=8m
+
+          echo "Active service endpoints:"
+          kubectl get endpoints neuron-mcp -n neuron-prod
+
+          echo "Pod status:"
+          kubectl get pods -n neuron-prod -l app=neuron-mcp
+
+      - name: Cleanup
+        if: always()
+        run: rm -f /tmp/gcp-key.json

.gitea/workflows/deploy-gke.yaml

@@ -1,16 +1,13 @@
-name: Deploy Soul to GKE
+name: Deploy Soul to GKE (manual)
 
-# Triggers on push to main — after the soul binary is built and published
-# by ci.yaml, this workflow builds the Docker image and blue-green deploys
-# to the neuron-prod namespace on GKE.
+# MANUAL OVERRIDE ONLY — push-triggered deploys now run as the 'deploy' job
+# in ci.yaml (needs: build), which eliminates the two-workflow concurrency
+# race that was cancelling queued deploy runs.
 #
-# This workflow runs AFTER ci.yaml has published the neuron-soul generic
-# artifact to Artifact Registry. The Docker build downloads that binary.
+# Use this workflow only when you need to deploy a specific slot manually
+# (e.g. rollback, force a slot override) without triggering a full CI build.
 
 on:
-  push:
-    branches:
-      - main
   workflow_dispatch:
     inputs:
       slot:
@@ -18,8 +15,7 @@ on:
         required: false
         default: "green"
 
-# Serialize all builds on this runner — concurrent jobs exhaust the Docker daemon.
-# A queued deploy runs after the in-progress build finishes.
+# Manual deploys still share the runner serialization group.
 concurrency:
   group: neuron-runner
   cancel-in-progress: false

chat.el

@@ -885,7 +885,7 @@ fn handle_chat(body: String) -> String {
 
     // Cross-session affective context: on session start (no history yet), check engram
     // for recent distress signals within 72h and prepend a care directive if found.
-    let affective_prefix: String = {
+    let affective_prefix: String = if true {
         // Runs every turn. Uses correct BellEvent/PositiveEvent tags.
         let aff_now_ts: Int = time_now()
         let aff_cutoff: Int = aff_now_ts - 259200
@@ -940,7 +940,7 @@ fn handle_chat(body: String) -> String {
                 "[RECENT CONTEXT: User recently shared exciting or joyful news. Acknowledge and celebrate with them when relevant.]\n\n"
             } else { "" }
         }
-    }
+    } else { "" }
 
     let ctx: String = engram_compile(activation_seed)
     let system: String = affective_prefix + build_system_prompt(ctx, true)
@@ -2086,6 +2086,18 @@ fn handle_chat_as_soul(body: String) -> String {
 // The soul's engram activates on the transcript content — its own recall,
 // not external injection. The system prompt is just identity.
 //
+// distill_transcript — reduce a full room transcript to the salient tail that
+// should drive engram activation. Minimal implementation: keep the last 4000
+// characters (the recent exchange + trailing question). A full transcript still
+// activates correctly; this just bounds the activation seed for long rooms.
+fn distill_transcript(transcript: String) -> String {
+    let tlen: Int = str_len(transcript)
+    if tlen <= 4000 {
+        return transcript
+    }
+    return str_slice(transcript, tlen - 4000, tlen)
+}
+
 // After responding, the soul records what it said in its own engram.
 // That is how it learns. Not from being told about the room.
 fn handle_dharma_room_turn(body: String) -> String {

memory.el

@@ -109,8 +109,22 @@ fn mem_consolidate() -> String {
 }
 
 fn mem_save(path: String) -> Void {
-    let save_result: String = engram_save(path)
-    if str_eq(save_result, "") {
+    // ENGRAM_STORE on: the durable path is a checkpoint of the resident graph into
+    // the paged store (persists learned hebb + activation-formed edges via the WAL).
+    // The JSON engram_save stays available as an explicit export elsewhere; here the
+    // store is authoritative, so we checkpoint instead of writing the snapshot.
+    let store_flag: String = env("ENGRAM_STORE")
+    if str_eq(store_flag, "1") || str_eq(store_flag, "on") || str_eq(store_flag, "true") {
+        let ck: Int = engram_store_checkpoint()
+        if ck == 0 {
+            println("[memory] mem_save: engram_store_checkpoint returned 0 — checkpoint may have failed")
+        }
+        return
+    }
+    // engram_save returns Int 1/0 (ok/fail), not a String — checking it as a
+    // String (str_eq(save_result, "")) dereferences a tagged int and segfaults.
+    let save_result: Int = engram_save(path)
+    if save_result == 0 {
         println("[memory] mem_save: engram_save failed for " + path + " — snapshot may be incomplete")
     }
 }

safety.el

@@ -244,7 +244,7 @@ fn safety_general_hard_phrases() -> String {
 }
 
 fn safety_soft_phrases() -> String {
-    return "[\"stressed\",\"overwhelmed\",\"can't cope\",\"cannot cope\",\"struggling\",\"anxious\",\"anxiety\",\"depressed\",\"depression\",\"lonely\",\"isolated\",\"hopeless\",\"hopelessness\",\"exhausted\",\"burnt out\",\"burned out\",\"burnout\",\"panic\",\"panicking\",\"falling apart\",\"breaking down\",\"can't handle\",\"cannot handle\",\"losing it\",\"nothing matters\",\"don't care anymore\",\"given up\",\"giving up\",\"helpless\",\"worthless\",\"useless\",\"hate myself\",\"no one cares\",\"nobody cares\",\"no one understands\",\"nobody understands\",\"empty inside\",\"can't stop crying\",\"breaking point\",\"at my limit\",\"having a breakdown\""]"
+    return "[\"stressed\",\"overwhelmed\",\"can't cope\",\"cannot cope\",\"struggling\",\"anxious\",\"anxiety\",\"depressed\",\"depression\",\"lonely\",\"isolated\",\"hopeless\",\"hopelessness\",\"exhausted\",\"burnt out\",\"burned out\",\"burnout\",\"panic\",\"panicking\",\"falling apart\",\"breaking down\",\"can't handle\",\"cannot handle\",\"losing it\",\"nothing matters\",\"don't care anymore\",\"given up\",\"giving up\",\"helpless\",\"worthless\",\"useless\",\"hate myself\",\"no one cares\",\"nobody cares\",\"no one understands\",\"nobody understands\",\"empty inside\",\"can't stop crying\",\"breaking point\",\"at my limit\",\"having a breakdown\"]"
 }
 
 // ISSUE 5 TODO: phrase lists are rebuilt from JSON literals on every call.

sessions.el

@@ -503,10 +503,10 @@ fn session_hist_save(session_id: String, hist: String) -> Void {
         let last_role: String = json_get(last_entry, "role")
         let last_content: String = json_get(last_entry, "content")
         let topic_snip: String = if str_len(last_content) > 200 { str_slice(last_content, 0, 200) } else { last_content }
-        let safe_topic: String = str_replace(topic_snip, """, "'")
+        let safe_topic: String = str_replace(topic_snip, "\"", "'")
         let ts_now: String = int_to_str(time_now())
         let topic_content: String = "last-session-topic | ts:" + ts_now + " | session:" + session_id + " | topic:" + safe_topic
-        let topic_tags: String = "["last-session-topic","conv:history","Conversation","session:topic"]"
+        let topic_tags: String = "[\"last-session-topic\",\"conv:history\",\"Conversation\",\"session:topic\"]"
         let topic_label: String = "last-session-topic:" + session_id
         // Delete old last-session-topic node for this session before writing fresh
         let old_topic: String = engram_search_json("last-session-topic:" + session_id, 2)

soul.el

@@ -500,11 +500,28 @@ println("[soul] boot - cgi=" + soul_cgi_id + " port=" + int_to_str(port))
 
 let using_http_engram: Bool = !str_eq(engram_url_raw, "")
 
+// ENGRAM_STORE (tiered paged store): when the flag is on, the durable neuron.egm
+// store — not the JSON snapshot — is the source of truth. engram_store_boot does
+// import-once + WAL-replay + resident load; every structural mutation is mirrored
+// into the store's WAL, and mem_save() checkpoints the resident graph (incl.
+// learned hebb) so associations survive a restart. Flag OFF is unchanged.
+let engram_store_flag: String = env("ENGRAM_STORE")
+let engram_store_on: Bool = str_eq(engram_store_flag, "1") || str_eq(engram_store_flag, "on") || str_eq(engram_store_flag, "true")
+let engram_data_dir_raw: String = env("ENGRAM_DATA_DIR")
+let engram_data_dir: String = if str_eq(engram_data_dir_raw, "") { env("HOME") + "/.neuron/engram" } else { engram_data_dir_raw }
+
 // Always try local snapshot first. If it has content (>50 nodes) it was
 // previously seeded from HTTP Engram and is kept up-to-date by the awareness
 // loop — use it. This preserves sessions and memories across restarts.
 // HTTP Engram is only used for the very first boot (empty/absent snapshot).
-engram_load(snapshot)
+if engram_store_on {
+    let booted: Int = engram_store_boot(engram_data_dir)
+    println("[soul] ENGRAM_STORE on — booted paged store from " + engram_data_dir
+        + " (rc=" + int_to_str(booted) + ") nodes=" + int_to_str(engram_node_count())
+        + " edges=" + int_to_str(engram_edge_count()))
+} else {
+    engram_load(snapshot)
+}
 let local_node_count: Int = engram_node_count()
 let snapshot_usable: Bool = local_node_count > 50