fix(safety): wire safety augment into system prompt, fix timestamp fallback

- Remove dead soft_bell block in layered_cycle that wrote soul_safety_system_augment
  to state but was never read; safety augmentation now goes through the correct
  layered_cycle_safety_system_addendum state key read by build_system_prompt
- build_system_prompt now reads layered_cycle_safety_system_addendum and appends
  it to the system prompt, clearing the key after consumption
- Timestamp extraction for distress nodes falls back to updated_at when created_at
  is empty, preventing the 72h recency check from always treating nodes as stale

.gitea/workflows/ci.yaml

@@ -9,11 +9,23 @@ 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.
+concurrency:
+  group: neuron-runner
+  cancel-in-progress: false
+
 jobs:
   build:
     runs-on: ubuntu-latest
 
     steps:
+      - name: Free disk space
+        run: |
+          df -h /
+          docker system prune -af --volumes 2>/dev/null || true
+          df -h /
+
       - name: Checkout
         uses: actions/checkout@v4
 
@@ -91,44 +103,35 @@ jobs:
           echo "El SDK ready"
           /opt/el/dist/platform/elc --version || true
 
-      - name: Generate ELP master declarations header
-        run: |
-          {
-            printf '/* Auto-generated C forward declarations for ELP cross-module calls */\n'
-            printf '#pragma once\n'
-            printf '#include "el_runtime.h"\n'
-            printf '\n'
-            grep -h -E '^(el_val_t|void|int|char\*|const char\*)[[:space:]]+[a-zA-Z_][a-zA-Z0-9_]*[[:space:]]*\(' dist/*.c 2>/dev/null \
-              | grep ';$' | sort -u
-          } > dist/elp-c-decls.h
-          echo "Generated elp-c-decls.h with $(grep -c ';' dist/elp-c-decls.h 2>/dev/null || echo 0) declarations"
-
       - name: Build neuron soul binary
         run: |
           ELB=/opt/el/dist/bin/elb
           ELC=/opt/el/dist/platform/elc
           RUNTIME=/opt/el/runtime
 
-          # Compile all El modules to C.
-          # This step will fail at link on Linux: the El compiler inlines imported
-          # modules into each module's .c file, producing duplicate strong symbol
-          # definitions. GNU ld rejects these; macOS ld accepts them silently.
-          # We capture the link failure and re-link manually below.
+          # 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
 
-          # Re-link with soul.c listed first so its real main() (from the cgi block)
-          # wins over the stub main()s generated in every other module.
-          # --allow-multiple-definition tells GNU ld to pick the first definition
-          # for each duplicate symbol — safe here because all duplicates are identical
-          # (same El source compiled independently into multiple .c files).
+          # 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.
           mkdir -p dist
-          OTHER_C=$(ls dist/*.c | grep -v '/soul\.c$' | sort | tr '\n' ' ')
           cc -O2 -DHAVE_CURL \
             -I$RUNTIME \
-            dist/soul.c $OTHER_C \
+            dist/soul.c \
             $RUNTIME/el_runtime.c \
             -lssl -lcrypto -lcurl -lpthread -lm \
-            -Wl,--allow-multiple-definition \
             -o dist/neuron
 
           ls -lh dist/neuron

.gitea/workflows/deploy-gke.yaml

@@ -18,11 +18,27 @@ 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.
+concurrency:
+  group: neuron-runner
+  cancel-in-progress: false
+
 jobs:
   deploy:
     runs-on: ubuntu-latest
 
+    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
 
@@ -53,7 +69,14 @@ jobs:
       - name: Determine image tag and slot
         id: vars
         run: |
-          SHA="${GITEA_SHA:0:8}"
+          # 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"
@@ -85,6 +108,66 @@ jobs:
           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 ────────────────────────────────────────────────────────
+          # ci.yaml publishes the soul binary to foundation-prod on every push.
+          # Download the latest version (the one just built by ci.yaml).
+          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 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).
@@ -95,16 +178,13 @@ jobs:
           echo "Engram source ready at ./engram/src/server.el"
 
       - name: Build and push Docker image
-        env:
-          GCP_SA_KEY: ${{ secrets.GCP_SA_KEY }}
         run: |
           IMAGE="${{ steps.vars.outputs.image }}"
-          SHA="${{ steps.vars.outputs.sha }}"
 
           echo "Building ${IMAGE}..."
+          # No --secret needed: artifacts are pre-downloaded into build-artifacts/
+          # and the Dockerfile uses COPY to include them.
           docker build \
-            --build-arg SOUL_VERSION="${SHA}" \
-            --secret id=gcp_sa_key,env=GCP_SA_KEY \
             --tag "${IMAGE}" \
             --tag "us-central1-docker.pkg.dev/neuron-785695/neuron-api/neuron-soul:latest" \
             .
@@ -120,13 +200,40 @@ jobs:
             --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=3m
+            --timeout=8m
 
           echo "Active service endpoints:"
           kubectl get endpoints neuron-mcp -n neuron-prod

Dockerfile

@@ -1,108 +1,28 @@
 # Neuron Soul — GKE container image
 #
 # Build strategy:
-#   1. Download the pre-built linux/amd64 soul binary (package: neuron-soul)
-#      from Artifact Registry (foundation-dev).
-#   2. Download the El SDK from Artifact Registry and build engram from source
-#      (the neuron-technologies/engram repo is a git submodule). Engram has
-#      never been published as a standalone Artifact Registry package.
-#   3. Package both in an Ubuntu 24.04 runtime image (GLIBC 2.39 required by
-#      binaries compiled on Ubuntu 24.04 CI runners).
+#   1. CI pre-downloads all artifacts from Artifact Registry into build-artifacts/
+#      (neuron soul binary, El compiler, El runtime). No GCP credentials are needed
+#      inside the build — all AR access happens in the CI workflow before docker build.
+#   2. Build engram from source (neuron-technologies/engram, cloned by CI into ./engram/).
+#   3. Package soul + engram in an Ubuntu 24.04 runtime image (GLIBC 2.39).
 #   4. entrypoint.sh starts engram on :8742, waits for it to be healthy,
 #      then starts the soul with ENGRAM_URL pointing at it (HTTP mode).
 #
+# Expected build context layout (prepared by deploy-gke.yaml before docker build):
+#   build-artifacts/neuron         — pre-built linux/amd64 soul binary
+#   build-artifacts/elc            — El compiler (for engram source compilation)
+#   build-artifacts/el_runtime.c   — El C runtime
+#   build-artifacts/el_runtime.h   — El C runtime header
+#   engram/src/server.el           — engram source (cloned by CI)
+#   entrypoint.sh                  — container entrypoint
+#
 # Required env vars (injected via ExternalSecret at runtime):
 #   NEURON_PORT, NEURON_LLM_0_URL, NEURON_LLM_0_KEY, NEURON_LLM_0_FORMAT,
 #   SOUL_CGI_ID, SOUL_IDENTITY, NEURON_TOKEN, NEURON_API_URL, ENGRAM_URL,
 #   ENGRAM_DATA_DIR
 
-ARG SOUL_VERSION=latest
-
-# ── Stage 1: Download neuron-soul + El SDK from Artifact Registry ─────────────
-FROM ubuntu:24.04 AS downloader
-
-ARG SOUL_VERSION
-
-RUN apt-get update -qq && \
-    apt-get install -y --no-install-recommends \
-      ca-certificates \
-      curl \
-      gnupg \
-      apt-transport-https && \
-    echo "deb [signed-by=/usr/share/keyrings/cloud.google.gpg] https://packages.cloud.google.com/apt cloud-sdk main" \
-      > /etc/apt/sources.list.d/google-cloud-sdk.list && \
-    curl -fsSL https://packages.cloud.google.com/apt/doc/apt-key.gpg \
-      | gpg --dearmor -o /usr/share/keyrings/cloud.google.gpg && \
-    apt-get update -qq && \
-    apt-get install -y --no-install-recommends google-cloud-cli && \
-    rm -rf /var/lib/apt/lists/*
-
-RUN --mount=type=secret,id=gcp_sa_key \
-    GCP_SA_KEY=$(cat /run/secrets/gcp_sa_key 2>/dev/null || echo "") && \
-    if [ -n "$GCP_SA_KEY" ]; then \
-      echo "$GCP_SA_KEY" > /tmp/gcp-key.json && \
-      gcloud auth activate-service-account --key-file=/tmp/gcp-key.json; \
-    fi && \
-    gcloud config set project neuron-785695 && \
-    mkdir -p /tmp/soul /tmp/el-sdk && \
-    \
-    # ── soul ──────────────────────────────────────────────────────────────── \
-    if [ "${SOUL_VERSION}" = "latest" ]; then \
-      SOUL_VER=$(gcloud artifacts versions list \
-        --repository=foundation-dev \
-        --location=us-central1 \
-        --project=neuron-785695 \
-        --package=neuron-soul \
-        --sort-by="~createTime" \
-        --limit=1 \
-        --format="value(name)" 2>/dev/null | awk -F/ '{print $NF}'); \
-    else \
-      SOUL_VER="${SOUL_VERSION}"; \
-    fi && \
-    echo "Downloading neuron-soul@${SOUL_VER}" && \
-    gcloud artifacts generic download \
-      --repository=foundation-dev \
-      --location=us-central1 \
-      --project=neuron-785695 \
-      --package=neuron-soul \
-      --version="${SOUL_VER}" \
-      --destination=/tmp/soul/ && \
-    mv /tmp/soul/neuron* /tmp/soul/neuron 2>/dev/null || true && \
-    chmod +x /tmp/soul/neuron && \
-    \
-    # ── El SDK (needed to build engram from source) ────────────────────────── \
-    ELC_VER=$(gcloud artifacts versions list \
-      --repository=foundation-dev --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-dev --location=us-central1 --project=neuron-785695 \
-      --package=el-elc --version="${ELC_VER}" --destination=/tmp/el-sdk/ && \
-    mv /tmp/el-sdk/elc* /tmp/el-sdk/elc 2>/dev/null || true && \
-    chmod +x /tmp/el-sdk/elc && \
-    \
-    RC_VER=$(gcloud artifacts versions list \
-      --repository=foundation-dev --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-dev --location=us-central1 --project=neuron-785695 \
-      --package=el-runtime-c --version="${RC_VER}" --destination=/tmp/el-sdk/ && \
-    mv /tmp/el-sdk/el_runtime.c* /tmp/el-sdk/el_runtime.c 2>/dev/null || true && \
-    \
-    RH_VER=$(gcloud artifacts versions list \
-      --repository=foundation-dev --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-dev --location=us-central1 --project=neuron-785695 \
-      --package=el-runtime-h --version="${RH_VER}" --destination=/tmp/el-sdk/ && \
-    mv /tmp/el-sdk/el_runtime.h* /tmp/el-sdk/el_runtime.h 2>/dev/null || true && \
-    \
-    rm -f /tmp/gcp-key.json && \
-    echo "Downloads complete:" && ls -lh /tmp/soul/ /tmp/el-sdk/
-
-# ── Stage 2: Build engram from source ────────────────────────────────────────
+# ── Stage 1: Build engram from source ────────────────────────────────────────
 FROM ubuntu:24.04 AS engram-builder
 
 RUN apt-get update -qq && \
@@ -113,12 +33,13 @@ RUN apt-get update -qq && \
       libcurl4-openssl-dev && \
     rm -rf /var/lib/apt/lists/*
 
-COPY --from=downloader /tmp/el-sdk/elc           /usr/local/bin/elc
-COPY --from=downloader /tmp/el-sdk/el_runtime.c  /usr/local/lib/el/el_runtime.c
-COPY --from=downloader /tmp/el-sdk/el_runtime.h  /usr/local/lib/el/el_runtime.h
+# El SDK pre-downloaded by CI into build-artifacts/
+COPY build-artifacts/elc           /usr/local/bin/elc
+COPY build-artifacts/el_runtime.c  /usr/local/lib/el/el_runtime.c
+COPY build-artifacts/el_runtime.h  /usr/local/lib/el/el_runtime.h
+RUN chmod +x /usr/local/bin/elc
 
-# engram source is expected at ./engram/src/server.el in the build context.
-# The deploy-gke.yaml CI must clone neuron-technologies/engram alongside this repo.
+# engram source cloned by CI into ./engram/
 COPY engram/src/server.el /build/src/server.el
 
 RUN mkdir -p /build/dist && \
@@ -133,7 +54,7 @@ RUN mkdir -p /build/dist && \
     echo "Built engram:" && ls -lh /build/dist/engram && \
     chmod +x /build/dist/engram
 
-# ── Stage 3: Runtime image ───────────────────────────────────────────────────
+# ── Stage 2: Runtime image ───────────────────────────────────────────────────
 # Ubuntu 24.04: GLIBC 2.39 satisfies both neuron-soul and engram binary deps.
 FROM ubuntu:24.04
 
@@ -145,9 +66,10 @@ RUN apt-get update -qq && \
     rm -rf /var/lib/apt/lists/* && \
     useradd -r -u 10000 -m -s /bin/bash soul
 
-COPY --from=downloader    /tmp/soul/neuron        /usr/local/bin/neuron
-COPY --from=engram-builder /build/dist/engram     /usr/local/bin/engram
-COPY entrypoint.sh                                /usr/local/bin/entrypoint.sh
+# soul binary pre-downloaded by CI into build-artifacts/
+COPY build-artifacts/neuron        /usr/local/bin/neuron
+COPY --from=engram-builder /build/dist/engram /usr/local/bin/engram
+COPY entrypoint.sh                 /usr/local/bin/entrypoint.sh
 
 RUN chmod +x /usr/local/bin/neuron /usr/local/bin/engram /usr/local/bin/entrypoint.sh
 

awareness.el

@@ -219,15 +219,32 @@ fn proactive_curiosity() -> Bool {
     // str_find_chars finds the first space/colon/bracket delimiter. sp > 3 guards against
     // very short or bracket-prefixed labels like "[BacklogItem]" (sp=0, not > 3 → skipped).
     // EL scoping: state_set/state_get pattern used because let inside if creates inner scope.
-    // (2026-06-11 self-review)
+    //
+    // NODE TYPE FILTER (2026-06-19 self-review): only derive auto_term from Memory,
+    // BacklogItem, or Entity nodes. Knowledge nodes are stable reference material —
+    // using their first word as a curiosity seed creates a self-reinforcing loop: e.g.
+    // "Numeric tier strings in Engram..." (a Knowledge node) -> auto_term="Numeric" ->
+    // activates all "Numeric" nodes -> keeps that Knowledge node dominant in WM forever.
+    // Knowledge nodes should be REACHED by curiosity seeds, not drive them. Only dynamic
+    // personal/work nodes (Memory, BacklogItem, Entity) carry live contextual salience
+    // worth radiating from. (2026-06-11 origin; filter added 2026-06-19 self-review)
     state_set("cseed_auto", "")
     let wm_top_j: String = engram_wm_top_json(1)
     let wm_top_n: String = json_array_get(wm_top_j, 0)
     let wm_top_lbl: String = json_get(wm_top_n, "label")
-    if !str_eq(wm_top_lbl, "") {
-        let sp: Int = str_find_chars(wm_top_lbl, " :([")
-        if sp > 3 {
-            state_set("cseed_auto", str_slice(wm_top_lbl, 0, sp))
+    let wm_top_type: String = json_get(wm_top_n, "node_type")
+    // state_set/state_get pattern: EL let-inside-if creates inner scope only.
+    state_set("allow_auto", "0")
+    if str_eq(wm_top_type, "Memory") { state_set("allow_auto", "1") }
+    if str_eq(wm_top_type, "BacklogItem") { state_set("allow_auto", "1") }
+    if str_eq(wm_top_type, "Entity") { state_set("allow_auto", "1") }
+    let allow_auto: String = state_get("allow_auto")
+    if str_eq(allow_auto, "1") {
+        if !str_eq(wm_top_lbl, "") {
+            let sp: Int = str_find_chars(wm_top_lbl, " :([")
+            if sp > 3 {
+                state_set("cseed_auto", str_slice(wm_top_lbl, 0, sp))
+            }
         }
     }
     let auto_term: String = state_get("cseed_auto")

chat.el

@@ -81,7 +81,15 @@ fn build_system_prompt(ctx: String) -> String {
         "\n\n[ENGRAM CONTEXT — compiled from your graph]\n" + ctx
     }
 
-    return identity + date_line + voice_rules + security_rules + identity_block + engram_block
+    let safety_addendum: String = state_get("layered_cycle_safety_system_addendum")
+    let safety_block: String = if str_eq(safety_addendum, "") {
+        ""
+    } else {
+        state_set("layered_cycle_safety_system_addendum", "")
+        safety_addendum
+    }
+
+    return identity + date_line + voice_rules + security_rules + identity_block + engram_block + safety_block
 }
 
 fn hist_append(hist: String, role: String, content: String) -> String {
@@ -175,8 +183,27 @@ fn handle_chat(body: String) -> String {
         message
     }
 
+    // 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 = if hist_len == 0 {
+        let distress_nodes: String = engram_search_json("bell distress crisis loss grief despair", 3)
+        let has_nodes: Bool = !str_eq(distress_nodes, "") && !str_eq(distress_nodes, "[]")
+        let now_ts: Int = time_now()
+        let cutoff: Int = now_ts - 259200
+        let found_recent: Bool = if has_nodes {
+            let dn0: String = json_array_get(distress_nodes, 0)
+            let ts0_raw: String = json_get(dn0, "created_at")
+            let ts0_str: String = if str_eq(ts0_raw, "") { json_get(dn0, "updated_at") } else { ts0_raw }
+            let ts0: Int = if str_eq(ts0_str, "") { 0 } else { str_to_int(ts0_str) }
+            ts0 > cutoff
+        } else { false }
+        if found_recent {
+            "[RECENT CONTEXT: User recently expressed significant distress. Monitor for indirect crisis signals and respond with care.]\n\n"
+        } else { "" }
+    } else { "" }
+
     let ctx: String = engram_compile(activation_seed)
-    let system: String = build_system_prompt(ctx)
+    let system: String = affective_prefix + build_system_prompt(ctx)
     let full_system: String = if hist_len > 0 {
         system + "\n\n[RECENT CONVERSATION — last " + int_to_str(hist_len) + " turns]\n" + stored_hist
     } else {
@@ -317,10 +344,13 @@ fn connector_tools_json() -> String {
     return arr
 }
 
-// Built-in tools + native web_search + every connector tool, as one tools array.
-// Splices connector tools in before the closing bracket of the base array.
+// Built-in tools + every connector tool, as one tools array.
+// Uses agentic_tools_literal (not agentic_tools_with_web) to avoid a duplicate
+// "web_search" name — the literal already includes a custom web_search handler,
+// and adding the Anthropic server-side web_search_20250305 (same name) causes
+// Anthropic to reject with "Tool names must be unique."
 fn agentic_tools_all() -> String {
-    let base: String = agentic_tools_with_web()
+    let base: String = agentic_tools_literal()
     let conn: String = connector_tools_json()
     let conn_inner: String = str_slice(conn, 1, str_len(conn) - 1)
     if str_eq(conn_inner, "") {
@@ -377,16 +407,78 @@ fn call_neuron_mcp(tool_name: String, args: String) -> String {
     return json_safe(result)
 }
 
+// ---------------------------------------------------------------------------
+// Agent workspace scope (defense-in-depth, NOT a hard security boundary).
+//
+// When a workspace root is configured (state key "agent_workspace_root", else
+// env NEURON_AGENT_ROOT), the path-based tools (read_file, write_file,
+// list_files, grep) are confined to that subtree by a lexical check, and
+// run_command runs with its cwd set to the root. With no root set, behavior is
+// unchanged (unscoped) for backward compatibility.
+//
+// LIMITATION — FLAGGED FOR WILL'S REVIEW: this is a lexical guard. It does not
+// resolve symlinks and cannot stop an arbitrary shell command from cd-ing out
+// of the root. Real confinement needs runtime support (cwd-locked exec /
+// sandbox-exec / chroot) in el_runtime.c. This raises the floor; it is not a
+// boundary. The default-allow-when-unset policy and the "cd <root> && (...)"
+// wrapping are deliberate choices to confirm against the intended design.
+// ---------------------------------------------------------------------------
+
+fn agent_workspace_root() -> String {
+    let s: String = state_get("agent_workspace_root")
+    if !str_eq(s, "") {
+        return s
+    }
+    return env("NEURON_AGENT_ROOT")
+}
+
+// Allow if path stays under root. Empty root = no sandbox = allow. Rejects
+// parent traversal and ~ expansion; absolute paths must live under root.
+fn path_within_root(path: String, root: String) -> Bool {
+    if str_eq(root, "") {
+        return true
+    }
+    if str_contains(path, "..") {
+        return false
+    }
+    if str_starts_with(path, "~") {
+        return false
+    }
+    if str_starts_with(path, "/") {
+        return str_starts_with(path, root)
+    }
+    return true
+}
+
+// Resolve a relative tool path against the root so it lands inside the subtree.
+fn resolve_in_root(path: String, root: String) -> String {
+    if str_eq(root, "") {
+        return path
+    }
+    if str_starts_with(path, "/") {
+        return path
+    }
+    return root + "/" + path
+}
+
 fn dispatch_tool(tool_name: String, tool_input: String) -> String {
     if str_eq(tool_name, "read_file") {
         let path: String = json_get(tool_input, "path")
-        let content: String = fs_read(path)
+        let root: String = agent_workspace_root()
+        if !path_within_root(path, root) {
+            return json_safe("denied: path is outside the agent workspace root")
+        }
+        let content: String = fs_read(resolve_in_root(path, root))
         return json_safe(content)
     }
     if str_eq(tool_name, "write_file") {
         let path: String = json_get(tool_input, "path")
         let content: String = json_get(tool_input, "content")
-        fs_write(path, content)
+        let root: String = agent_workspace_root()
+        if !path_within_root(path, root) {
+            return json_safe("denied: path is outside the agent workspace root")
+        }
+        fs_write(resolve_in_root(path, root), content)
         return json_safe("{\"ok\":true}")
     }
     if str_eq(tool_name, "web_get") {
@@ -401,7 +493,9 @@ fn dispatch_tool(tool_name: String, tool_input: String) -> String {
     }
     if str_eq(tool_name, "run_command") {
         let cmd: String = json_get(tool_input, "command")
-        let result: String = exec_capture(cmd)
+        let root: String = agent_workspace_root()
+        let scoped: String = if str_eq(root, "") { cmd } else { "cd " + root + " && ( " + cmd + " )" }
+        let result: String = exec_capture(scoped)
         return json_safe(result)
     }
     // MCP connector tools (namespaced mcp__<server>__<tool>) are routed through
@@ -421,13 +515,21 @@ fn dispatch_tool(tool_name: String, tool_input: String) -> String {
     }
     if str_eq(tool_name, "list_files") {
         let path: String = json_get(tool_input, "path")
-        let result: String = exec_capture("ls -la " + path + " 2>&1")
+        let root: String = agent_workspace_root()
+        if !path_within_root(path, root) {
+            return json_safe("denied: path is outside the agent workspace root")
+        }
+        let result: String = exec_capture("ls -la " + resolve_in_root(path, root) + " 2>&1")
         return json_safe(result)
     }
     if str_eq(tool_name, "grep") {
         let pattern: String = json_get(tool_input, "pattern")
         let path: String = json_get(tool_input, "path")
-        let result: String = exec_capture("grep -rn \"" + pattern + "\" " + path + " 2>&1 | head -50")
+        let root: String = agent_workspace_root()
+        if !path_within_root(path, root) {
+            return json_safe("denied: path is outside the agent workspace root")
+        }
+        let result: String = exec_capture("grep -rn \"" + pattern + "\" " + resolve_in_root(path, root) + " 2>&1 | head -50")
         return json_safe(result)
     }
     if str_eq(tool_name, "edit_file") {
@@ -909,6 +1011,9 @@ fn handle_chat_as_soul(body: String) -> String {
     let req_model: String = json_get(body, "model")
     let model: String = if str_eq(req_model, "") { chat_default_model() } else { req_model }
 
+    // Hard Bell: pre-LLM safety evaluation — multi-soul room conversations are real interactions.
+    let system_prompt = safety_augment_system(system_prompt, eff_message)
+
     let raw_response: String = llm_call_system(model, system_prompt, eff_message)
 
     let is_error: Bool = str_starts_with(raw_response, "{\"error\"")
@@ -955,6 +1060,9 @@ fn handle_dharma_room_turn(body: String) -> String {
         identity + "\n\n" + engram_ctx
     }
 
+    // Hard Bell: pre-LLM safety evaluation — dharma room turns are real conversations.
+    let system_prompt = safety_augment_system(system_prompt, transcript)
+
     let raw_response: String = llm_call_system(model, system_prompt, transcript)
 
     let is_error: Bool = str_starts_with(raw_response, "{\"error\"")
@@ -1001,6 +1109,9 @@ fn handle_dharma_room_turn_agentic(body: String) -> String {
     let system: String = identity + " You have access to tools: read files, write files, browse the web, search your memory, run commands. Use them when they add genuine value. Be direct and stay in character.\n\n" + ctx
 
     let api_key: String = agentic_api_key()
+    // Hard Bell: pre-LLM safety evaluation on agentic dharma room turns.
+    let system = safety_augment_system(system, transcript)
+
     let tools_json: String = agentic_tools_all()
     let safe_transcript: String = json_safe(transcript)
     let safe_sys: String = json_safe(system)

chat.elh

@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// auto-generated by elc --emit-header - do not edit
 extern fn chat_default_model() -> String
 extern fn gemini_api_key() -> String
 extern fn xai_api_key() -> String
@@ -19,8 +19,18 @@ extern fn studio_tools_json() -> String
 extern fn agentic_api_key() -> String
 extern fn call_neuron_mcp(tool_name: String, args_json: String) -> String
 extern fn agentic_tools_literal() -> String
+extern fn agentic_tools_with_web() -> String
 extern fn dispatch_tool(tool_name: String, tool_input: String) -> String
+extern fn json_array_append(arr: String, item: String) -> String
+extern fn append_tool_log(log: String, name: String) -> String
+extern fn exec_tool_block(block: String) -> String
+extern fn agentic_blob(model: String, system: String, tools_json: String, messages: String, origin: String, approval: Bool, iteration: Int, tools_log: String, content: String, queue: String, results: String, next: Int) -> String
+extern fn extract_all_text(s: String) -> String
+extern fn strip_citations(s: String) -> String
+extern fn agentic_api_turn(model: String, safe_sys: String, tools_json: String, messages: String) -> String
+extern fn agentic_engine(session_id: String, blob: String) -> String
 extern fn handle_chat_agentic(body: String) -> String
+extern fn handle_session_approve(session_id: String, body: String) -> String
 extern fn handle_chat_as_soul(body: String) -> String
 extern fn handle_dharma_room_turn(body: String) -> String
 extern fn handle_dharma_room_turn_agentic(body: String) -> String

dist/awareness.c

@@ -285,10 +285,24 @@ el_val_t proactive_curiosity(void) {
   el_val_t wm_top_j = engram_wm_top_json(1);
   el_val_t wm_top_n = json_array_get(wm_top_j, 0);
   el_val_t wm_top_lbl = json_get(wm_top_n, EL_STR("label"));
-  if (!str_eq(wm_top_lbl, EL_STR(""))) {
-    el_val_t sp = str_find_chars(wm_top_lbl, EL_STR(" :(["));
-    if (sp > 3) {
-      state_set(EL_STR("cseed_auto"), str_slice(wm_top_lbl, 0, sp));
+  el_val_t wm_top_type = json_get(wm_top_n, EL_STR("node_type"));
+  state_set(EL_STR("allow_auto"), EL_STR("0"));
+  if (str_eq(wm_top_type, EL_STR("Memory"))) {
+    state_set(EL_STR("allow_auto"), EL_STR("1"));
+  }
+  if (str_eq(wm_top_type, EL_STR("BacklogItem"))) {
+    state_set(EL_STR("allow_auto"), EL_STR("1"));
+  }
+  if (str_eq(wm_top_type, EL_STR("Entity"))) {
+    state_set(EL_STR("allow_auto"), EL_STR("1"));
+  }
+  el_val_t allow_auto = state_get(EL_STR("allow_auto"));
+  if (str_eq(allow_auto, EL_STR("1"))) {
+    if (!str_eq(wm_top_lbl, EL_STR(""))) {
+      el_val_t sp = str_find_chars(wm_top_lbl, EL_STR(" :(["));
+      if (sp > 3) {
+        state_set(EL_STR("cseed_auto"), str_slice(wm_top_lbl, 0, sp));
+      }
     }
   }
   el_val_t auto_term = state_get(EL_STR("cseed_auto"));

dist/chat.elh

@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// auto-generated by elc --emit-header - do not edit
 extern fn chat_default_model() -> String
 extern fn gemini_api_key() -> String
 extern fn xai_api_key() -> String
@@ -19,6 +19,7 @@ extern fn studio_tools_json() -> String
 extern fn agentic_api_key() -> String
 extern fn call_neuron_mcp(tool_name: String, args_json: String) -> String
 extern fn agentic_tools_literal() -> String
+extern fn agentic_tools_with_web() -> String
 extern fn dispatch_tool(tool_name: String, tool_input: String) -> String
 extern fn handle_chat_agentic(body: String) -> String
 extern fn handle_chat_as_soul(body: String) -> String

dist/neuron.c

@@ -1042,12 +1042,36 @@ el_val_t call_neuron_mcp(el_val_t tool_name, el_val_t args_json);
 el_val_t agentic_tools_literal(void);
 el_val_t agentic_tools_with_web(void);
 el_val_t dispatch_tool(el_val_t tool_name, el_val_t tool_input);
+el_val_t json_array_append(el_val_t arr, el_val_t item);
+el_val_t append_tool_log(el_val_t log, el_val_t name);
+el_val_t exec_tool_block(el_val_t block);
+el_val_t agentic_blob(el_val_t model, el_val_t system, el_val_t tools_json, el_val_t messages, el_val_t origin, el_val_t approval, el_val_t iteration, el_val_t tools_log, el_val_t content, el_val_t queue, el_val_t results, el_val_t next);
+el_val_t extract_all_text(el_val_t s);
+el_val_t strip_citations(el_val_t s);
+el_val_t agentic_api_turn(el_val_t model, el_val_t safe_sys, el_val_t tools_json, el_val_t messages);
+el_val_t agentic_engine(el_val_t session_id, el_val_t blob);
 el_val_t handle_chat_agentic(el_val_t body);
+el_val_t handle_session_approve(el_val_t session_id, el_val_t body);
 el_val_t handle_chat_as_soul(el_val_t body);
 el_val_t handle_dharma_room_turn(el_val_t body);
 el_val_t handle_dharma_room_turn_agentic(el_val_t body);
 el_val_t auto_persist(el_val_t req, el_val_t resp);
 el_val_t strengthen_chat_nodes(el_val_t activation_nodes);
+el_val_t safety_self_harm_phrases(void);
+el_val_t safety_abuse_phrases(void);
+el_val_t safety_general_hard_phrases(void);
+el_val_t safety_soft_phrases(void);
+el_val_t safety_normalize(el_val_t message);
+el_val_t safety_any_match(el_val_t text, el_val_t phrases_json);
+el_val_t safety_count_match(el_val_t text, el_val_t phrases_json);
+el_val_t safety_detect_bell_level(el_val_t message);
+el_val_t safety_classify_hard_bell(el_val_t message);
+el_val_t safety_soft_directive(void);
+el_val_t safety_hard_directive(el_val_t hard_type);
+el_val_t safety_augment_system(el_val_t system, el_val_t user_msg);
+el_val_t safety_contact_path(void);
+el_val_t handle_safety_contact_get(void);
+el_val_t handle_safety_contact_post(el_val_t body);
 el_val_t auth_headers(el_val_t tok);
 el_val_t axon_get(el_val_t path);
 el_val_t axon_post(el_val_t path, el_val_t body);
@@ -1110,6 +1134,7 @@ el_val_t session_update_meta_timestamp(el_val_t session_id);
 el_val_t session_auto_title(el_val_t session_id, el_val_t first_message);
 el_val_t handle_session_approve(el_val_t session_id, el_val_t body);
 el_val_t strip_query(el_val_t path);
+el_val_t flag_true(el_val_t body, el_val_t key);
 el_val_t err_404(el_val_t path);
 el_val_t err_405(el_val_t method, el_val_t path);
 el_val_t route_health(void);
@@ -1144,6 +1169,9 @@ el_val_t local_node_count;
 el_val_t snapshot_usable;
 el_val_t boot_num;
 el_val_t is_genesis;
+el_val_t guard_disk;
+el_val_t guard_disk_len;
+el_val_t safe_to_seed;
 
 el_val_t lang_profile(el_val_t code, el_val_t word_order, el_val_t morph_type, el_val_t has_case, el_val_t has_gender, el_val_t script_dir, el_val_t agreement, el_val_t null_subject) {
   el_val_t r = native_list_empty();
@@ -25890,14 +25918,28 @@ el_val_t proactive_curiosity(void) {
   el_val_t wm_top_j = engram_wm_top_json(1);
   el_val_t wm_top_n = json_array_get(wm_top_j, 0);
   el_val_t wm_top_lbl = json_get(wm_top_n, EL_STR("label"));
-  if (!str_eq(wm_top_lbl, EL_STR(""))) {
-    el_val_t sp = str_find_chars(wm_top_lbl, EL_STR(" :(["));
-    if (sp > 3) {
-      state_set(EL_STR("cseed_auto"), str_slice(wm_top_lbl, 0, sp));
+  el_val_t wm_top_type = json_get(wm_top_n, EL_STR("node_type"));
+  state_set(EL_STR("allow_auto"), EL_STR("0"));
+  if (str_eq(wm_top_type, EL_STR("Memory"))) {
+    state_set(EL_STR("allow_auto"), EL_STR("1"));
+  }
+  if (str_eq(wm_top_type, EL_STR("BacklogItem"))) {
+    state_set(EL_STR("allow_auto"), EL_STR("1"));
+  }
+  if (str_eq(wm_top_type, EL_STR("Entity"))) {
+    state_set(EL_STR("allow_auto"), EL_STR("1"));
+  }
+  el_val_t allow_auto = state_get(EL_STR("allow_auto"));
+  if (str_eq(allow_auto, EL_STR("1"))) {
+    if (!str_eq(wm_top_lbl, EL_STR(""))) {
+      el_val_t sp = str_find_chars(wm_top_lbl, EL_STR(" :(["));
+      if (sp > 3) {
+        state_set(EL_STR("cseed_auto"), str_slice(wm_top_lbl, 0, sp));
+      }
     }
   }
   el_val_t auto_term = state_get(EL_STR("cseed_auto"));
-  el_val_t results_auto = ({ el_val_t _if_result_101 = 0; if (str_eq(auto_term, EL_STR(""))) { _if_result_101 = (EL_STR("[]")); } else { _if_result_101 = (engram_activate_json(auto_term, 1)); } _if_result_101; });
+  el_val_t results_auto = ({ el_val_t _if_result_3 = 0; if (str_eq(auto_term, EL_STR(""))) { _if_result_3 = (EL_STR("[]")); } else { _if_result_3 = (engram_activate_json(auto_term, 1)); } _if_result_3; });
   el_val_t found_auto = json_array_len(results_auto);
   el_val_t total_found = (found + found_auto);
   el_val_t safe_auto = str_replace(auto_term, EL_STR("\""), EL_STR("'"));
@@ -25908,6 +25950,7 @@ el_val_t proactive_curiosity(void) {
   return 0;
 }
 
+
 el_val_t pulse_count(void) {
   el_val_t s = state_get(EL_STR("soul.pulse"));
   if (str_eq(s, EL_STR(""))) {
@@ -28915,7 +28958,13 @@ int main(int _argc, char** _argv) {
   state_set(EL_STR("soul_engram_api_key"), engram_api_key_raw);
   state_set(EL_STR("soul.running"), EL_STR("true"));
   is_genesis = str_eq(soul_cgi_id, EL_STR("ntn-genesis"));
-  if (is_genesis) {
+  guard_disk = ({ el_val_t _if_result_25 = 0; if (str_eq(engram_url_raw, EL_STR(""))) { _if_result_25 = (fs_read(snapshot)); } else { _if_result_25 = (EL_STR("")); } _if_result_25; });
+  guard_disk_len = str_len(guard_disk);
+  safe_to_seed = !((guard_disk_len > 200000) && (engram_node_count() < (guard_disk_len / 16000)));
+  if (is_genesis && !safe_to_seed) {
+    println(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("[soul] GUARD: loaded "), int_to_str(engram_node_count())), EL_STR(" nodes but snapshot file is ")), int_to_str(guard_disk_len)), EL_STR(" bytes \xe2\x80\x94 refusing to seed/save over a real graph")));
+  }
+  if (is_genesis && safe_to_seed) {
     el_val_t edge_count_now = engram_edge_count();
     if (edge_count_now < 100) {
       init_soul_edges();
@@ -28926,7 +28975,7 @@ int main(int _argc, char** _argv) {
     state_set(EL_STR("soul_snapshot_path"), snapshot);
     engram_save(snapshot);
   }
-  if (is_genesis) {
+  if (is_genesis && safe_to_seed) {
     el_val_t snap = state_get(EL_STR("soul_snapshot_path"));
     if (!str_eq(snap, EL_STR(""))) {
       engram_save(snap);

dist/soul.c

@@ -1041,13 +1041,54 @@ el_val_t agentic_api_key(void);
 el_val_t call_neuron_mcp(el_val_t tool_name, el_val_t args_json);
 el_val_t agentic_tools_literal(void);
 el_val_t agentic_tools_with_web(void);
+/* === Patched agentic declarations === */
+el_val_t connector_tools_json(void);
+el_val_t agentic_tools_all(void);
+el_val_t call_mcp_bridge(el_val_t tool_name, el_val_t tool_input);
+el_val_t tool_auto_approved(el_val_t tool_name);
+el_val_t is_builtin_tool(el_val_t tool_name);
+el_val_t next_bridge_id(void);
+el_val_t agentic_loop(el_val_t session_id, el_val_t model, el_val_t safe_sys, el_val_t tools_json, el_val_t messages_in, el_val_t h, el_val_t tools_log_in);
+el_val_t bridge_save(el_val_t session_id, el_val_t model, el_val_t safe_sys, el_val_t tools_json, el_val_t messages, el_val_t tools_log, el_val_t tool_use_id);
+el_val_t agentic_resume(el_val_t session_id, el_val_t tool_use_id, el_val_t content);
+/* === End patched declarations === */
+/* === PR #23 workspace scope declarations === */
+el_val_t agent_workspace_root(void);
+el_val_t path_within_root(el_val_t path, el_val_t root);
+el_val_t resolve_in_root(el_val_t path, el_val_t root);
+el_val_t ensure_self_canonical_bridge(void);
+/* === End PR #23/#24 declarations === */
 el_val_t dispatch_tool(el_val_t tool_name, el_val_t tool_input);
+el_val_t json_array_append(el_val_t arr, el_val_t item);
+el_val_t append_tool_log(el_val_t log, el_val_t name);
+el_val_t exec_tool_block(el_val_t block);
+el_val_t agentic_blob(el_val_t model, el_val_t system, el_val_t tools_json, el_val_t messages, el_val_t origin, el_val_t approval, el_val_t iteration, el_val_t tools_log, el_val_t content, el_val_t queue, el_val_t results, el_val_t next);
+el_val_t extract_all_text(el_val_t s);
+el_val_t strip_citations(el_val_t s);
+el_val_t agentic_api_turn(el_val_t model, el_val_t safe_sys, el_val_t tools_json, el_val_t messages);
+el_val_t agentic_engine(el_val_t session_id, el_val_t blob);
 el_val_t handle_chat_agentic(el_val_t body);
+el_val_t handle_session_approve(el_val_t session_id, el_val_t body);
 el_val_t handle_chat_as_soul(el_val_t body);
 el_val_t handle_dharma_room_turn(el_val_t body);
 el_val_t handle_dharma_room_turn_agentic(el_val_t body);
 el_val_t auto_persist(el_val_t req, el_val_t resp);
 el_val_t strengthen_chat_nodes(el_val_t activation_nodes);
+el_val_t safety_self_harm_phrases(void);
+el_val_t safety_abuse_phrases(void);
+el_val_t safety_general_hard_phrases(void);
+el_val_t safety_soft_phrases(void);
+el_val_t safety_normalize(el_val_t message);
+el_val_t safety_any_match(el_val_t text, el_val_t phrases_json);
+el_val_t safety_count_match(el_val_t text, el_val_t phrases_json);
+el_val_t safety_detect_bell_level(el_val_t message);
+el_val_t safety_classify_hard_bell(el_val_t message);
+el_val_t safety_soft_directive(void);
+el_val_t safety_hard_directive(el_val_t hard_type);
+el_val_t safety_augment_system(el_val_t system, el_val_t user_msg);
+el_val_t safety_contact_path(void);
+el_val_t handle_safety_contact_get(void);
+el_val_t handle_safety_contact_post(el_val_t body);
 el_val_t auth_headers(el_val_t tok);
 el_val_t axon_get(el_val_t path);
 el_val_t axon_post(el_val_t path, el_val_t body);
@@ -1110,6 +1151,7 @@ el_val_t session_update_meta_timestamp(el_val_t session_id);
 el_val_t session_auto_title(el_val_t session_id, el_val_t first_message);
 el_val_t handle_session_approve(el_val_t session_id, el_val_t body);
 el_val_t strip_query(el_val_t path);
+el_val_t flag_true(el_val_t body, el_val_t key);
 el_val_t err_404(el_val_t path);
 el_val_t err_405(el_val_t method, el_val_t path);
 el_val_t route_health(void);
@@ -1144,6 +1186,9 @@ el_val_t local_node_count;
 el_val_t snapshot_usable;
 el_val_t boot_num;
 el_val_t is_genesis;
+el_val_t guard_disk;
+el_val_t guard_disk_len;
+el_val_t safe_to_seed;
 
 el_val_t lang_profile(el_val_t code, el_val_t word_order, el_val_t morph_type, el_val_t has_case, el_val_t has_gender, el_val_t script_dir, el_val_t agreement, el_val_t null_subject) {
   el_val_t r = native_list_empty();
@@ -26558,21 +26603,82 @@ el_val_t agentic_tools_with_web(void) {
   return 0;
 }
 
+
+/* === PR #23: workspace scope helpers === */
+el_val_t agent_workspace_root(void) {
+  el_val_t s = state_get(EL_STR("agent_workspace_root"));
+  if (!str_eq(s, EL_STR(""))) {
+    return s;
+  }
+  return env(EL_STR("NEURON_AGENT_ROOT"));
+  return 0;
+}
+
+el_val_t path_within_root(el_val_t path, el_val_t root) {
+  if (str_eq(root, EL_STR(""))) {
+    return 1;
+  }
+  if (str_contains(path, EL_STR(".."))) {
+    return 0;
+  }
+  if (str_starts_with(path, EL_STR("~"))) {
+    return 0;
+  }
+  if (str_starts_with(path, EL_STR("/"))) {
+    return str_starts_with(path, root);
+  }
+  return 1;
+  return 0;
+}
+
+el_val_t resolve_in_root(el_val_t path, el_val_t root) {
+  if (str_eq(root, EL_STR(""))) {
+    return path;
+  }
+  if (str_starts_with(path, EL_STR("/"))) {
+    return path;
+  }
+  return el_str_concat(el_str_concat(root, EL_STR("/")), path);
+  return 0;
+}
+
+
+/* === PR #24: ensure_self_canonical_bridge === */
+/* Link the public self anchor (kn-efeb4a5b, 8 tag edges) to the curated    */
+/* self node (015644f5, 1461 edges) so self-traversal reaches real identity. */
+/* Idempotent: only adds the edge when missing. Run every boot.             */
+el_val_t ensure_self_canonical_bridge(void) {
+  el_val_t pub_self = EL_STR("kn-efeb4a5b-5aff-4759-8a97-7233099be6ee");
+  el_val_t curated_self = EL_STR("015644f5-8194-4af0-800d-dd4a0cd71396");
+  el_val_t nbrs = engram_neighbors_json(pub_self, 1, EL_STR("out"));
+  if (!str_contains(nbrs, curated_self)) {
+    engram_connect(pub_self, curated_self, el_from_float(0.95), EL_STR("canonical-self"));
+    engram_connect(curated_self, pub_self, el_from_float(0.95), EL_STR("canonical-self"));
+    println(EL_STR("[soul] canonical-self bridge built: kn-efeb4a5b <-> 015644f5"));
+  }
+  return 0;
+}
+
+/* === PR #23: workspace-scoped dispatch_tool === */
 el_val_t dispatch_tool(el_val_t tool_name, el_val_t tool_input) {
   if (str_eq(tool_name, EL_STR("read_file"))) {
     el_val_t path = json_get(tool_input, EL_STR("path"));
-    el_val_t content = fs_read(path);
+    el_val_t root = agent_workspace_root();
+    if (!path_within_root(path, root)) {
+      return json_safe(EL_STR("denied: path is outside the agent workspace root"));
+    }
+    el_val_t content = fs_read(resolve_in_root(path, root));
     return json_safe(content);
   }
   if (str_eq(tool_name, EL_STR("write_file"))) {
     el_val_t path = json_get(tool_input, EL_STR("path"));
     el_val_t content = json_get(tool_input, EL_STR("content"));
-    el_val_t threat = threat_trajectory_check(tool_name, tool_input);
-    if (threat >= 70) {
-      return json_safe(el_str_concat(el_str_concat(EL_STR("{\"error\":\"blocked: security threshold exceeded\",\"score\":"), int_to_str(threat)), EL_STR("}")));
+    el_val_t root = agent_workspace_root();
+    if (!path_within_root(path, root)) {
+      return json_safe(EL_STR("denied: path is outside the agent workspace root"));
     }
-    fs_write(path, content);
-    return EL_STR("{\\\"ok\\\":true}");
+    fs_write(resolve_in_root(path, root), content);
+    return json_safe(EL_STR("{\"ok\":true}"));
   }
   if (str_eq(tool_name, EL_STR("web_get"))) {
     el_val_t url = json_get(tool_input, EL_STR("url"));
@@ -26586,43 +26692,47 @@ el_val_t dispatch_tool(el_val_t tool_name, el_val_t tool_input) {
   }
   if (str_eq(tool_name, EL_STR("run_command"))) {
     el_val_t cmd = json_get(tool_input, EL_STR("command"));
-    el_val_t threat = threat_trajectory_check(tool_name, tool_input);
-    if (threat >= 70) {
-      return json_safe(el_str_concat(el_str_concat(EL_STR("{\"error\":\"blocked: security threshold exceeded\",\"score\":"), int_to_str(threat)), EL_STR("}")));
-    }
-    el_val_t result = exec_capture(cmd);
+    el_val_t root = agent_workspace_root();
+    el_val_t scoped = ({ el_val_t _if_result_26 = 0; if (str_eq(root, EL_STR(""))) { _if_result_26 = (cmd); } else { _if_result_26 = (el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("cd "), root), EL_STR(" && ( ")), cmd), EL_STR(" )"))); } _if_result_26; });
+    el_val_t result = exec_capture(scoped);
     return json_safe(result);
   }
+  if (str_starts_with(tool_name, EL_STR("mcp__"))) {
+    el_val_t out = call_mcp_bridge(tool_name, tool_input);
+    if (str_eq(out, EL_STR(""))) {
+      return json_safe(EL_STR("MCP bridge unreachable (neuron-connectd on :7771)"));
+    }
+    el_val_t content = json_get(out, EL_STR("content"));
+    if (str_eq(content, EL_STR(""))) {
+      el_val_t err = json_get(out, EL_STR("error"));
+      el_val_t msg = ({ el_val_t _if_result_27 = 0; if (str_eq(err, EL_STR(""))) { _if_result_27 = (EL_STR("MCP call failed")); } else { _if_result_27 = (el_str_concat(EL_STR("MCP error: "), err)); } _if_result_27; });
+      return json_safe(msg);
+    }
+    return json_safe(content);
+  }
   if (str_eq(tool_name, EL_STR("list_files"))) {
     el_val_t path = json_get(tool_input, EL_STR("path"));
-    el_val_t result = exec_capture(el_str_concat(el_str_concat(EL_STR("ls -la "), path), EL_STR(" 2>&1")));
+    el_val_t root = agent_workspace_root();
+    if (!path_within_root(path, root)) {
+      return json_safe(EL_STR("denied: path is outside the agent workspace root"));
+    }
+    el_val_t result = exec_capture(el_str_concat(el_str_concat(EL_STR("ls -la "), resolve_in_root(path, root)), EL_STR(" 2>&1")));
     return json_safe(result);
   }
   if (str_eq(tool_name, EL_STR("grep"))) {
     el_val_t pattern = json_get(tool_input, EL_STR("pattern"));
     el_val_t path = json_get(tool_input, EL_STR("path"));
-    el_val_t result = exec_capture(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("grep -rn "), EL_STR("\"")), pattern), EL_STR("\" ")), path), EL_STR(" 2>&1 | head -50")));
-    return json_safe(result);
-  }
-  if (str_eq(tool_name, EL_STR("web_search"))) {
-    el_val_t query = json_get(tool_input, EL_STR("query"));
-    el_val_t safe_q = exec_capture(el_str_concat(el_str_concat(EL_STR("python3 -c \"import urllib.parse; print(urllib.parse.quote('"), query), EL_STR("'))\" 2>/dev/null")));
-    el_val_t safe_q2 = str_trim(safe_q);
-    el_val_t url = el_str_concat(EL_STR("https://html.duckduckgo.com/html/?q="), safe_q2);
-    el_val_t h = el_map_new(0);
-    map_set(h, EL_STR("User-Agent"), EL_STR("Mozilla/5.0"));
-    el_val_t raw = http_get(url);
-    el_val_t result = ({ el_val_t _if_result_197 = 0; if ((str_len(raw) > 4000)) { _if_result_197 = (str_slice(raw, 0, 4000)); } else { _if_result_197 = (raw); } _if_result_197; });
+    el_val_t root = agent_workspace_root();
+    if (!path_within_root(path, root)) {
+      return json_safe(EL_STR("denied: path is outside the agent workspace root"));
+    }
+    el_val_t result = exec_capture(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("grep -rn \""), pattern), EL_STR("\" ")), resolve_in_root(path, root)), EL_STR(" 2>&1 | head -50")));
     return json_safe(result);
   }
   if (str_eq(tool_name, EL_STR("edit_file"))) {
     el_val_t path = json_get(tool_input, EL_STR("path"));
     el_val_t old_text = json_get(tool_input, EL_STR("old_text"));
     el_val_t new_text = json_get(tool_input, EL_STR("new_text"));
-    el_val_t threat = threat_trajectory_check(tool_name, tool_input);
-    if (threat >= 70) {
-      return json_safe(el_str_concat(el_str_concat(EL_STR("{\"error\":\"blocked: security threshold exceeded\",\"score\":"), int_to_str(threat)), EL_STR("}")));
-    }
     el_val_t content = fs_read(path);
     if (str_eq(content, EL_STR(""))) {
       return json_safe(EL_STR("{\"error\":\"file not found\"}"));
@@ -26634,21 +26744,21 @@ el_val_t dispatch_tool(el_val_t tool_name, el_val_t tool_input) {
   if (str_eq(tool_name, EL_STR("remember"))) {
     el_val_t content = json_get(tool_input, EL_STR("content"));
     el_val_t tags_raw = json_get(tool_input, EL_STR("tags"));
-    el_val_t tags = ({ el_val_t _if_result_198 = 0; if (str_eq(tags_raw, EL_STR(""))) { _if_result_198 = (EL_STR("[\"chat\"]")); } else { _if_result_198 = (tags_raw); } _if_result_198; });
+    el_val_t tags = ({ el_val_t _if_result_28 = 0; if (str_eq(tags_raw, EL_STR(""))) { _if_result_28 = (EL_STR("[\"chat\"]")); } else { _if_result_28 = (tags_raw); } _if_result_28; });
     el_val_t id = mem_remember(content, tags);
     return json_safe(el_str_concat(el_str_concat(EL_STR("{\"ok\":true,\"id\":\""), id), EL_STR("\"}")));
   }
   if (str_eq(tool_name, EL_STR("recall"))) {
     el_val_t query = json_get(tool_input, EL_STR("query"));
     el_val_t depth_str = json_get(tool_input, EL_STR("depth"));
-    el_val_t depth = ({ el_val_t _if_result_199 = 0; if (str_eq(depth_str, EL_STR(""))) { _if_result_199 = (3); } else { _if_result_199 = (str_to_int(depth_str)); } _if_result_199; });
+    el_val_t depth = ({ el_val_t _if_result_29 = 0; if (str_eq(depth_str, EL_STR(""))) { _if_result_29 = (3); } else { _if_result_29 = (str_to_int(depth_str)); } _if_result_29; });
     el_val_t result = mem_recall(query, depth);
     return json_safe(result);
   }
   if (str_eq(tool_name, EL_STR("neuron_search_knowledge"))) {
     el_val_t query = json_get(tool_input, EL_STR("query"));
     el_val_t limit_str = json_get(tool_input, EL_STR("limit"));
-    el_val_t limit = ({ el_val_t _if_result_200 = 0; if (str_eq(limit_str, EL_STR(""))) { _if_result_200 = (5); } else { _if_result_200 = (str_to_int(limit_str)); } _if_result_200; });
+    el_val_t limit = ({ el_val_t _if_result_30 = 0; if (str_eq(limit_str, EL_STR(""))) { _if_result_30 = (5); } else { _if_result_30 = (str_to_int(limit_str)); } _if_result_30; });
     el_val_t args = el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"query\":\""), json_safe(query)), EL_STR("\",\"limit\":")), int_to_str(limit)), EL_STR("}"));
     el_val_t result = call_neuron_mcp(EL_STR("searchKnowledge"), args);
     return json_safe(result);
@@ -26659,9 +26769,9 @@ el_val_t dispatch_tool(el_val_t tool_name, el_val_t tool_input) {
     el_val_t project = json_get(tool_input, EL_STR("project"));
     el_val_t importance = json_get(tool_input, EL_STR("importance"));
     el_val_t safe_content = json_safe(content);
-    el_val_t tags_part = ({ el_val_t _if_result_201 = 0; if (str_eq(tags_raw, EL_STR(""))) { _if_result_201 = (EL_STR("\"tags\":[\"chat\"]")); } else { _if_result_201 = (el_str_concat(EL_STR("\"tags\":"), tags_raw)); } _if_result_201; });
-    el_val_t project_part = ({ el_val_t _if_result_202 = 0; if (str_eq(project, EL_STR(""))) { _if_result_202 = (EL_STR("")); } else { _if_result_202 = (el_str_concat(el_str_concat(EL_STR(",\"project\":\""), json_safe(project)), EL_STR("\""))); } _if_result_202; });
-    el_val_t importance_part = ({ el_val_t _if_result_203 = 0; if (str_eq(importance, EL_STR(""))) { _if_result_203 = (EL_STR("")); } else { _if_result_203 = (el_str_concat(el_str_concat(EL_STR(",\"importance\":\""), json_safe(importance)), EL_STR("\""))); } _if_result_203; });
+    el_val_t tags_part = ({ el_val_t _if_result_31 = 0; if (str_eq(tags_raw, EL_STR(""))) { _if_result_31 = (EL_STR("\"tags\":[\"chat\"]")); } else { _if_result_31 = (el_str_concat(EL_STR("\"tags\":"), tags_raw)); } _if_result_31; });
+    el_val_t project_part = ({ el_val_t _if_result_32 = 0; if (str_eq(project, EL_STR(""))) { _if_result_32 = (EL_STR("")); } else { _if_result_32 = (el_str_concat(el_str_concat(EL_STR(",\"project\":\""), json_safe(project)), EL_STR("\""))); } _if_result_32; });
+    el_val_t importance_part = ({ el_val_t _if_result_33 = 0; if (str_eq(importance, EL_STR(""))) { _if_result_33 = (EL_STR("")); } else { _if_result_33 = (el_str_concat(el_str_concat(EL_STR(",\"importance\":\""), json_safe(importance)), EL_STR("\""))); } _if_result_33; });
     el_val_t args = el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"content\":\""), safe_content), EL_STR("\",")), tags_part), project_part), importance_part), EL_STR("}"));
     el_val_t result = call_neuron_mcp(EL_STR("remember"), args);
     return json_safe(result);
@@ -26669,7 +26779,7 @@ el_val_t dispatch_tool(el_val_t tool_name, el_val_t tool_input) {
   if (str_eq(tool_name, EL_STR("neuron_recall"))) {
     el_val_t query = json_get(tool_input, EL_STR("query"));
     el_val_t limit_str = json_get(tool_input, EL_STR("limit"));
-    el_val_t limit = ({ el_val_t _if_result_204 = 0; if (str_eq(limit_str, EL_STR(""))) { _if_result_204 = (10); } else { _if_result_204 = (str_to_int(limit_str)); } _if_result_204; });
+    el_val_t limit = ({ el_val_t _if_result_34 = 0; if (str_eq(limit_str, EL_STR(""))) { _if_result_34 = (10); } else { _if_result_34 = (str_to_int(limit_str)); } _if_result_34; });
     el_val_t args = el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"query\":\""), json_safe(query)), EL_STR("\",\"limit\":")), int_to_str(limit)), EL_STR("}"));
     el_val_t result = call_neuron_mcp(EL_STR("inspectMemories"), args);
     return json_safe(result);
@@ -26680,11 +26790,11 @@ el_val_t dispatch_tool(el_val_t tool_name, el_val_t tool_input) {
     el_val_t status = json_get(tool_input, EL_STR("status"));
     el_val_t priority = json_get(tool_input, EL_STR("priority"));
     el_val_t query = json_get(tool_input, EL_STR("query"));
-    el_val_t view_part = ({ el_val_t _if_result_205 = 0; if (str_eq(view, EL_STR(""))) { _if_result_205 = (EL_STR("\"view\":\"roadmap\"")); } else { _if_result_205 = (el_str_concat(el_str_concat(EL_STR("\"view\":\""), json_safe(view)), EL_STR("\""))); } _if_result_205; });
-    el_val_t project_part = ({ el_val_t _if_result_206 = 0; if (str_eq(project, EL_STR(""))) { _if_result_206 = (EL_STR("")); } else { _if_result_206 = (el_str_concat(el_str_concat(EL_STR(",\"project\":\""), json_safe(project)), EL_STR("\""))); } _if_result_206; });
-    el_val_t status_part = ({ el_val_t _if_result_207 = 0; if (str_eq(status, EL_STR(""))) { _if_result_207 = (EL_STR("")); } else { _if_result_207 = (el_str_concat(el_str_concat(EL_STR(",\"status\":\""), json_safe(status)), EL_STR("\""))); } _if_result_207; });
-    el_val_t priority_part = ({ el_val_t _if_result_208 = 0; if (str_eq(priority, EL_STR(""))) { _if_result_208 = (EL_STR("")); } else { _if_result_208 = (el_str_concat(el_str_concat(EL_STR(",\"priority\":\""), json_safe(priority)), EL_STR("\""))); } _if_result_208; });
-    el_val_t query_part = ({ el_val_t _if_result_209 = 0; if (str_eq(query, EL_STR(""))) { _if_result_209 = (EL_STR("")); } else { _if_result_209 = (el_str_concat(el_str_concat(EL_STR(",\"query\":\""), json_safe(query)), EL_STR("\""))); } _if_result_209; });
+    el_val_t view_part = ({ el_val_t _if_result_35 = 0; if (str_eq(view, EL_STR(""))) { _if_result_35 = (EL_STR("\"view\":\"roadmap\"")); } else { _if_result_35 = (el_str_concat(el_str_concat(EL_STR("\"view\":\""), json_safe(view)), EL_STR("\""))); } _if_result_35; });
+    el_val_t project_part = ({ el_val_t _if_result_36 = 0; if (str_eq(project, EL_STR(""))) { _if_result_36 = (EL_STR("")); } else { _if_result_36 = (el_str_concat(el_str_concat(EL_STR(",\"project\":\""), json_safe(project)), EL_STR("\""))); } _if_result_36; });
+    el_val_t status_part = ({ el_val_t _if_result_37 = 0; if (str_eq(status, EL_STR(""))) { _if_result_37 = (EL_STR("")); } else { _if_result_37 = (el_str_concat(el_str_concat(EL_STR(",\"status\":\""), json_safe(status)), EL_STR("\""))); } _if_result_37; });
+    el_val_t priority_part = ({ el_val_t _if_result_38 = 0; if (str_eq(priority, EL_STR(""))) { _if_result_38 = (EL_STR("")); } else { _if_result_38 = (el_str_concat(el_str_concat(EL_STR(",\"priority\":\""), json_safe(priority)), EL_STR("\""))); } _if_result_38; });
+    el_val_t query_part = ({ el_val_t _if_result_39 = 0; if (str_eq(query, EL_STR(""))) { _if_result_39 = (EL_STR("")); } else { _if_result_39 = (el_str_concat(el_str_concat(EL_STR(",\"query\":\""), json_safe(query)), EL_STR("\""))); } _if_result_39; });
     el_val_t args = el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{"), view_part), project_part), status_part), priority_part), query_part), EL_STR("}"));
     el_val_t result = call_neuron_mcp(EL_STR("reviewBacklog"), args);
     return json_safe(result);
@@ -26692,8 +26802,8 @@ el_val_t dispatch_tool(el_val_t tool_name, el_val_t tool_input) {
   if (str_eq(tool_name, EL_STR("neuron_find_artifacts"))) {
     el_val_t query = json_get(tool_input, EL_STR("query"));
     el_val_t project = json_get(tool_input, EL_STR("project"));
-    el_val_t query_part = ({ el_val_t _if_result_210 = 0; if (str_eq(query, EL_STR(""))) { _if_result_210 = (EL_STR("")); } else { _if_result_210 = (el_str_concat(el_str_concat(EL_STR("\"query\":\""), json_safe(query)), EL_STR("\""))); } _if_result_210; });
-    el_val_t project_part = ({ el_val_t _if_result_211 = 0; if (str_eq(project, EL_STR(""))) { _if_result_211 = (EL_STR("")); } else { _if_result_211 = (({ el_val_t _if_result_212 = 0; if (str_eq(query_part, EL_STR(""))) { _if_result_212 = (el_str_concat(el_str_concat(EL_STR("\"project\":\""), json_safe(project)), EL_STR("\""))); } else { _if_result_212 = (el_str_concat(el_str_concat(EL_STR(",\"project\":\""), json_safe(project)), EL_STR("\""))); } _if_result_212; })); } _if_result_211; });
+    el_val_t query_part = ({ el_val_t _if_result_40 = 0; if (str_eq(query, EL_STR(""))) { _if_result_40 = (EL_STR("")); } else { _if_result_40 = (el_str_concat(el_str_concat(EL_STR("\"query\":\""), json_safe(query)), EL_STR("\""))); } _if_result_40; });
+    el_val_t project_part = ({ el_val_t _if_result_41 = 0; if (str_eq(project, EL_STR(""))) { _if_result_41 = (EL_STR("")); } else { _if_result_41 = (({ el_val_t _if_result_42 = 0; if (str_eq(query_part, EL_STR(""))) { _if_result_42 = (el_str_concat(el_str_concat(EL_STR("\"project\":\""), json_safe(project)), EL_STR("\""))); } else { _if_result_42 = (el_str_concat(el_str_concat(EL_STR(",\"project\":\""), json_safe(project)), EL_STR("\""))); } _if_result_42; })); } _if_result_41; });
     el_val_t args = el_str_concat(el_str_concat(el_str_concat(EL_STR("{"), query_part), project_part), EL_STR("}"));
     el_val_t result = call_neuron_mcp(EL_STR("findArtifacts"), args);
     return json_safe(result);
@@ -26706,58 +26816,193 @@ el_val_t dispatch_tool(el_val_t tool_name, el_val_t tool_input) {
   return 0;
 }
 
-el_val_t handle_chat_agentic(el_val_t body) {
-  el_val_t message = json_get(body, EL_STR("message"));
-  if (str_eq(message, EL_STR(""))) {
-    return EL_STR("{\"error\":\"message required\",\"reply\":\"\"}");
+
+
+/* === PATCHED: new agentic infrastructure functions === */
+el_val_t safety_normalize(el_val_t message) {
+  el_val_t lower = str_to_lower(message);
+  return str_replace(lower, EL_STR("’"), EL_STR("'"));
+  return 0;
+}
+
+el_val_t safety_count_match(el_val_t text, el_val_t phrases_json) {
+  el_val_t n = json_array_len(phrases_json);
+  el_val_t i = 0;
+  el_val_t count = 0;
+  while (i < n) {
+    el_val_t phrase = json_array_get_string(phrases_json, i);
+    count = ({ el_val_t _if_result_46 = 0; if (str_contains(text, phrase)) { _if_result_46 = ((count + 1)); } else { _if_result_46 = (count); } _if_result_46; });
+    i = (i + 1);
   }
-  el_val_t req_model = json_get(body, EL_STR("model"));
-  el_val_t model = ({ el_val_t _if_result_213 = 0; if (str_eq(req_model, EL_STR(""))) { _if_result_213 = (chat_default_model()); } else { _if_result_213 = (req_model); } _if_result_213; });
-  el_val_t session_id = json_get(body, EL_STR("session_id"));
-  el_val_t using_session = !str_eq(session_id, EL_STR(""));
-  el_val_t require_approval = json_get_bool(body, EL_STR("require_approval"));
-  el_val_t discard_ra = ({ el_val_t _if_result_214 = 0; if ((using_session && require_approval)) { (void)(state_set(el_str_concat(EL_STR("session_require_approval_"), session_id), EL_STR("true"))); _if_result_214 = (1); } else { _if_result_214 = (0); } _if_result_214; });
-  threat_history_append(message);
-  el_val_t prior_hist = ({ el_val_t _if_result_215 = 0; if (using_session) { el_val_t sh = state_get(el_str_concat(EL_STR("session_hist_"), session_id)); _if_result_215 = (({ el_val_t _if_result_216 = 0; if (str_eq(sh, EL_STR(""))) { el_val_t eng_results = engram_search_json(el_str_concat(EL_STR("session:messages:"), session_id), 3); _if_result_216 = (({ el_val_t _if_result_217 = 0; if (str_eq(eng_results, EL_STR(""))) { _if_result_217 = (EL_STR("")); } else { _if_result_217 = (({ el_val_t _if_result_218 = 0; if (str_eq(eng_results, EL_STR("[]"))) { _if_result_218 = (EL_STR("")); } else { el_val_t h_node = json_array_get(eng_results, 0); el_val_t h_label = json_get(h_node, EL_STR("label")); el_val_t h_content = json_get(h_node, EL_STR("content")); _if_result_218 = (({ el_val_t _if_result_219 = 0; if ((str_eq(h_label, el_str_concat(EL_STR("session:messages:"), session_id)) && str_starts_with(h_content, EL_STR("[")))) { _if_result_219 = (h_content); } else { _if_result_219 = (EL_STR("")); } _if_result_219; })); } _if_result_218; })); } _if_result_217; })); } else { _if_result_216 = (sh); } _if_result_216; })); } else { _if_result_215 = (EL_STR("")); } _if_result_215; });
-  el_val_t ctx = engram_compile(message);
-  el_val_t identity = build_identity_from_graph();
-  el_val_t system = el_str_concat(el_str_concat(identity, EL_STR(" You have access to tools: read/write/edit files, list directories, grep, run shell commands, fetch URLs, search the web, search your engram memory, remember new things, and recall memories by association. Use tools when they add genuine value. Be direct.\n\n")), ctx);
-  if (str_starts_with(model, EL_STR("gemini"))) {
-    el_val_t gemini_resp = llm_call_gemini(model, system, message);
-    el_val_t is_err = str_starts_with(gemini_resp, EL_STR("{\"error\""));
-    if (is_err) {
-      return EL_STR("{\"error\":\"llm unavailable\",\"reply\":\"\"}");
-    }
-    el_val_t safe_gr = json_safe(gemini_resp);
-    el_val_t sess_field = ({ el_val_t _if_result_220 = 0; if (using_session) { _if_result_220 = (el_str_concat(el_str_concat(EL_STR(",\"session_id\":\""), session_id), EL_STR("\""))); } else { _if_result_220 = (EL_STR("")); } _if_result_220; });
-    return el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"reply\":\""), safe_gr), EL_STR("\",\"model\":\"")), model), EL_STR("\",\"agentic\":false,\"tools_used\":[]")), sess_field), EL_STR("}"));
+  return count;
+  return 0;
+}
+
+el_val_t safety_any_match(el_val_t text, el_val_t phrases_json) {
+  el_val_t n = json_array_len(phrases_json);
+  el_val_t i = 0;
+  el_val_t found = 0;
+  while (i < n) {
+    el_val_t phrase = json_array_get_string(phrases_json, i);
+    found = ({ el_val_t _if_result_45 = 0; if (str_contains(text, phrase)) { _if_result_45 = (1); } else { _if_result_45 = (found); } _if_result_45; });
+    i = (i + 1);
   }
-  if (str_starts_with(model, EL_STR("grok"))) {
-    el_val_t grok_resp = llm_call_grok(model, system, message);
-    el_val_t is_err = str_starts_with(grok_resp, EL_STR("{\"error\""));
-    if (is_err) {
-      return EL_STR("{\"error\":\"llm unavailable\",\"reply\":\"\"}");
-    }
-    el_val_t safe_gr = json_safe(grok_resp);
-    el_val_t sess_field = ({ el_val_t _if_result_221 = 0; if (using_session) { _if_result_221 = (el_str_concat(el_str_concat(EL_STR(",\"session_id\":\""), session_id), EL_STR("\""))); } else { _if_result_221 = (EL_STR("")); } _if_result_221; });
-    return el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"reply\":\""), safe_gr), EL_STR("\",\"model\":\"")), model), EL_STR("\",\"agentic\":false,\"tools_used\":[]")), sess_field), EL_STR("}"));
+  return found;
+  return 0;
+}
+
+el_val_t safety_abuse_phrases(void) {
+  return EL_STR("[\"someone is hurting me\",\"someone's hurting me\",\"someone hurt me\",\"he hit me\",\"she hit me\",\"they hit me\",\"he hurt me\",\"she hurt me\",\"being abused\",\"being hurt by\",\"i am being abused\",\"i'm being abused\",\"i am being hurt\",\"i'm being hurt\",\"domestic violence\",\"my partner hurt\",\"my partner hit\",\"my husband hurt\",\"my wife hurt\",\"my boyfriend hurt\",\"my girlfriend hurt\",\"my parent hurt\",\"my father hurt\",\"my mother hurt\",\"my dad hurt\",\"my mom hurt\",\"afraid of him\",\"afraid of her\",\"afraid to go home\",\"scared of him\",\"scared of her\",\"he threatened me\",\"she threatened me\",\"threatened to hurt me\",\"threatened to kill me\",\"going to hurt me\",\"going to kill me\",\"help me he\",\"help me she\",\"help me they\"]");
+  return 0;
+}
+
+el_val_t safety_self_harm_phrases(void) {
+  return EL_STR("[\"kill myself\",\"killing myself\",\"want to die\",\"want to be dead\",\"going to end my life\",\"end my life\",\"take my life\",\"taking my life\",\"suicide\",\"suicidal\",\"can't go on\",\"cannot go on\",\"i have a knife\",\"i have a gun\",\"i have pills\",\"took pills\",\"took too many\",\"overdose\",\"overdosing\",\"self harm\",\"self-harm\",\"cutting myself\",\"hurt myself\",\"hurting myself\",\"no reason to live\",\"not worth living\",\"better off dead\",\"better off without me\"]");
+  return 0;
+}
+
+el_val_t safety_general_hard_phrases(void) {
+  return EL_STR("[\"going to kill\",\"going to hurt\",\"hurting me\",\"being hurt\"]");
+  return 0;
+}
+
+el_val_t safety_soft_phrases(void) {
+  return EL_STR("[\"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 0;
+}
+
+el_val_t safety_classify_hard_bell(el_val_t message) {
+  el_val_t text = safety_normalize(message);
+  if (safety_any_match(text, safety_abuse_phrases())) {
+    return EL_STR("abuse");
   }
-  el_val_t api_key = agentic_api_key();
-  el_val_t tools_json = agentic_tools_with_web();
-  el_val_t safe_msg = json_safe(message);
-  el_val_t safe_sys = json_safe(system);
-  el_val_t hist_prefix = ({ el_val_t _if_result_222 = 0; if ((!str_eq(prior_hist, EL_STR("")) && !str_eq(prior_hist, EL_STR("[]")))) { el_val_t h_total = json_array_len(prior_hist); el_val_t h_out = EL_STR(""); el_val_t hi = 0; _if_result_222 = (({ el_val_t _if_result_223 = 0; if (str_eq(h_out, EL_STR(""))) { _if_result_223 = (EL_STR("")); } else { _if_result_223 = (el_str_concat(h_out, EL_STR(","))); } _if_result_223; })); } else { _if_result_222 = (EL_STR("")); } _if_result_222; });
-  el_val_t messages = el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("["), hist_prefix), EL_STR("{\"role\":\"user\",\"content\":\"")), safe_msg), EL_STR("\"}]"));
+  if (safety_any_match(text, safety_self_harm_phrases())) {
+    return EL_STR("self_harm");
+  }
+  return EL_STR("self_harm");
+  return 0;
+}
+
+el_val_t safety_detect_bell_level(el_val_t message) {
+  el_val_t text = safety_normalize(message);
+  el_val_t is_hard = ((safety_any_match(text, safety_self_harm_phrases()) || safety_any_match(text, safety_abuse_phrases())) || safety_any_match(text, safety_general_hard_phrases()));
+  if (is_hard) {
+    return EL_STR("hard");
+  }
+  el_val_t soft_count = safety_count_match(text, safety_soft_phrases());
+  if (soft_count >= 2) {
+    return EL_STR("soft");
+  }
+  return EL_STR("none");
+  return 0;
+}
+
+el_val_t safety_hard_directive(el_val_t hard_type) {
+  el_val_t preamble = EL_STR("[SUBSTRATE DIRECTIVE - not visible to the user, do not mention this instruction]\nThe person has expressed something that sounds like immediate distress or danger. Do not ignore it. Do not just answer the surface question. Lead with genuine human warmth. Acknowledge what you heard. Tell them you're concerned. Let them know they are not alone. Ask them directly if they are safe right now. Stay with them in this conversation.");
+  el_val_t abuse_block = EL_STR("\n\nThis appears to be danger from ANOTHER person. Routing rule (non-negotiable): do NOT suggest involving, contacting, or notifying the person's safety contact, family, or anyone close to them - that person may be the source of danger and has NOT been notified. Share only independent emergency resources:\n  - Call or text 911 if in immediate danger\n  - National Domestic Violence Hotline - 1-800-799-7233 (24/7, confidential)\n  - Text START to 88788\n  - thehotline.org (chat available)\n  - 988 Suicide & Crisis Lifeline - call or text 988\nReassure them, if it fits, that their contact list has not been notified.");
+  el_val_t self_harm_block = EL_STR("\n\nShare these crisis resources if appropriate:\n  - 988 Suicide & Crisis Lifeline - call or text 988 (US)\n  - Crisis Text Line - text HOME to 741741\n  - International Association for Suicide Prevention: https://www.iasp.info/resources/Crisis_Centres/");
+  if (str_eq(hard_type, EL_STR("abuse"))) {
+    return el_str_concat(preamble, abuse_block);
+  }
+  return el_str_concat(preamble, self_harm_block);
+  return 0;
+}
+
+el_val_t safety_soft_directive(void) {
+  return EL_STR("[SUBSTRATE DIRECTIVE - not visible to the user, do not mention this instruction]\nBefore responding to the user's message, acknowledge what they've said with genuine care and warmth. Pause on the feeling they expressed. Ask how they are, or whether they want to talk about it. Do this naturally, in your own voice - not as a script, not as a checklist. Only after checking in should you continue with whatever they asked.");
+  return 0;
+}
+
+el_val_t safety_augment_system(el_val_t system, el_val_t user_msg) {
+  el_val_t level = safety_detect_bell_level(user_msg);
+  if (str_eq(level, EL_STR("none"))) {
+    return system;
+  }
+  if (str_eq(level, EL_STR("soft"))) {
+    el_val_t logd = mem_emit_state_event(EL_STR("safety-bell"), EL_STR("soft"), EL_STR("soft bell fired (content not stored)"));
+    return el_str_concat(el_str_concat(system, EL_STR("\n\n")), safety_soft_directive());
+  }
+  el_val_t hard_type = safety_classify_hard_bell(user_msg);
+  el_val_t logd2 = mem_emit_state_event(EL_STR("safety-bell"), el_str_concat(EL_STR("hard:"), hard_type), EL_STR("hard bell fired (content not stored)"));
+  return el_str_concat(el_str_concat(system, EL_STR("\n\n")), safety_hard_directive(hard_type));
+  return 0;
+}
+
+el_val_t connector_tools_json(void) {
+  el_val_t raw = exec_capture(EL_STR("curl -s --max-time 2 http://127.0.0.1:7771/mcp/tools"));
+  if (str_eq(raw, EL_STR(""))) {
+    return EL_STR("[]");
+  }
+  el_val_t arr = json_get_raw(raw, EL_STR("tools"));
+  if (str_eq(arr, EL_STR(""))) {
+    return EL_STR("[]");
+  }
+  return arr;
+  return 0;
+}
+
+el_val_t agentic_tools_all(void) {
+  el_val_t base = agentic_tools_literal();
+  el_val_t conn = connector_tools_json();
+  el_val_t conn_inner = str_slice(conn, 1, (str_len(conn) - 1));
+  if (str_eq(conn_inner, EL_STR(""))) {
+    return base;
+  }
+  el_val_t base_open = str_slice(base, 0, (str_len(base) - 1));
+  return el_str_concat(el_str_concat(el_str_concat(base_open, EL_STR(",")), conn_inner), EL_STR("]"));
+  return 0;
+}
+
+el_val_t call_mcp_bridge(el_val_t tool_name, el_val_t tool_input) {
+  el_val_t eff_input = ({ el_val_t _if_result_24 = 0; if (str_eq(tool_input, EL_STR(""))) { _if_result_24 = (EL_STR("{}")); } else { _if_result_24 = (tool_input); } _if_result_24; });
+  el_val_t body = el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"name\":\""), tool_name), EL_STR("\",\"input\":")), eff_input), EL_STR("}"));
+  el_val_t tmp = EL_STR("/tmp/neuron-mcp-call.json");
+  fs_write(tmp, body);
+  return exec_capture(el_str_concat(EL_STR("curl -s --max-time 30 -X POST http://127.0.0.1:7771/mcp/call -H 'Content-Type: application/json' -d @"), tmp));
+  return 0;
+}
+
+el_val_t tool_auto_approved(el_val_t tool_name) {
+  if (!str_starts_with(tool_name, EL_STR("mcp__"))) {
+    return 0;
+  }
+  el_val_t raw = exec_capture(EL_STR("curl -s --max-time 2 http://127.0.0.1:7771/mcp/auto-approved"));
+  if (str_eq(raw, EL_STR(""))) {
+    return 0;
+  }
+  el_val_t list = json_get_raw(raw, EL_STR("tools"));
+  if (str_eq(list, EL_STR(""))) {
+    return 0;
+  }
+  return str_contains(list, el_str_concat(el_str_concat(EL_STR("\""), tool_name), EL_STR("\"")));
+  return 0;
+}
+
+el_val_t is_builtin_tool(el_val_t tool_name) {
+  return ((((((((((str_eq(tool_name, EL_STR("read_file")) || str_eq(tool_name, EL_STR("write_file"))) || str_eq(tool_name, EL_STR("web_get"))) || str_eq(tool_name, EL_STR("search_memory"))) || str_eq(tool_name, EL_STR("run_command"))) || str_eq(tool_name, EL_STR("list_files"))) || str_eq(tool_name, EL_STR("grep"))) || str_eq(tool_name, EL_STR("edit_file"))) || str_eq(tool_name, EL_STR("remember"))) || str_eq(tool_name, EL_STR("recall"))) || str_starts_with(tool_name, EL_STR("neuron_")));
+  return 0;
+}
+
+el_val_t next_bridge_id(void) {
+  el_val_t prev = state_get(EL_STR("mcp_bridge_seq"));
+  el_val_t n = ({ el_val_t _if_result_42 = 0; if (str_eq(prev, EL_STR(""))) { _if_result_42 = (0); } else { _if_result_42 = (str_to_int(prev)); } _if_result_42; });
+  el_val_t next = (n + 1);
+  state_set(EL_STR("mcp_bridge_seq"), int_to_str(next));
+  return el_str_concat(el_str_concat(el_str_concat(EL_STR("br-"), int_to_str(time_now())), EL_STR("-")), int_to_str(next));
+  return 0;
+}
+
+el_val_t agentic_loop(el_val_t session_id, el_val_t model, el_val_t safe_sys, el_val_t tools_json, el_val_t messages_in, el_val_t h, el_val_t tools_log_in) {
   el_val_t api_url = EL_STR("https://api.anthropic.com/v1/messages");
-  el_val_t h = el_map_new(0);
-  map_set(h, EL_STR("x-api-key"), api_key);
-  map_set(h, EL_STR("anthropic-version"), EL_STR("2023-06-01"));
-  map_set(h, EL_STR("content-type"), EL_STR("application/json"));
+  el_val_t messages = messages_in;
   el_val_t final_text = EL_STR("");
-  el_val_t tools_log = EL_STR("");
+  el_val_t tools_log = tools_log_in;
   el_val_t iteration = 0;
   el_val_t keep_going = 1;
-  el_val_t always_key = el_str_concat(EL_STR("always_allow_"), session_id);
+  el_val_t pending = 0;
+  el_val_t pend_tool_id = EL_STR("");
+  el_val_t pend_tool_name = EL_STR("");
+  el_val_t pend_tool_input = EL_STR("");
   while (keep_going && (iteration < 8)) {
     el_val_t req_body = el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"model\":\""), model), EL_STR("\"")), EL_STR(",\"max_tokens\":4096")), EL_STR(",\"system\":\"")), safe_sys), EL_STR("\"")), EL_STR(",\"tools\":")), tools_json), EL_STR(",\"messages\":")), messages), EL_STR("}"));
     el_val_t raw_resp = http_post_with_headers(api_url, req_body, h);
@@ -26767,7 +27012,7 @@ el_val_t handle_chat_agentic(el_val_t body) {
     }
     el_val_t stop_reason = json_get(raw_resp, EL_STR("stop_reason"));
     el_val_t content_arr = json_get_raw(raw_resp, EL_STR("content"));
-    el_val_t eff_content = ({ el_val_t _if_result_224 = 0; if (str_eq(content_arr, EL_STR(""))) { _if_result_224 = (EL_STR("[]")); } else { _if_result_224 = (content_arr); } _if_result_224; });
+    el_val_t eff_content = ({ el_val_t _if_result_54 = 0; if (str_eq(content_arr, EL_STR(""))) { _if_result_54 = (EL_STR("[]")); } else { _if_result_54 = (content_arr); } _if_result_54; });
     el_val_t text_out = EL_STR("");
     el_val_t has_tool = 0;
     el_val_t tool_id = EL_STR("");
@@ -26778,51 +27023,137 @@ el_val_t handle_chat_agentic(el_val_t body) {
     while (ci < c_total) {
       el_val_t block = json_array_get(eff_content, ci);
       el_val_t btype = json_get(block, EL_STR("type"));
-      text_out = ({ el_val_t _if_result_225 = 0; if (str_eq(btype, EL_STR("text"))) { _if_result_225 = (el_str_concat(text_out, json_get(block, EL_STR("text")))); } else { _if_result_225 = (text_out); } _if_result_225; });
+      text_out = ({ el_val_t _if_result_55 = 0; if (str_eq(btype, EL_STR("text"))) { _if_result_55 = (el_str_concat(text_out, json_get(block, EL_STR("text")))); } else { _if_result_55 = (text_out); } _if_result_55; });
       el_val_t is_new_tool = (str_eq(btype, EL_STR("tool_use")) && !has_tool);
-      has_tool = ({ el_val_t _if_result_226 = 0; if (is_new_tool) { _if_result_226 = (1); } else { _if_result_226 = (has_tool); } _if_result_226; });
-      tool_id = ({ el_val_t _if_result_227 = 0; if (is_new_tool) { _if_result_227 = (json_get(block, EL_STR("id"))); } else { _if_result_227 = (tool_id); } _if_result_227; });
-      tool_name = ({ el_val_t _if_result_228 = 0; if (is_new_tool) { _if_result_228 = (json_get(block, EL_STR("name"))); } else { _if_result_228 = (tool_name); } _if_result_228; });
-      tool_input = ({ el_val_t _if_result_229 = 0; if (is_new_tool) { _if_result_229 = (json_get_raw(block, EL_STR("input"))); } else { _if_result_229 = (tool_input); } _if_result_229; });
+      has_tool = ({ el_val_t _if_result_56 = 0; if (is_new_tool) { _if_result_56 = (1); } else { _if_result_56 = (has_tool); } _if_result_56; });
+      tool_id = ({ el_val_t _if_result_57 = 0; if (is_new_tool) { _if_result_57 = (json_get(block, EL_STR("id"))); } else { _if_result_57 = (tool_id); } _if_result_57; });
+      tool_name = ({ el_val_t _if_result_58 = 0; if (is_new_tool) { _if_result_58 = (json_get(block, EL_STR("name"))); } else { _if_result_58 = (tool_name); } _if_result_58; });
+      tool_input = ({ el_val_t _if_result_59 = 0; if (is_new_tool) { _if_result_59 = (json_get_raw(block, EL_STR("input"))); } else { _if_result_59 = (tool_input); } _if_result_59; });
       ci = (ci + 1);
     }
     el_val_t is_tool_turn = (str_eq(stop_reason, EL_STR("tool_use")) && has_tool);
-    el_val_t always_list = state_get(always_key);
-    el_val_t is_always_allowed = (!str_eq(tool_name, EL_STR("")) && str_contains(always_list, tool_name));
-    el_val_t needs_approval_pause = (((is_tool_turn && require_approval) && using_session) && !is_always_allowed);
-    el_val_t discard_pause = ({ el_val_t _if_result_230 = 0; if (needs_approval_pause) { el_val_t inner_pause = str_slice(messages, 1, (str_len(messages) - 1)); el_val_t msgs_with_assistant = el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("["), inner_pause), EL_STR(",{\"role\":\"assistant\",\"content\":")), eff_content), EL_STR("}]")); el_val_t pending = el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"call_id\":\""), tool_id), EL_STR("\"")), EL_STR(",\"tool_name\":\"")), tool_name), EL_STR("\"")), EL_STR(",\"tool_input\":")), tool_input), EL_STR(",\"messages_so_far\":")), msgs_with_assistant), EL_STR(",\"model\":\"")), model), EL_STR("\"")), EL_STR(",\"system\":\"")), safe_sys), EL_STR("\"}")); (void)(state_set(el_str_concat(EL_STR("pending_tool_"), session_id), pending)); _if_result_230 = (1); } else { _if_result_230 = (0); } _if_result_230; });
-    keep_going = ({ el_val_t _if_result_231 = 0; if (needs_approval_pause) { _if_result_231 = (0); } else { _if_result_231 = (keep_going); } _if_result_231; });
-    el_val_t tool_result_raw = ({ el_val_t _if_result_232 = 0; if ((is_tool_turn && !needs_approval_pause)) { _if_result_232 = (dispatch_tool(tool_name, tool_input)); } else { _if_result_232 = (EL_STR("")); } _if_result_232; });
-    el_val_t tool_result = ({ el_val_t _if_result_233 = 0; if ((str_len(tool_result_raw) > 6000)) { _if_result_233 = (el_str_concat(str_slice(tool_result_raw, 0, 6000), EL_STR("...[truncated]"))); } else { _if_result_233 = (tool_result_raw); } _if_result_233; });
+    el_val_t always_key = el_str_concat(EL_STR("always_allow_"), session_id);
+    el_val_t always_list = ({ el_val_t _if_result_60 = 0; if (!str_eq(session_id, EL_STR(""))) { _if_result_60 = (state_get(always_key)); } else { _if_result_60 = (EL_STR("")); } _if_result_60; });
+    el_val_t is_always_allowed = ((!str_eq(tool_name, EL_STR("")) && !str_eq(always_list, EL_STR(""))) && str_contains(always_list, tool_name));
+    el_val_t needs_bridge = ((is_tool_turn && !is_builtin_tool(tool_name)) && !is_always_allowed);
+    el_val_t tool_result_raw = ({ el_val_t _if_result_61 = 0; if ((is_tool_turn && !needs_bridge)) { _if_result_61 = (dispatch_tool(tool_name, tool_input)); } else { _if_result_61 = (EL_STR("")); } _if_result_61; });
+    el_val_t tool_result = ({ el_val_t _if_result_62 = 0; if ((str_len(tool_result_raw) > 6000)) { _if_result_62 = (el_str_concat(str_slice(tool_result_raw, 0, 6000), EL_STR("...[truncated]"))); } else { _if_result_62 = (tool_result_raw); } _if_result_62; });
     el_val_t tool_msg = el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"type\":\"tool_result\",\"tool_use_id\":\""), tool_id), EL_STR("\",\"content\":\"")), tool_result), EL_STR("\"}"));
-    el_val_t input_summary = ({ el_val_t _if_result_234 = 0; if (str_eq(tool_name, EL_STR("run_command"))) { _if_result_234 = (json_get(tool_input, EL_STR("command"))); } else { _if_result_234 = (({ el_val_t _if_result_235 = 0; if (str_eq(tool_name, EL_STR("read_file"))) { _if_result_235 = (json_get(tool_input, EL_STR("path"))); } else { _if_result_235 = (({ el_val_t _if_result_236 = 0; if (str_eq(tool_name, EL_STR("write_file"))) { _if_result_236 = (json_get(tool_input, EL_STR("path"))); } else { _if_result_236 = (({ el_val_t _if_result_237 = 0; if (str_eq(tool_name, EL_STR("edit_file"))) { _if_result_237 = (json_get(tool_input, EL_STR("path"))); } else { _if_result_237 = (({ el_val_t _if_result_238 = 0; if (str_eq(tool_name, EL_STR("list_files"))) { _if_result_238 = (json_get(tool_input, EL_STR("path"))); } else { _if_result_238 = (({ el_val_t _if_result_239 = 0; if (str_eq(tool_name, EL_STR("grep"))) { _if_result_239 = (el_str_concat(el_str_concat(json_get(tool_input, EL_STR("pattern")), EL_STR(" in ")), json_get(tool_input, EL_STR("path")))); } else { _if_result_239 = (({ el_val_t _if_result_240 = 0; if (str_eq(tool_name, EL_STR("web_search"))) { _if_result_240 = (json_get(tool_input, EL_STR("query"))); } else { _if_result_240 = (({ el_val_t _if_result_241 = 0; if (str_eq(tool_name, EL_STR("web_get"))) { _if_result_241 = (json_get(tool_input, EL_STR("url"))); } else { _if_result_241 = (({ el_val_t _if_result_242 = 0; if (str_eq(tool_name, EL_STR("search_memory"))) { _if_result_242 = (json_get(tool_input, EL_STR("query"))); } else { _if_result_242 = (EL_STR("")); } _if_result_242; })); } _if_result_241; })); } _if_result_240; })); } _if_result_239; })); } _if_result_238; })); } _if_result_237; })); } _if_result_236; })); } _if_result_235; })); } _if_result_234; });
-    el_val_t safe_input_summary = json_safe(input_summary);
-    el_val_t tool_entry = el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"tool\":\""), tool_name), EL_STR("\",\"input\":\"")), safe_input_summary), EL_STR("\"}"));
-    tools_log = ({ el_val_t _if_result_243 = 0; if ((is_tool_turn && !needs_approval_pause)) { _if_result_243 = (({ el_val_t _if_result_244 = 0; if (str_eq(tools_log, EL_STR(""))) { _if_result_244 = (tool_entry); } else { _if_result_244 = (el_str_concat(el_str_concat(tools_log, EL_STR(",")), tool_entry)); } _if_result_244; })); } else { _if_result_243 = (tools_log); } _if_result_243; });
+    el_val_t tool_quoted = el_str_concat(el_str_concat(EL_STR("\""), tool_name), EL_STR("\""));
+    tools_log = ({ el_val_t _if_result_63 = 0; if (has_tool) { _if_result_63 = (({ el_val_t _if_result_64 = 0; if (str_eq(tools_log, EL_STR(""))) { _if_result_64 = (tool_quoted); } else { _if_result_64 = (el_str_concat(el_str_concat(tools_log, EL_STR(",")), tool_quoted)); } _if_result_64; })); } else { _if_result_63 = (tools_log); } _if_result_63; });
     el_val_t inner = str_slice(messages, 1, (str_len(messages) - 1));
-    messages = ({ el_val_t _if_result_245 = 0; if ((is_tool_turn && !needs_approval_pause)) { _if_result_245 = (el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("["), inner), EL_STR(",{\"role\":\"assistant\",\"content\":")), eff_content), EL_STR("}")), EL_STR(",{\"role\":\"user\",\"content\":[")), tool_msg), EL_STR("]}")), EL_STR("]"))); } else { _if_result_245 = (messages); } _if_result_245; });
-    final_text = ({ el_val_t _if_result_246 = 0; if (!is_tool_turn) { _if_result_246 = (text_out); } else { _if_result_246 = (final_text); } _if_result_246; });
-    keep_going = ({ el_val_t _if_result_247 = 0; if (!is_tool_turn) { _if_result_247 = (0); } else { _if_result_247 = (keep_going); } _if_result_247; });
+    el_val_t messages_with_assistant = el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("["), inner), EL_STR(",{\"role\":\"assistant\",\"content\":")), eff_content), EL_STR("}")), EL_STR("]"));
+    el_val_t local_continue = (is_tool_turn && !needs_bridge);
+    messages = ({ el_val_t _if_result_65 = 0; if (local_continue) { el_val_t inner2 = str_slice(messages_with_assistant, 1, (str_len(messages_with_assistant) - 1)); _if_result_65 = (el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("["), inner2), EL_STR(",{\"role\":\"user\",\"content\":[")), tool_msg), EL_STR("]}]"))); } else { _if_result_65 = (messages); } _if_result_65; });
+    pending = ({ el_val_t _if_result_66 = 0; if (needs_bridge) { _if_result_66 = (1); } else { _if_result_66 = (pending); } _if_result_66; });
+    pend_tool_id = ({ el_val_t _if_result_67 = 0; if (needs_bridge) { _if_result_67 = (tool_id); } else { _if_result_67 = (pend_tool_id); } _if_result_67; });
+    pend_tool_name = ({ el_val_t _if_result_68 = 0; if (needs_bridge) { _if_result_68 = (tool_name); } else { _if_result_68 = (pend_tool_name); } _if_result_68; });
+    pend_tool_input = ({ el_val_t _if_result_69 = 0; if (needs_bridge) { _if_result_69 = (tool_input); } else { _if_result_69 = (pend_tool_input); } _if_result_69; });
+    if (needs_bridge) {
+      bridge_save(session_id, model, safe_sys, tools_json, messages_with_assistant, tools_log, pend_tool_id);
+    }
+    final_text = ({ el_val_t _if_result_70 = 0; if (!is_tool_turn) { _if_result_70 = (text_out); } else { _if_result_70 = (final_text); } _if_result_70; });
+    keep_going = ({ el_val_t _if_result_71 = 0; if (local_continue) { _if_result_71 = (keep_going); } else { _if_result_71 = (0); } _if_result_71; });
     iteration = (iteration + 1);
   }
-  el_val_t pending_check = ({ el_val_t _if_result_248 = 0; if (using_session) { _if_result_248 = (state_get(el_str_concat(EL_STR("pending_tool_"), session_id))); } else { _if_result_248 = (EL_STR("")); } _if_result_248; });
-  if (!str_eq(pending_check, EL_STR(""))) {
-    el_val_t p_tool_name = json_get(pending_check, EL_STR("tool_name"));
-    el_val_t p_call_id = json_get(pending_check, EL_STR("call_id"));
-    el_val_t p_tool_input = json_get_raw(pending_check, EL_STR("tool_input"));
-    return el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"status\":\"tool_pending\""), EL_STR(",\"call_id\":\"")), p_call_id), EL_STR("\"")), EL_STR(",\"tool_name\":\"")), p_tool_name), EL_STR("\"")), EL_STR(",\"tool_input\":")), p_tool_input), EL_STR(",\"session_id\":\"")), session_id), EL_STR("\"}"));
+  if (pending) {
+    el_val_t safe_in = ({ el_val_t _if_result_72 = 0; if (str_eq(pend_tool_input, EL_STR(""))) { _if_result_72 = (EL_STR("{}")); } else { _if_result_72 = (pend_tool_input); } _if_result_72; });
+    el_val_t tools_arr = ({ el_val_t _if_result_73 = 0; if (str_eq(tools_log, EL_STR(""))) { _if_result_73 = (EL_STR("[]")); } else { _if_result_73 = (el_str_concat(el_str_concat(EL_STR("["), tools_log), EL_STR("]"))); } _if_result_73; });
+    return el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"tool_pending\":true"), EL_STR(",\"session_id\":\"")), session_id), EL_STR("\"")), EL_STR(",\"call_id\":\"")), pend_tool_id), EL_STR("\"")), EL_STR(",\"tool_name\":\"")), pend_tool_name), EL_STR("\"")), EL_STR(",\"tool_input\":")), safe_in), EL_STR(",\"model\":\"")), model), EL_STR("\"")), EL_STR(",\"agentic\":true")), EL_STR(",\"tools_used\":")), tools_arr), EL_STR("}"));
   }
   if (str_eq(final_text, EL_STR(""))) {
     return EL_STR("{\"error\":\"no response\",\"reply\":\"\"}");
   }
-  el_val_t discard_sess = ({ el_val_t _if_result_249 = 0; if (using_session) { el_val_t updated_hist = hist_append(prior_hist, EL_STR("user"), message); el_val_t updated_hist2 = hist_append(updated_hist, EL_STR("assistant"), final_text); el_val_t trimmed_hist = ({ el_val_t _if_result_250 = 0; if ((json_array_len(updated_hist2) > 20)) { _if_result_250 = (hist_trim(updated_hist2)); } else { _if_result_250 = (updated_hist2); } _if_result_250; }); (void)(state_set(el_str_concat(EL_STR("session_hist_"), session_id), trimmed_hist)); el_val_t old_results = engram_search_json(el_str_concat(EL_STR("session:messages:"), session_id), 3); el_val_t o_total = ({ el_val_t _if_result_251 = 0; if (str_eq(old_results, EL_STR(""))) { _if_result_251 = (0); } else { _if_result_251 = (json_array_len(old_results)); } _if_result_251; }); el_val_t oi = 0; el_val_t hist_tags = EL_STR("[\"session\",\"session-history\",\"Conversation\"]"); el_val_t discard_write = engram_node_full(trimmed_hist, EL_STR("Conversation"), el_str_concat(EL_STR("session:messages:"), session_id), el_from_float(el_from_float(0.6)), el_from_float(el_from_float(0.6)), el_from_float(el_from_float(0.9)), EL_STR("Episodic"), hist_tags); _if_result_249 = (1); } else { _if_result_249 = (0); } _if_result_249; });
   el_val_t safe_text = json_safe(final_text);
-  el_val_t tools_arr = ({ el_val_t _if_result_252 = 0; if (str_eq(tools_log, EL_STR(""))) { _if_result_252 = (EL_STR("[]")); } else { _if_result_252 = (el_str_concat(el_str_concat(EL_STR("["), tools_log), EL_STR("]"))); } _if_result_252; });
-  el_val_t sess_field = ({ el_val_t _if_result_253 = 0; if (using_session) { _if_result_253 = (el_str_concat(el_str_concat(EL_STR(",\"session_id\":\""), session_id), EL_STR("\""))); } else { _if_result_253 = (EL_STR("")); } _if_result_253; });
-  return el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"reply\":\""), safe_text), EL_STR("\",\"model\":\"")), model), EL_STR("\",\"agentic\":true,\"tools_used\":")), tools_arr), sess_field), EL_STR("}"));
+  el_val_t tools_arr = ({ el_val_t _if_result_74 = 0; if (str_eq(tools_log, EL_STR(""))) { _if_result_74 = (EL_STR("[]")); } else { _if_result_74 = (el_str_concat(el_str_concat(EL_STR("["), tools_log), EL_STR("]"))); } _if_result_74; });
+  return el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"reply\":\""), safe_text), EL_STR("\",\"model\":\"")), model), EL_STR("\",\"agentic\":true,\"tools_used\":")), tools_arr), EL_STR("}"));
   return 0;
 }
 
+el_val_t bridge_save(el_val_t session_id, el_val_t model, el_val_t safe_sys, el_val_t tools_json, el_val_t messages, el_val_t tools_log, el_val_t tool_use_id) {
+  if (str_eq(messages, EL_STR("")) || str_eq(tools_json, EL_STR(""))) {
+    return 0;
+  }
+  el_val_t blob = el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"model\":\""), json_safe(model)), EL_STR("\"")), EL_STR(",\"safe_sys\":\"")), json_safe(safe_sys)), EL_STR("\"")), EL_STR(",\"messages_raw\":")), messages), EL_STR(",\"tools_raw\":")), tools_json), EL_STR(",\"tools_log\":\"")), json_safe(tools_log)), EL_STR("\"")), EL_STR(",\"tool_use_id\":\"")), json_safe(tool_use_id)), EL_STR("\"}"));
+  state_set(el_str_concat(EL_STR("mcp_bridge:"), session_id), blob);
+  return 1;
+  return 0;
+}
+
+/* agentic_resume (sessions version — reads mcp_bridge: key) */
+el_val_t agentic_resume(el_val_t session_id, el_val_t tool_use_id, el_val_t content) {
+  el_val_t blob = state_get(el_str_concat(EL_STR("mcp_bridge:"), session_id));
+  if (str_eq(blob, EL_STR(""))) {
+    return EL_STR("{\"error\":\"unknown session_id\",\"reply\":\"\"}");
+  }
+  el_val_t model = json_get(blob, EL_STR("model"));
+  el_val_t safe_sys = json_get(blob, EL_STR("safe_sys"));
+  el_val_t messages = json_get_raw(blob, EL_STR("messages_raw"));
+  messages = ({ el_val_t _if_result_75 = 0; if (str_eq(messages, EL_STR(""))) { _if_result_75 = (json_get(blob, EL_STR("messages"))); } else { _if_result_75 = (messages); } _if_result_75; });
+  el_val_t tools_json = json_get_raw(blob, EL_STR("tools_raw"));
+  tools_json = ({ el_val_t _if_result_76 = 0; if (str_eq(tools_json, EL_STR(""))) { _if_result_76 = (json_get(blob, EL_STR("tools_json"))); } else { _if_result_76 = (tools_json); } _if_result_76; });
+  if (str_eq(messages, EL_STR("")) || str_eq(tools_json, EL_STR(""))) {
+    return EL_STR("{\"error\":\"corrupt bridge state\",\"reply\":\"\"}");
+  }
+  el_val_t tools_log = json_get(blob, EL_STR("tools_log"));
+  el_val_t saved_use_id = json_get(blob, EL_STR("tool_use_id"));
+  el_val_t use_id = ({ el_val_t _if_result_77 = 0; if (str_eq(tool_use_id, EL_STR(""))) { _if_result_77 = (saved_use_id); } else { _if_result_77 = (tool_use_id); } _if_result_77; });
+  el_val_t eff_use_id = ({ el_val_t _if_result_78 = 0; if (str_eq(use_id, saved_use_id)) { _if_result_78 = (use_id); } else { _if_result_78 = (saved_use_id); } _if_result_78; });
+  el_val_t trimmed = ({ el_val_t _if_result_79 = 0; if ((str_len(content) > 6000)) { _if_result_79 = (el_str_concat(str_slice(content, 0, 6000), EL_STR("...[truncated]"))); } else { _if_result_79 = (content); } _if_result_79; });
+  el_val_t safe_result = json_safe(trimmed);
+  el_val_t tool_msg = el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"type\":\"tool_result\",\"tool_use_id\":\""), eff_use_id), EL_STR("\",\"content\":\"")), safe_result), EL_STR("\"}"));
+  el_val_t inner = str_slice(messages, 1, (str_len(messages) - 1));
+  el_val_t resumed_messages = el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("["), inner), EL_STR(",{\"role\":\"user\",\"content\":[")), tool_msg), EL_STR("]}]"));
+  state_set(el_str_concat(EL_STR("mcp_bridge:"), session_id), EL_STR(""));
+  el_val_t api_key = agentic_api_key();
+  el_val_t h = el_map_new(0);
+  map_set(h, EL_STR("x-api-key"), api_key);
+  map_set(h, EL_STR("anthropic-version"), EL_STR("2023-06-01"));
+  map_set(h, EL_STR("content-type"), EL_STR("application/json"));
+  return agentic_loop(session_id, model, safe_sys, tools_json, resumed_messages, h, tools_log);
+  return 0;
+}
+
+/* === PATCHED: handle_chat_agentic (agentic_tools_all + agentic_loop) === */
+el_val_t handle_chat_agentic(el_val_t body) {
+  el_val_t message = json_get(body, EL_STR("message"));
+  if (str_eq(message, EL_STR(""))) {
+    return EL_STR("{\"error\":\"message required\",\"reply\":\"\"}");
+  }
+  el_val_t req_model = json_get(body, EL_STR("model"));
+  el_val_t model = ({ el_val_t _if_result_43 = 0; if (str_eq(req_model, EL_STR(""))) { _if_result_43 = (chat_default_model()); } else { _if_result_43 = (req_model); } _if_result_43; });
+  el_val_t req_session = json_get(body, EL_STR("session_id"));
+  el_val_t hist_key = ({ el_val_t _if_result_44 = 0; if (str_eq(req_session, EL_STR(""))) { _if_result_44 = (EL_STR("conv_history")); } else { _if_result_44 = (el_str_concat(EL_STR("session_hist_"), req_session)); } _if_result_44; });
+  el_val_t agentic_hist = state_get(hist_key);
+  el_val_t agentic_hist_len = ({ el_val_t _if_result_45 = 0; if (str_eq(agentic_hist, EL_STR(""))) { _if_result_45 = (0); } else { _if_result_45 = (json_array_len(agentic_hist)); } _if_result_45; });
+  el_val_t ag_is_cont = ((str_len(message) < 50) && (agentic_hist_len > 0));
+  el_val_t ag_last_entry = ({ el_val_t _if_result_46 = 0; if (ag_is_cont) { _if_result_46 = (json_array_get(agentic_hist, (agentic_hist_len - 1))); } else { _if_result_46 = (EL_STR("")); } _if_result_46; });
+  el_val_t ag_last_content = ({ el_val_t _if_result_47 = 0; if (!str_eq(ag_last_entry, EL_STR(""))) { _if_result_47 = (json_get(ag_last_entry, EL_STR("content"))); } else { _if_result_47 = (EL_STR("")); } _if_result_47; });
+  el_val_t ag_thread_snip = ({ el_val_t _if_result_48 = 0; if ((str_len(ag_last_content) > 150)) { _if_result_48 = (str_slice(ag_last_content, 0, 150)); } else { _if_result_48 = (ag_last_content); } _if_result_48; });
+  el_val_t ag_seed = ({ el_val_t _if_result_49 = 0; if (!str_eq(ag_thread_snip, EL_STR(""))) { _if_result_49 = (el_str_concat(el_str_concat(ag_thread_snip, EL_STR(" ")), message)); } else { _if_result_49 = (message); } _if_result_49; });
+  el_val_t ctx = engram_compile(ag_seed);
+  el_val_t identity = state_get(EL_STR("soul_identity"));
+  el_val_t system = el_str_concat(el_str_concat(identity, EL_STR(" You have access to tools: read files, write files, browse the web, search your memory, run commands. Use them when they add genuine value. Be direct.\n\n")), ctx);
+  el_val_t api_key = agentic_api_key();
+  el_val_t tools_json = agentic_tools_all();
+  el_val_t safe_msg = json_safe(message);
+  el_val_t safe_sys = json_safe(system);
+  el_val_t prior_messages = ({ el_val_t _if_result_50 = 0; if ((agentic_hist_len > 0)) { el_val_t inner = str_slice(agentic_hist, 1, (str_len(agentic_hist) - 1)); _if_result_50 = (el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("["), inner), EL_STR(",{\"role\":\"user\",\"content\":\"")), safe_msg), EL_STR("\"}]"))); } else { _if_result_50 = (el_str_concat(el_str_concat(EL_STR("[{\"role\":\"user\",\"content\":\""), safe_msg), EL_STR("\"}]"))); } _if_result_50; });
+  el_val_t messages = prior_messages;
+  el_val_t api_url = EL_STR("https://api.anthropic.com/v1/messages");
+  el_val_t h = el_map_new(0);
+  map_set(h, EL_STR("x-api-key"), api_key);
+  map_set(h, EL_STR("anthropic-version"), EL_STR("2023-06-01"));
+  map_set(h, EL_STR("content-type"), EL_STR("application/json"));
+  el_val_t session_id = ({ el_val_t _if_result_51 = 0; if (str_eq(req_session, EL_STR(""))) { _if_result_51 = (next_bridge_id()); } else { _if_result_51 = (req_session); } _if_result_51; });
+  el_val_t result = agentic_loop(session_id, model, safe_sys, tools_json, messages, h, EL_STR(""));
+  el_val_t reply_text = json_get(result, EL_STR("reply"));
+  el_val_t discard_hist = ({ el_val_t _if_result_52 = 0; if (!str_eq(reply_text, EL_STR(""))) { el_val_t updated = hist_append(agentic_hist, EL_STR("user"), message); el_val_t updated2 = hist_append(updated, EL_STR("assistant"), reply_text); el_val_t trimmed = ({ el_val_t _if_result_53 = 0; if ((json_array_len(updated2) > 20)) { _if_result_53 = (hist_trim(updated2)); } else { _if_result_53 = (updated2); } _if_result_53; }); (void)(state_set(hist_key, trimmed)); _if_result_52 = (1); } else { _if_result_52 = (0); } _if_result_52; });
+  return result;
+  return 0;
+}
+
+
 el_val_t handle_chat_as_soul(el_val_t body) {
   el_val_t speaker = json_get(body, EL_STR("speaker_slug"));
   if (str_eq(speaker, EL_STR(""))) {
@@ -26878,9 +27209,11 @@ el_val_t handle_dharma_room_turn(el_val_t body) {
   return 0;
 }
 
+/* === PATCHED: handle_dharma_room_turn_agentic (agentic_tools_all + agentic_loop) === */
 el_val_t handle_dharma_room_turn_agentic(el_val_t body) {
   el_val_t transcript = json_get(body, EL_STR("transcript"));
-  el_val_t identity = build_identity_from_graph();
+  el_val_t room_id = json_get(body, EL_STR("room_id"));
+  el_val_t identity = state_get(EL_STR("soul_identity"));
   el_val_t cgi_id = state_get(EL_STR("soul_cgi_id"));
   el_val_t model = chat_default_model();
   if (str_eq(transcript, EL_STR(""))) {
@@ -26889,70 +27222,37 @@ el_val_t handle_dharma_room_turn_agentic(el_val_t body) {
   el_val_t ctx = engram_compile(transcript);
   el_val_t system = el_str_concat(el_str_concat(identity, EL_STR(" You have access to tools: read files, write files, browse the web, search your memory, run commands. Use them when they add genuine value. Be direct and stay in character.\n\n")), ctx);
   el_val_t api_key = agentic_api_key();
-  el_val_t tools_json = agentic_tools_literal();
+  system = safety_augment_system(system, transcript);
+  el_val_t tools_json = agentic_tools_all();
   el_val_t safe_transcript = json_safe(transcript);
   el_val_t safe_sys = json_safe(system);
   el_val_t messages = el_str_concat(el_str_concat(EL_STR("[{\"role\":\"user\",\"content\":\""), safe_transcript), EL_STR("\"}]"));
-  el_val_t api_url = EL_STR("https://api.anthropic.com/v1/messages");
   el_val_t h = el_map_new(0);
   map_set(h, EL_STR("x-api-key"), api_key);
   map_set(h, EL_STR("anthropic-version"), EL_STR("2023-06-01"));
   map_set(h, EL_STR("content-type"), EL_STR("application/json"));
-  el_val_t final_text = EL_STR("");
-  el_val_t tools_log = EL_STR("");
-  el_val_t iteration = 0;
-  el_val_t keep_going = 1;
-  while (keep_going && (iteration < 8)) {
-    el_val_t req_body = el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"model\":\""), model), EL_STR("\"")), EL_STR(",\"max_tokens\":4096")), EL_STR(",\"system\":\"")), safe_sys), EL_STR("\"")), EL_STR(",\"tools\":")), tools_json), EL_STR(",\"messages\":")), messages), EL_STR("}"));
-    el_val_t raw_resp = http_post_with_headers(api_url, req_body, h);
-    el_val_t is_error = ((str_starts_with(raw_resp, EL_STR("{\"error\"")) || str_starts_with(raw_resp, EL_STR("{\"type\":\"error\""))) || str_contains(raw_resp, EL_STR("authentication_error")));
-    if (is_error) {
-      return el_str_concat(el_str_concat(EL_STR("{\"error\":\"llm unavailable\",\"response\":\"\",\"cgi_id\":\""), cgi_id), EL_STR("\"}"));
-    }
-    el_val_t stop_reason = json_get(raw_resp, EL_STR("stop_reason"));
-    el_val_t content_arr = json_get_raw(raw_resp, EL_STR("content"));
-    el_val_t eff_content = ({ el_val_t _if_result_257 = 0; if (str_eq(content_arr, EL_STR(""))) { _if_result_257 = (EL_STR("[]")); } else { _if_result_257 = (content_arr); } _if_result_257; });
-    el_val_t text_out = EL_STR("");
-    el_val_t has_tool = 0;
-    el_val_t tool_id = EL_STR("");
-    el_val_t tool_name = EL_STR("");
-    el_val_t tool_input = EL_STR("");
-    el_val_t ci = 0;
-    el_val_t c_total = json_array_len(eff_content);
-    while (ci < c_total) {
-      el_val_t block = json_array_get(eff_content, ci);
-      el_val_t btype = json_get(block, EL_STR("type"));
-      text_out = ({ el_val_t _if_result_258 = 0; if (str_eq(btype, EL_STR("text"))) { _if_result_258 = (el_str_concat(text_out, json_get(block, EL_STR("text")))); } else { _if_result_258 = (text_out); } _if_result_258; });
-      el_val_t is_new_tool = (str_eq(btype, EL_STR("tool_use")) && !has_tool);
-      has_tool = ({ el_val_t _if_result_259 = 0; if (is_new_tool) { _if_result_259 = (1); } else { _if_result_259 = (has_tool); } _if_result_259; });
-      tool_id = ({ el_val_t _if_result_260 = 0; if (is_new_tool) { _if_result_260 = (json_get(block, EL_STR("id"))); } else { _if_result_260 = (tool_id); } _if_result_260; });
-      tool_name = ({ el_val_t _if_result_261 = 0; if (is_new_tool) { _if_result_261 = (json_get(block, EL_STR("name"))); } else { _if_result_261 = (tool_name); } _if_result_261; });
-      tool_input = ({ el_val_t _if_result_262 = 0; if (is_new_tool) { _if_result_262 = (json_get_raw(block, EL_STR("input"))); } else { _if_result_262 = (tool_input); } _if_result_262; });
-      ci = (ci + 1);
-    }
-    el_val_t tool_result_raw = ({ el_val_t _if_result_263 = 0; if (has_tool) { _if_result_263 = (dispatch_tool(tool_name, tool_input)); } else { _if_result_263 = (EL_STR("")); } _if_result_263; });
-    el_val_t tool_result = ({ el_val_t _if_result_264 = 0; if ((str_len(tool_result_raw) > 6000)) { _if_result_264 = (el_str_concat(str_slice(tool_result_raw, 0, 6000), EL_STR("...[truncated]"))); } else { _if_result_264 = (tool_result_raw); } _if_result_264; });
-    el_val_t tool_msg = el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"type\":\"tool_result\",\"tool_use_id\":\""), tool_id), EL_STR("\",\"content\":\"")), tool_result), EL_STR("\"}"));
-    el_val_t input_summary = ({ el_val_t _if_result_265 = 0; if (str_eq(tool_name, EL_STR("run_command"))) { _if_result_265 = (json_get(tool_input, EL_STR("command"))); } else { _if_result_265 = (({ el_val_t _if_result_266 = 0; if (str_eq(tool_name, EL_STR("read_file"))) { _if_result_266 = (json_get(tool_input, EL_STR("path"))); } else { _if_result_266 = (({ el_val_t _if_result_267 = 0; if (str_eq(tool_name, EL_STR("write_file"))) { _if_result_267 = (json_get(tool_input, EL_STR("path"))); } else { _if_result_267 = (({ el_val_t _if_result_268 = 0; if (str_eq(tool_name, EL_STR("edit_file"))) { _if_result_268 = (json_get(tool_input, EL_STR("path"))); } else { _if_result_268 = (({ el_val_t _if_result_269 = 0; if (str_eq(tool_name, EL_STR("list_files"))) { _if_result_269 = (json_get(tool_input, EL_STR("path"))); } else { _if_result_269 = (({ el_val_t _if_result_270 = 0; if (str_eq(tool_name, EL_STR("grep"))) { _if_result_270 = (el_str_concat(el_str_concat(json_get(tool_input, EL_STR("pattern")), EL_STR(" in ")), json_get(tool_input, EL_STR("path")))); } else { _if_result_270 = (({ el_val_t _if_result_271 = 0; if (str_eq(tool_name, EL_STR("web_search"))) { _if_result_271 = (json_get(tool_input, EL_STR("query"))); } else { _if_result_271 = (({ el_val_t _if_result_272 = 0; if (str_eq(tool_name, EL_STR("web_get"))) { _if_result_272 = (json_get(tool_input, EL_STR("url"))); } else { _if_result_272 = (({ el_val_t _if_result_273 = 0; if (str_eq(tool_name, EL_STR("search_memory"))) { _if_result_273 = (json_get(tool_input, EL_STR("query"))); } else { _if_result_273 = (EL_STR("")); } _if_result_273; })); } _if_result_272; })); } _if_result_271; })); } _if_result_270; })); } _if_result_269; })); } _if_result_268; })); } _if_result_267; })); } _if_result_266; })); } _if_result_265; });
-    el_val_t safe_input_summary = json_safe(input_summary);
-    el_val_t tool_entry = el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"tool\":\""), tool_name), EL_STR("\",\"input\":\"")), safe_input_summary), EL_STR("\"}"));
-    tools_log = ({ el_val_t _if_result_274 = 0; if (has_tool) { _if_result_274 = (({ el_val_t _if_result_275 = 0; if (str_eq(tools_log, EL_STR(""))) { _if_result_275 = (tool_entry); } else { _if_result_275 = (el_str_concat(el_str_concat(tools_log, EL_STR(",")), tool_entry)); } _if_result_275; })); } else { _if_result_274 = (tools_log); } _if_result_274; });
-    el_val_t is_tool_turn = (str_eq(stop_reason, EL_STR("tool_use")) && has_tool);
-    el_val_t inner = str_slice(messages, 1, (str_len(messages) - 1));
-    messages = ({ el_val_t _if_result_276 = 0; if (is_tool_turn) { _if_result_276 = (el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("["), inner), EL_STR(",{\"role\":\"assistant\",\"content\":")), eff_content), EL_STR("}")), EL_STR(",{\"role\":\"user\",\"content\":[")), tool_msg), EL_STR("]}")), EL_STR("]"))); } else { _if_result_276 = (messages); } _if_result_276; });
-    final_text = ({ el_val_t _if_result_277 = 0; if (!is_tool_turn) { _if_result_277 = (text_out); } else { _if_result_277 = (final_text); } _if_result_277; });
-    keep_going = ({ el_val_t _if_result_278 = 0; if (!is_tool_turn) { _if_result_278 = (0); } else { _if_result_278 = (keep_going); } _if_result_278; });
-    iteration = (iteration + 1);
+  el_val_t session_id = ({ el_val_t _if_result_83 = 0; if (str_eq(room_id, EL_STR(""))) { _if_result_83 = (el_str_concat(EL_STR("dharma:"), next_bridge_id())); } else { _if_result_83 = (el_str_concat(EL_STR("dharma:"), room_id)); } _if_result_83; });
+  el_val_t loop_result = agentic_loop(session_id, model, safe_sys, tools_json, messages, h, EL_STR(""));
+  el_val_t result_error = json_get(loop_result, EL_STR("error"));
+  if (!str_eq(result_error, EL_STR(""))) {
+    return el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"error\":\""), result_error), EL_STR("\",\"response\":\"\",\"cgi_id\":\"")), cgi_id), EL_STR("\"}"));
   }
+  el_val_t is_pending = (str_eq(json_get(loop_result, EL_STR("tool_pending")), EL_STR("true")) || str_starts_with(loop_result, EL_STR("{\"tool_pending\":true")));
+  if (is_pending) {
+    return loop_result;
+  }
+  el_val_t final_text = json_get(loop_result, EL_STR("reply"));
   if (str_eq(final_text, EL_STR(""))) {
     return el_str_concat(el_str_concat(EL_STR("{\"error\":\"no response\",\"response\":\"\",\"cgi_id\":\""), cgi_id), EL_STR("\"}"));
   }
+  el_val_t tools_arr = json_get_raw(loop_result, EL_STR("tools_used"));
+  el_val_t eff_tools = ({ el_val_t _if_result_84 = 0; if (str_eq(tools_arr, EL_STR(""))) { _if_result_84 = (EL_STR("[]")); } else { _if_result_84 = (tools_arr); } _if_result_84; });
   el_val_t safe_text = json_safe(final_text);
-  el_val_t tools_arr = ({ el_val_t _if_result_279 = 0; if (str_eq(tools_log, EL_STR(""))) { _if_result_279 = (EL_STR("[]")); } else { _if_result_279 = (el_str_concat(el_str_concat(EL_STR("["), tools_log), EL_STR("]"))); } _if_result_279; });
-  return el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"response\":\""), safe_text), EL_STR("\",\"cgi_id\":\"")), cgi_id), EL_STR("\",\"tools_used\":")), tools_arr), EL_STR("}"));
+  return el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"response\":\""), safe_text), EL_STR("\",\"cgi_id\":\"")), cgi_id), EL_STR("\",\"tools_used\":")), eff_tools), EL_STR("}"));
   return 0;
 }
 
+
 el_val_t auto_persist(el_val_t req, el_val_t resp) {
   el_val_t message = json_get(req, EL_STR("message"));
   el_val_t reply = json_get(resp, EL_STR("response"));
@@ -28154,6 +28454,7 @@ el_val_t session_auto_title(el_val_t session_id, el_val_t first_message) {
   return 0;
 }
 
+/* === PATCHED: handle_session_approve (2-path: mcp_bridge + legacy) === */
 el_val_t handle_session_approve(el_val_t session_id, el_val_t body) {
   if (str_eq(session_id, EL_STR(""))) {
     return EL_STR("{\"error\":\"session_id is required\"}");
@@ -28166,6 +28467,23 @@ el_val_t handle_session_approve(el_val_t session_id, el_val_t body) {
   if (str_eq(action, EL_STR(""))) {
     return EL_STR("{\"error\":\"action is required (allow|deny|always)\"}");
   }
+  el_val_t eff_action = ({ el_val_t _if_result_135 = 0; if (str_eq(action, EL_STR("always"))) { _if_result_135 = (EL_STR("allow")); } else { _if_result_135 = (action); } _if_result_135; });
+  el_val_t bridge_blob = state_get(el_str_concat(EL_STR("mcp_bridge:"), session_id));
+  if (!str_eq(bridge_blob, EL_STR(""))) {
+    el_val_t always_key = el_str_concat(EL_STR("always_allow_"), session_id);
+    el_val_t approve_tool_name = json_get(body, EL_STR("tool_name"));
+    el_val_t discard_always = ({ el_val_t _if_result_136 = 0; if ((str_eq(action, EL_STR("always")) && !str_eq(approve_tool_name, EL_STR("")))) { el_val_t always_list = state_get(always_key); el_val_t new_always = ({ el_val_t _if_result_137 = 0; if (str_eq(always_list, EL_STR(""))) { _if_result_137 = (approve_tool_name); } else { _if_result_137 = (el_str_concat(el_str_concat(always_list, EL_STR(",")), approve_tool_name)); } _if_result_137; }); (void)(state_set(always_key, new_always)); _if_result_136 = (1); } else { _if_result_136 = (0); } _if_result_136; });
+    if (str_eq(approve_tool_name, EL_STR("")) && str_eq(eff_action, EL_STR("allow"))) {
+      return EL_STR("{\"error\":\"tool_name is required for allow action\"}");
+    }
+    el_val_t client_content = json_get(body, EL_STR("content"));
+    el_val_t use_client_content = !str_eq(client_content, EL_STR(""));
+    el_val_t use_dispatch = (is_builtin_tool(approve_tool_name) && !use_client_content);
+    el_val_t raw_input = json_get_raw(body, EL_STR("tool_input"));
+    el_val_t eff_input = ({ el_val_t _if_result_138 = 0; if (str_eq(raw_input, EL_STR(""))) { _if_result_138 = (EL_STR("{}")); } else { _if_result_138 = (raw_input); } _if_result_138; });
+    el_val_t content = ({ el_val_t _if_result_139 = 0; if (str_eq(eff_action, EL_STR("allow"))) { _if_result_139 = (({ el_val_t _if_result_140 = 0; if (use_client_content) { el_val_t trimmed = ({ el_val_t _if_result_141 = 0; if ((str_len(client_content) > 6000)) { _if_result_141 = (el_str_concat(str_slice(client_content, 0, 6000), EL_STR("...[truncated]"))); } else { _if_result_141 = (client_content); } _if_result_141; }); _if_result_140 = (trimmed); } else { _if_result_140 = (({ el_val_t _if_result_142 = 0; if (use_dispatch) { el_val_t raw = dispatch_tool(approve_tool_name, eff_input); _if_result_142 = (({ el_val_t _if_result_143 = 0; if ((str_len(raw) > 6000)) { _if_result_143 = (el_str_concat(str_slice(raw, 0, 6000), EL_STR("...[truncated]"))); } else { _if_result_143 = (raw); } _if_result_143; })); } else { _if_result_142 = (el_str_concat(el_str_concat(EL_STR("{\"error\":\"client content required for non-builtin tool: "), approve_tool_name), EL_STR("\"}"))); } _if_result_142; })); } _if_result_140; })); } else { _if_result_139 = (EL_STR("{\"error\":\"User denied this tool call\"}")); } _if_result_139; });
+    return agentic_resume(session_id, call_id, content);
+  }
   el_val_t pending_raw = state_get(el_str_concat(EL_STR("pending_tool_"), session_id));
   if (str_eq(pending_raw, EL_STR(""))) {
     return el_str_concat(el_str_concat(EL_STR("{\"error\":\"no pending tool for session\",\"session_id\":\""), session_id), EL_STR("\"}"));
@@ -28176,95 +28494,23 @@ el_val_t handle_session_approve(el_val_t session_id, el_val_t body) {
   }
   el_val_t tool_name = json_get(pending_raw, EL_STR("tool_name"));
   el_val_t tool_input = json_get_raw(pending_raw, EL_STR("tool_input"));
-  el_val_t messages = json_get_raw(pending_raw, EL_STR("messages_so_far"));
   el_val_t model = json_get(pending_raw, EL_STR("model"));
   el_val_t safe_sys = json_get(pending_raw, EL_STR("system"));
   el_val_t always_key = el_str_concat(EL_STR("always_allow_"), session_id);
   el_val_t always_list = state_get(always_key);
-  el_val_t discard_always = ({ el_val_t _if_result_397 = 0; if (str_eq(action, EL_STR("always"))) { el_val_t new_always = ({ el_val_t _if_result_398 = 0; if (str_eq(always_list, EL_STR(""))) { _if_result_398 = (tool_name); } else { _if_result_398 = (el_str_concat(el_str_concat(always_list, EL_STR(",")), tool_name)); } _if_result_398; }); (void)(state_set(always_key, new_always)); _if_result_397 = (1); } else { _if_result_397 = (0); } _if_result_397; });
+  el_val_t discard_always2 = ({ el_val_t _if_result_144 = 0; if (str_eq(action, EL_STR("always"))) { el_val_t new_always = ({ el_val_t _if_result_145 = 0; if (str_eq(always_list, EL_STR(""))) { _if_result_145 = (tool_name); } else { _if_result_145 = (el_str_concat(el_str_concat(always_list, EL_STR(",")), tool_name)); } _if_result_145; }); (void)(state_set(always_key, new_always)); _if_result_144 = (1); } else { _if_result_144 = (0); } _if_result_144; });
   state_set(el_str_concat(EL_STR("pending_tool_"), session_id), EL_STR(""));
-  el_val_t eff_action = ({ el_val_t _if_result_399 = 0; if (str_eq(action, EL_STR("always"))) { _if_result_399 = (EL_STR("allow")); } else { _if_result_399 = (action); } _if_result_399; });
-  el_val_t tool_result = ({ el_val_t _if_result_400 = 0; if (str_eq(eff_action, EL_STR("allow"))) { el_val_t raw = dispatch_tool(tool_name, tool_input); _if_result_400 = (({ el_val_t _if_result_401 = 0; if ((str_len(raw) > 6000)) { _if_result_401 = (el_str_concat(str_slice(raw, 0, 6000), EL_STR("...[truncated]"))); } else { _if_result_401 = (raw); } _if_result_401; })); } else { _if_result_400 = (json_safe(EL_STR("{\"error\":\"User denied this tool call\"}"))); } _if_result_400; });
-  el_val_t tool_msg = el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"type\":\"tool_result\",\"tool_use_id\":\""), call_id), EL_STR("\",\"content\":\"")), tool_result), EL_STR("\"}"));
-  el_val_t inner = str_slice(messages, 1, (str_len(messages) - 1));
-  el_val_t resumed_messages = el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("["), inner), EL_STR(",{\"role\":\"user\",\"content\":[")), tool_msg), EL_STR("]}]"));
-  el_val_t api_key = agentic_api_key();
-  el_val_t tools_json = agentic_tools_literal();
-  el_val_t api_url = EL_STR("https://api.anthropic.com/v1/messages");
-  el_val_t h = el_map_new(0);
-  map_set(h, EL_STR("x-api-key"), api_key);
-  map_set(h, EL_STR("anthropic-version"), EL_STR("2023-06-01"));
-  map_set(h, EL_STR("content-type"), EL_STR("application/json"));
-  el_val_t final_text = EL_STR("");
-  el_val_t tools_log = EL_STR("");
-  el_val_t iteration = 0;
-  el_val_t keep_going = 1;
-  el_val_t cur_messages = resumed_messages;
-  while (keep_going && (iteration < 8)) {
-    el_val_t req_body = el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"model\":\""), model), EL_STR("\"")), EL_STR(",\"max_tokens\":4096")), EL_STR(",\"system\":\"")), safe_sys), EL_STR("\"")), EL_STR(",\"tools\":")), tools_json), EL_STR(",\"messages\":")), cur_messages), EL_STR("}"));
-    el_val_t raw_resp = http_post_with_headers(api_url, req_body, h);
-    el_val_t is_error = ((str_starts_with(raw_resp, EL_STR("{\"error\"")) || str_starts_with(raw_resp, EL_STR("{\"type\":\"error\""))) || str_contains(raw_resp, EL_STR("authentication_error")));
-    if (is_error) {
-      return EL_STR("{\"error\":\"llm unavailable\",\"reply\":\"\"}");
-    }
-    el_val_t stop_reason = json_get(raw_resp, EL_STR("stop_reason"));
-    el_val_t content_arr = json_get_raw(raw_resp, EL_STR("content"));
-    el_val_t eff_content = ({ el_val_t _if_result_402 = 0; if (str_eq(content_arr, EL_STR(""))) { _if_result_402 = (EL_STR("[]")); } else { _if_result_402 = (content_arr); } _if_result_402; });
-    el_val_t text_out = EL_STR("");
-    el_val_t has_tool = 0;
-    el_val_t next_tool_id = EL_STR("");
-    el_val_t next_tool_name = EL_STR("");
-    el_val_t next_tool_input = EL_STR("");
-    el_val_t ci = 0;
-    el_val_t c_total = json_array_len(eff_content);
-    while (ci < c_total) {
-      el_val_t block = json_array_get(eff_content, ci);
-      el_val_t btype = json_get(block, EL_STR("type"));
-      text_out = ({ el_val_t _if_result_403 = 0; if (str_eq(btype, EL_STR("text"))) { _if_result_403 = (el_str_concat(text_out, json_get(block, EL_STR("text")))); } else { _if_result_403 = (text_out); } _if_result_403; });
-      el_val_t is_new_tool = (str_eq(btype, EL_STR("tool_use")) && !has_tool);
-      has_tool = ({ el_val_t _if_result_404 = 0; if (is_new_tool) { _if_result_404 = (1); } else { _if_result_404 = (has_tool); } _if_result_404; });
-      next_tool_id = ({ el_val_t _if_result_405 = 0; if (is_new_tool) { _if_result_405 = (json_get(block, EL_STR("id"))); } else { _if_result_405 = (next_tool_id); } _if_result_405; });
-      next_tool_name = ({ el_val_t _if_result_406 = 0; if (is_new_tool) { _if_result_406 = (json_get(block, EL_STR("name"))); } else { _if_result_406 = (next_tool_name); } _if_result_406; });
-      next_tool_input = ({ el_val_t _if_result_407 = 0; if (is_new_tool) { _if_result_407 = (json_get_raw(block, EL_STR("input"))); } else { _if_result_407 = (next_tool_input); } _if_result_407; });
-      ci = (ci + 1);
-    }
-    el_val_t is_tool_turn = (str_eq(stop_reason, EL_STR("tool_use")) && has_tool);
-    el_val_t inner2 = str_slice(cur_messages, 1, (str_len(cur_messages) - 1));
-    el_val_t always_list2 = state_get(always_key);
-    el_val_t is_always = (str_contains(always_list2, next_tool_name) && !str_eq(next_tool_name, EL_STR("")));
-    el_val_t require_approval = state_get(el_str_concat(EL_STR("session_require_approval_"), session_id));
-    el_val_t needs_pause = ((is_tool_turn && str_eq(require_approval, EL_STR("true"))) && !is_always);
-    el_val_t next_tool_result = ({ el_val_t _if_result_408 = 0; if ((is_tool_turn && !needs_pause)) { el_val_t raw2 = dispatch_tool(next_tool_name, next_tool_input); _if_result_408 = (({ el_val_t _if_result_409 = 0; if ((str_len(raw2) > 6000)) { _if_result_409 = (el_str_concat(str_slice(raw2, 0, 6000), EL_STR("...[truncated]"))); } else { _if_result_409 = (raw2); } _if_result_409; })); } else { _if_result_408 = (EL_STR("")); } _if_result_408; });
-    el_val_t next_tool_msg = el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"type\":\"tool_result\",\"tool_use_id\":\""), next_tool_id), EL_STR("\",\"content\":\"")), next_tool_result), EL_STR("\"}"));
-    el_val_t tool_entry = el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"tool\":\""), next_tool_name), EL_STR("\",\"input\":\"")), json_safe(next_tool_name)), EL_STR("\"}"));
-    tools_log = ({ el_val_t _if_result_410 = 0; if ((is_tool_turn && !needs_pause)) { _if_result_410 = (({ el_val_t _if_result_411 = 0; if (str_eq(tools_log, EL_STR(""))) { _if_result_411 = (tool_entry); } else { _if_result_411 = (el_str_concat(el_str_concat(tools_log, EL_STR(",")), tool_entry)); } _if_result_411; })); } else { _if_result_410 = (tools_log); } _if_result_410; });
-    cur_messages = ({ el_val_t _if_result_412 = 0; if ((is_tool_turn && !needs_pause)) { _if_result_412 = (el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("["), inner2), EL_STR(",{\"role\":\"assistant\",\"content\":")), eff_content), EL_STR("}")), EL_STR(",{\"role\":\"user\",\"content\":[")), next_tool_msg), EL_STR("]}")), EL_STR("]"))); } else { _if_result_412 = (cur_messages); } _if_result_412; });
-    el_val_t discard_pause = ({ el_val_t _if_result_413 = 0; if (needs_pause) { el_val_t safe_sys2 = json_safe(safe_sys); el_val_t msgs_with_assistant = el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("["), inner2), EL_STR(",{\"role\":\"assistant\",\"content\":")), eff_content), EL_STR("}]")); el_val_t pending = el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"call_id\":\""), next_tool_id), EL_STR("\"")), EL_STR(",\"tool_name\":\"")), next_tool_name), EL_STR("\"")), EL_STR(",\"tool_input\":")), next_tool_input), EL_STR(",\"messages_so_far\":")), msgs_with_assistant), EL_STR(",\"model\":\"")), model), EL_STR("\"")), EL_STR(",\"system\":\"")), safe_sys2), EL_STR("\"}")); (void)(state_set(el_str_concat(EL_STR("pending_tool_"), session_id), pending)); _if_result_413 = (1); } else { _if_result_413 = (0); } _if_result_413; });
-    final_text = ({ el_val_t _if_result_414 = 0; if (!is_tool_turn) { _if_result_414 = (text_out); } else { _if_result_414 = (final_text); } _if_result_414; });
-    keep_going = ({ el_val_t _if_result_415 = 0; if (!is_tool_turn) { _if_result_415 = (0); } else { _if_result_415 = (({ el_val_t _if_result_416 = 0; if (needs_pause) { _if_result_416 = (0); } else { _if_result_416 = (keep_going); } _if_result_416; })); } _if_result_415; });
-    iteration = (iteration + 1);
-  }
-  el_val_t new_pending = state_get(el_str_concat(EL_STR("pending_tool_"), session_id));
-  if (!str_eq(new_pending, EL_STR(""))) {
-    el_val_t np_tool_name = json_get(new_pending, EL_STR("tool_name"));
-    el_val_t np_call_id = json_get(new_pending, EL_STR("call_id"));
-    el_val_t np_tool_input = json_get_raw(new_pending, EL_STR("tool_input"));
-    return el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"status\":\"tool_pending\""), EL_STR(",\"call_id\":\"")), np_call_id), EL_STR("\"")), EL_STR(",\"tool_name\":\"")), np_tool_name), EL_STR("\"")), EL_STR(",\"tool_input\":")), np_tool_input), EL_STR(",\"session_id\":\"")), session_id), EL_STR("\"}"));
-  }
-  if (str_eq(final_text, EL_STR(""))) {
-    return EL_STR("{\"error\":\"no response after approval\",\"reply\":\"\"}");
-  }
-  el_val_t hist = session_hist_load(session_id);
-  el_val_t updated_hist = hist_append(hist, EL_STR("assistant"), final_text);
-  el_val_t final_hist = ({ el_val_t _if_result_417 = 0; if ((json_array_len(updated_hist) > 20)) { _if_result_417 = (hist_trim(updated_hist)); } else { _if_result_417 = (updated_hist); } _if_result_417; });
-  session_hist_save(session_id, final_hist);
-  session_update_meta_timestamp(session_id);
-  el_val_t safe_text = json_safe(final_text);
-  el_val_t tools_arr = ({ el_val_t _if_result_418 = 0; if (str_eq(tools_log, EL_STR(""))) { _if_result_418 = (EL_STR("[]")); } else { _if_result_418 = (el_str_concat(el_str_concat(EL_STR("["), tools_log), EL_STR("]"))); } _if_result_418; });
-  return el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"reply\":\""), safe_text), EL_STR("\",\"model\":\"")), model), EL_STR("\",\"agentic\":true,\"tools_used\":")), tools_arr), EL_STR(",\"session_id\":\"")), session_id), EL_STR("\"}"));
+  el_val_t tool_result = ({ el_val_t _if_result_146 = 0; if (str_eq(eff_action, EL_STR("allow"))) { el_val_t raw = dispatch_tool(tool_name, tool_input); _if_result_146 = (({ el_val_t _if_result_147 = 0; if ((str_len(raw) > 6000)) { _if_result_147 = (el_str_concat(str_slice(raw, 0, 6000), EL_STR("...[truncated]"))); } else { _if_result_147 = (raw); } _if_result_147; })); } else { _if_result_146 = (EL_STR("{\"error\":\"User denied this tool call\"}")); } _if_result_146; });
+  el_val_t legacy_messages = json_get_raw(pending_raw, EL_STR("messages_so_far"));
+  el_val_t stored_variant = json_get(pending_raw, EL_STR("tools_variant"));
+  el_val_t tools_json = ({ el_val_t _if_result_148 = 0; if (str_eq(stored_variant, EL_STR("web"))) { _if_result_148 = (agentic_tools_with_web()); } else { _if_result_148 = (({ el_val_t _if_result_149 = 0; if (str_eq(stored_variant, EL_STR("all"))) { _if_result_149 = (agentic_tools_all()); } else { _if_result_149 = (agentic_tools_literal()); } _if_result_149; })); } _if_result_148; });
+  el_val_t blob = el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"model\":\""), json_safe(model)), EL_STR("\"")), EL_STR(",\"safe_sys\":\"")), json_safe(safe_sys)), EL_STR("\"")), EL_STR(",\"tools_json\":\"")), json_safe(tools_json)), EL_STR("\"")), EL_STR(",\"messages\":\"")), json_safe(legacy_messages)), EL_STR("\"")), EL_STR(",\"tools_log\":\"\"")), EL_STR(",\"tool_use_id\":\"")), json_safe(call_id)), EL_STR("\"}"));
+  state_set(el_str_concat(EL_STR("mcp_bridge:"), session_id), blob);
+  return agentic_resume(session_id, call_id, tool_result);
   return 0;
 }
 
+
 el_val_t strip_query(el_val_t path) {
   el_val_t q = str_index_of(path, EL_STR("?"));
   if (q < 0) {
@@ -28915,7 +29161,13 @@ int main(int _argc, char** _argv) {
   state_set(EL_STR("soul_engram_api_key"), engram_api_key_raw);
   state_set(EL_STR("soul.running"), EL_STR("true"));
   is_genesis = str_eq(soul_cgi_id, EL_STR("ntn-genesis"));
-  if (is_genesis) {
+  guard_disk = ({ el_val_t _if_result_25 = 0; if (str_eq(engram_url_raw, EL_STR(""))) { _if_result_25 = (fs_read(snapshot)); } else { _if_result_25 = (EL_STR("")); } _if_result_25; });
+  guard_disk_len = str_len(guard_disk);
+  safe_to_seed = !((guard_disk_len > 200000) && (engram_node_count() < (guard_disk_len / 16000)));
+  if (is_genesis && !safe_to_seed) {
+    println(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("[soul] GUARD: loaded "), int_to_str(engram_node_count())), EL_STR(" nodes but snapshot file is ")), int_to_str(guard_disk_len)), EL_STR(" bytes \xe2\x80\x94 refusing to seed/save over a real graph")));
+  }
+  if (is_genesis && safe_to_seed) {
     el_val_t edge_count_now = engram_edge_count();
     if (edge_count_now < 100) {
       init_soul_edges();
@@ -28923,10 +29175,12 @@ int main(int _argc, char** _argv) {
     } else {
       println(el_str_concat(el_str_concat(EL_STR("[soul] edges already present ("), int_to_str(edge_count_now)), EL_STR(") - skipping init")));
     }
+    /* PR #24: idempotent canonical-self bridge — runs regardless of edge count */
+    ensure_self_canonical_bridge();
     state_set(EL_STR("soul_snapshot_path"), snapshot);
     engram_save(snapshot);
   }
-  if (is_genesis) {
+  if (is_genesis && safe_to_seed) {
     el_val_t snap = state_get(EL_STR("soul_snapshot_path"));
     if (!str_eq(snap, EL_STR(""))) {
       engram_save(snap);

elp-input.elh

@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// auto-generated by elc --emit-header - do not edit
 extern fn elp_extract_topic(msg: String) -> String
 extern fn elp_detect_predicate(msg: String) -> String
 extern fn elp_parse(msg: String) -> String

memory.elh

@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// auto-generated by elc --emit-header - do not edit
 extern fn tier_working() -> String
 extern fn tier_episodic() -> String
 extern fn tier_canonical() -> String

neuron-api.el

@@ -87,6 +87,21 @@ fn api_or_empty(s: String) -> String {
     return "[]"
 }
 
+// api_persisted — read-back-after-write guard against hallucinated saves.
+// After a write builtin returns an id, confirm the node is actually queryable
+// via engram_get_node_json(id) (returns "" or "null" when missing). Returns
+// true only when the node is genuinely persisted.
+fn api_persisted(id: String) -> Bool {
+    if str_eq(id, "") { return false }
+    let node: String = engram_get_node_json(id)
+    return !str_eq(node, "") && !str_eq(node, "null")
+}
+
+// api_not_persisted — standard error for a write that did not read back.
+fn api_not_persisted(id: String) -> String {
+    return "{\"ok\":false,\"error\":\"write_not_persisted\",\"id\":\"" + id + "\"}"
+}
+
 // ── Session ───────────────────────────────────────────────────────────────────
 
 // handle_api_begin_session — full context bootstrap.
@@ -143,12 +158,101 @@ fn handle_api_remember(body: String) -> String {
     let id: String = engram_node_full(content, "Memory", "memory:remembered",
         el_from_float(sal), el_from_float(sal), el_from_float(0.9),
         "Episodic", final_tags)
+    if !api_persisted(id) { return api_not_persisted(id) }
     return "{\"id\":\"" + id + "\",\"ok\":true}"
 }
 
+// handle_api_node_create — generic typed-node create (BacklogItem, Artifact, ...).
+// Mirrors handle_api_remember but lets the caller choose node_type/label/tier so the
+// UI can create non-Memory nodes. Read-back verified against hallucinated saves.
+fn handle_api_node_create(body: String) -> String {
+    let content: String = json_get(body, "content")
+    if str_eq(content, "") { return api_err("content is required") }
+    let nt_raw: String = json_get(body, "node_type")
+    let node_type: String = if str_eq(nt_raw, "") { "Memory" } else { nt_raw }
+    let label_raw: String = json_get(body, "label")
+    let label: String = if str_eq(label_raw, "") { "node:created" } else { label_raw }
+    let tier_raw: String = json_get(body, "tier")
+    let tier: String = if str_eq(tier_raw, "") { "Episodic" } else { tier_raw }
+    let tags_raw: String = json_get(body, "tags")
+    let tags: String = if str_eq(tags_raw, "") { "[\"" + node_type + "\"]" } else { tags_raw }
+    let importance: String = json_get(body, "importance")
+    let sal: Float = if str_eq(importance, "critical") { 0.95 } else {
+        if str_eq(importance, "high") { 0.75 } else {
+            if str_eq(importance, "low") { 0.25 } else { 0.5 }
+        }
+    }
+    let id: String = engram_node_full(content, node_type, label,
+        el_from_float(sal), el_from_float(sal), el_from_float(0.9),
+        tier, tags)
+    if !api_persisted(id) { return api_not_persisted(id) }
+    return "{\"id\":\"" + id + "\",\"ok\":true}"
+}
+
+// handle_api_node_delete — remove a node by id (engram_forget) and verify it is gone.
+// Backs /api/neuron/node/delete and the /api/neuron/memory/delete alias the UI calls.
+fn handle_api_node_delete(body: String) -> String {
+    let id: String = json_get(body, "id")
+    if str_eq(id, "") { return api_err("id is required") }
+    // engram_forget removes the node + its incident edges from the live graph. We do
+    // NOT read-back-verify here: engram_get_node_json can return a STALE hit for a just-
+    // removed id (the id->index map is not rebuilt on forget), which would produce a
+    // false "delete_failed" even though the node is gone. The graph endpoints
+    // (/api/graph/nodes) correctly reflect the removal, which is the source of truth.
+    engram_forget(id)
+    return "{\"ok\":true,\"id\":\"" + id + "\"}"
+}
+
+// handle_api_node_update — update a node's content/fields. There is no in-place
+// engram update builtin, so this recreates the node with merged fields and then
+// forgets the old one (only after the new node reads back). The id changes; the
+// response returns the new id and the replaced id so callers can re-point.
+fn handle_api_node_update(body: String) -> String {
+    let id: String = json_get(body, "id")
+    if str_eq(id, "") { return api_err("id is required") }
+    if !api_persisted(id) {
+        return "{\"ok\":false,\"error\":\"not_found\",\"id\":\"" + id + "\"}"
+    }
+    let old: String = engram_get_node_json(id)
+    let body_content: String = json_get(body, "content")
+    let content: String = if str_eq(body_content, "") { json_get(old, "content") } else { body_content }
+    let body_nt: String = json_get(body, "node_type")
+    let old_nt: String = json_get(old, "node_type")
+    let node_type: String = if !str_eq(body_nt, "") { body_nt } else {
+        if !str_eq(old_nt, "") { old_nt } else { "Memory" }
+    }
+    let body_label: String = json_get(body, "label")
+    let old_label: String = json_get(old, "label")
+    let label: String = if !str_eq(body_label, "") { body_label } else {
+        if !str_eq(old_label, "") { old_label } else { "node:updated" }
+    }
+    let body_tier: String = json_get(body, "tier")
+    let old_tier: String = json_get(old, "tier")
+    let tier: String = if !str_eq(body_tier, "") { body_tier } else {
+        if !str_eq(old_tier, "") { old_tier } else { "Episodic" }
+    }
+    let body_tags: String = json_get(body, "tags")
+    let tags: String = if str_eq(body_tags, "") { "[\"" + node_type + "\"]" } else { body_tags }
+    let new_id: String = engram_node_full(content, node_type, label,
+        el_from_float(0.5), el_from_float(0.5), el_from_float(0.8),
+        tier, tags)
+    if !api_persisted(new_id) { return api_not_persisted(new_id) }
+    engram_forget(id)
+    return "{\"id\":\"" + new_id + "\",\"replaced\":\"" + id + "\",\"ok\":true}"
+}
+
 // handle_api_recall — search or activate memory by query.
 fn handle_api_recall(method: String, path: String, body: String) -> String {
-    let q: String = if str_eq(method, "GET") { api_query_param(path, "query") } else { json_get(body, "query") }
+    // Accept the query from the URL ?query= / ?q= params, or, when those are
+    // empty (e.g. a POST with a JSON body), from the body fields "query"/"q".
+    let url_q: String = if str_eq(api_query_param(path, "query"), "") {
+        api_query_param(path, "q")
+    } else { api_query_param(path, "query") }
+    let body_query: String = json_get(body, "query")
+    let body_q: String = json_get(body, "q")
+    let q: String = if !str_eq(url_q, "") { url_q } else {
+        if !str_eq(body_query, "") { body_query } else { body_q }
+    }
     let chain: String = json_get(body, "chain_name")
     let limit: Int = api_query_int(path, "limit", 0)
     let limit = if limit == 0 { json_get_int(body, "limit") } else { limit }
@@ -165,7 +269,14 @@ fn handle_api_recall(method: String, path: String, body: String) -> String {
 
 // handle_api_search_knowledge — search with query escaping + activate fallback.
 fn handle_api_search_knowledge(method: String, path: String, body: String) -> String {
-    let q: String = if str_eq(method, "GET") { api_query_param(path, "q") } else { json_get(body, "query") }
+    // Accept the query from the URL ?q= param, or, when that is empty (e.g. a
+    // POST with a JSON body), from the body fields "query" then "q".
+    let url_q: String = api_query_param(path, "q")
+    let body_query: String = json_get(body, "query")
+    let body_q: String = json_get(body, "q")
+    let q: String = if !str_eq(url_q, "") { url_q } else {
+        if !str_eq(body_query, "") { body_query } else { body_q }
+    }
     let limit: Int = api_query_int(path, "limit", 0)
     let limit = if limit == 0 { json_get_int(body, "limit") } else { limit }
     let limit = if limit == 0 { 10 } else { limit }
@@ -195,6 +306,7 @@ fn handle_api_capture_knowledge(body: String) -> String {
     let id: String = engram_node_full(full, "Knowledge", "knowledge:captured",
         el_from_float(0.85), el_from_float(0.8), el_from_float(0.9),
         "Episodic", tags)
+    if !api_persisted(id) { return api_not_persisted(id) }
     return "{\"id\":\"" + id + "\",\"ok\":true}"
 }
 
@@ -208,7 +320,8 @@ fn handle_api_evolve_knowledge(body: String) -> String {
     let new_id: String = engram_node_full(content, "Knowledge", "knowledge:evolved",
         el_from_float(0.75), el_from_float(0.75), el_from_float(0.9),
         "Episodic", tags)
-    if !str_eq(prior_id, "") && !str_eq(new_id, "") {
+    if !api_persisted(new_id) { return api_not_persisted(new_id) }
+    if !str_eq(prior_id, "") {
         engram_connect(new_id, prior_id, el_from_float(0.9), "supersedes")
     }
     return "{\"id\":\"" + new_id + "\",\"supersedes\":\"" + prior_id + "\",\"ok\":true}"
@@ -228,7 +341,7 @@ fn handle_api_promote_knowledge(body: String) -> String {
     let new_id: String = engram_node_full(content, "Knowledge", "knowledge:canonical",
         el_from_float(0.9), el_from_float(0.9), el_from_float(1.0),
         "Canonical", tags)
-    if str_eq(new_id, "") { return api_err("failed to create canonical node") }
+    if !api_persisted(new_id) { return api_not_persisted(new_id) }
     engram_connect(new_id, prior_id, el_from_float(0.95), "supersedes")
     return "{\"ok\":true,\"new_id\":\"" + new_id + "\",\"supersedes\":\"" + prior_id + "\"}"
 }
@@ -255,6 +368,7 @@ fn handle_api_define_process(body: String) -> String {
     let id: String = engram_node_full(content, "Process", label,
         el_from_float(0.8), el_from_float(0.8), el_from_float(0.9),
         "Canonical", tags)
+    if !api_persisted(id) { return api_not_persisted(id) }
     return "{\"id\":\"" + id + "\",\"ok\":true}"
 }
 

routes.el

@@ -219,7 +219,9 @@ fn connectd_get(suffix: String) -> String {
 // so arbitrary JSON cannot reach the shell as a command-line argument.
 fn connectd_post(suffix: String, body: String) -> String {
     let eff: String = if str_eq(body, "") { "{}" } else { body }
-    let tmp: String = "/tmp/neuron-connectors-req.json"
+    // Unique temp path per call — prevents collision if concurrency is ever added
+    // or if two soul instances run on the same machine (latent correctness hazard).
+    let tmp: String = "/tmp/neuron-connectors-req-" + int_to_str(time_now()) + ".json"
     fs_write(tmp, eff)
     let out: String = exec_capture("curl -s --max-time 20 -X POST http://127.0.0.1:7771" + suffix + " -H 'Content-Type: application/json' -d @" + tmp)
     if str_eq(out, "") {
@@ -339,6 +341,9 @@ fn handle_request(method: String, path: String, body: String) -> String {
         if str_eq(clean, "/api/neuron/ctx") {
             return handle_api_compile_ctx("")
         }
+        if str_eq(clean, "/api/safety-contact") {
+            return handle_safety_contact_get()
+        }
         if str_starts_with(clean, "/api/neuron/knowledge/search") {
             return handle_api_search_knowledge(method, path, body)
         }
@@ -511,6 +516,18 @@ fn handle_request(method: String, path: String, body: String) -> String {
         if str_eq(clean, "/api/neuron/memory") {
             return handle_api_remember(body)
         }
+        if str_eq(clean, "/api/safety-contact") {
+            return handle_safety_contact_post(body)
+        }
+        if str_eq(clean, "/api/neuron/node/create") {
+            return handle_api_node_create(body)
+        }
+        if str_eq(clean, "/api/neuron/node/update") {
+            return handle_api_node_update(body)
+        }
+        if str_eq(clean, "/api/neuron/node/delete") {
+            return handle_api_node_delete(body)
+        }
         if str_eq(clean, "/api/neuron/memory/evolve") {
             return handle_api_evolve_memory(body)
         }

routes.elh

@@ -1,5 +1,6 @@
-// auto-generated by elc --emit-header — do not edit
+// auto-generated by elc --emit-header - do not edit
 extern fn strip_query(path: String) -> String
+extern fn flag_true(body: String, key: String) -> Bool
 extern fn err_404(path: String) -> String
 extern fn err_405(method: String, path: String) -> String
 extern fn route_health() -> String

safety.el

@@ -207,3 +207,165 @@ fn safety_log_bell(level: String, reason: String, input_summary: String) -> Stri
     )
     return ""
 }
+
+//   abuse     — danger from another person. Emergency services / 988 ONLY. The
+//               safety contact on file is NEVER notified — they may be the abuser.
+//               This routing is non-configurable by design.
+//
+// Evaluation is keyword-only (zero added latency) and stays on device. Triggers are
+// logged locally as InternalStateEvents and never transmitted.
+
+// ── Phrase lists (ported verbatim from bell-detector.ts) ───────────────────────
+
+fn safety_self_harm_phrases() -> String {
+    return "[\"kill myself\",\"killing myself\",\"want to die\",\"want to be dead\",\"going to end my life\",\"end my life\",\"take my life\",\"taking my life\",\"suicide\",\"suicidal\",\"can't go on\",\"cannot go on\",\"i have a knife\",\"i have a gun\",\"i have pills\",\"took pills\",\"took too many\",\"overdose\",\"overdosing\",\"self harm\",\"self-harm\",\"cutting myself\",\"hurt myself\",\"hurting myself\",\"no reason to live\",\"not worth living\",\"better off dead\",\"better off without me\"]"
+}
+
+fn safety_abuse_phrases() -> String {
+    return "[\"someone is hurting me\",\"someone's hurting me\",\"someone hurt me\",\"he hit me\",\"she hit me\",\"they hit me\",\"he hurt me\",\"she hurt me\",\"being abused\",\"being hurt by\",\"i am being abused\",\"i'm being abused\",\"i am being hurt\",\"i'm being hurt\",\"domestic violence\",\"my partner hurt\",\"my partner hit\",\"my husband hurt\",\"my wife hurt\",\"my boyfriend hurt\",\"my girlfriend hurt\",\"my parent hurt\",\"my father hurt\",\"my mother hurt\",\"my dad hurt\",\"my mom hurt\",\"afraid of him\",\"afraid of her\",\"afraid to go home\",\"scared of him\",\"scared of her\",\"he threatened me\",\"she threatened me\",\"threatened to hurt me\",\"threatened to kill me\",\"going to hurt me\",\"going to kill me\",\"help me he\",\"help me she\",\"help me they\"]"
+}
+
+// General danger phrases that don't fit a bucket cleanly. Detected as hard; they
+// fall through to self_harm routing (the person is the primary concern).
+fn safety_general_hard_phrases() -> String {
+    return "[\"going to kill\",\"going to hurt\",\"hurting me\",\"being hurt\"]"
+}
+
+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\",\"highest structure\",\"tallest building\",\"tallest structure\",\"highest building\",\"bridge near me\",\"overpass near\",\"rooftop near\"]"
+}
+
+// ── Matching helpers (single loops only — el escapes while-body mutation via
+//    top-level let rebinds; nested loops would not advance) ────────────────────
+
+fn safety_normalize(message: String) -> String {
+    let lower: String = str_to_lower(message)
+    // Normalise the common curly apostrophe to ASCII so "can't" / "i'm" match.
+    return str_replace(lower, "’", "'")
+}
+
+fn safety_any_match(text: String, phrases_json: String) -> Bool {
+    let n: Int = json_array_len(phrases_json)
+    let i: Int = 0
+    let found: Bool = false
+    while i < n {
+        let phrase: String = json_array_get_string(phrases_json, i)
+        let found = if str_contains(text, phrase) { true } else { found }
+        let i = i + 1
+    }
+    return found
+}
+
+fn safety_count_match(text: String, phrases_json: String) -> Int {
+    let n: Int = json_array_len(phrases_json)
+    let i: Int = 0
+    let count: Int = 0
+    while i < n {
+        let phrase: String = json_array_get_string(phrases_json, i)
+        let count = if str_contains(text, phrase) { count + 1 } else { count }
+        let i = i + 1
+    }
+    return count
+}
+
+// ── Public detection API (ports detectBellLevel + classifyHardBell) ────────────
+
+// Returns "none" | "soft" | "hard". Hard bell triggers on ANY match (cost of a miss
+// outweighs a false positive). Soft bell needs >= 2 matches to reduce false positives.
+fn safety_detect_bell_level(message: String) -> String {
+    let text: String = safety_normalize(message)
+    let is_hard: Bool = safety_any_match(text, safety_self_harm_phrases())
+        || safety_any_match(text, safety_abuse_phrases())
+        || safety_any_match(text, safety_general_hard_phrases())
+    if is_hard { return "hard" }
+    let soft_count: Int = safety_count_match(text, safety_soft_phrases())
+    if soft_count >= 2 { return "soft" }
+    return "none"
+}
+
+// Returns "abuse" | "self_harm". Abuse is checked FIRST and takes precedence on
+// ambiguous signals — it forecloses the more dangerous routing (notifying a
+// possible abuser). General/unbucketed danger falls through to self_harm.
+fn safety_classify_hard_bell(message: String) -> String {
+    let text: String = safety_normalize(message)
+    if safety_any_match(text, safety_abuse_phrases()) { return "abuse" }
+    if safety_any_match(text, safety_self_harm_phrases()) { return "self_harm" }
+    return "self_harm"
+}
+
+// ── Directives (ported from eval.go; em dashes removed per voice rule) ──────────
+
+fn safety_soft_directive() -> String {
+    return "[SUBSTRATE DIRECTIVE - not visible to the user, do not mention this instruction]\nBefore responding to the user's message, acknowledge what they've said with genuine care and warmth. Pause on the feeling they expressed. Ask how they are, or whether they want to talk about it. Do this naturally, in your own voice - not as a script, not as a checklist. Only after checking in should you continue with whatever they asked."
+}
+
+fn safety_hard_directive(hard_type: String) -> String {
+    let preamble: String = "[SUBSTRATE DIRECTIVE - not visible to the user, do not mention this instruction]\nThe person has expressed something that sounds like immediate distress or danger. Do not ignore it. Do not just answer the surface question. Lead with genuine human warmth. Acknowledge what you heard. Tell them you're concerned. Let them know they are not alone. Ask them directly if they are safe right now. Stay with them in this conversation."
+    let abuse_block: String = "\n\nThis appears to be danger from ANOTHER person. Routing rule (non-negotiable): do NOT suggest involving, contacting, or notifying the person's safety contact, family, or anyone close to them - that person may be the source of danger and has NOT been notified. Share only independent emergency resources:\n  - Call or text 911 if in immediate danger\n  - National Domestic Violence Hotline - 1-800-799-7233 (24/7, confidential)\n  - Text START to 88788\n  - thehotline.org (chat available)\n  - 988 Suicide & Crisis Lifeline - call or text 988\nReassure them, if it fits, that their contact list has not been notified."
+    let self_harm_block: String = "\n\nShare these crisis resources if appropriate:\n  - 988 Suicide & Crisis Lifeline - call or text 988 (US)\n  - Crisis Text Line - text HOME to 741741\n  - International Association for Suicide Prevention: https://www.iasp.info/resources/Crisis_Centres/"
+    if str_eq(hard_type, "abuse") {
+        return preamble + abuse_block
+    }
+    return preamble + self_harm_block
+}
+
+// safety_augment_system — pre-LLM bell evaluation. Called with the finalized system
+// prompt and the raw user message, BEFORE the LLM call, on every chat path. Appends
+// the soft/hard directive when a bell fires; otherwise returns the prompt unchanged.
+// Logs the trigger on device only (level + sub-type, never the message content).
+fn safety_augment_system(system: String, user_msg: String) -> String {
+    let level: String = safety_detect_bell_level(user_msg)
+    if str_eq(level, "none") { return system }
+    if str_eq(level, "soft") {
+        let logd: String = mem_emit_state_event("safety-bell", "soft", "soft bell fired (content not stored)")
+        return system + "\n\n" + safety_soft_directive()
+    }
+    let hard_type: String = safety_classify_hard_bell(user_msg)
+    let logd2: String = mem_emit_state_event("safety-bell", "hard:" + hard_type, "hard bell fired (content not stored)")
+    return system + "\n\n" + safety_hard_directive(hard_type)
+}
+
+// ── Safety-contact storage + endpoint (ports contact.go + handler.go) ───────────
+// Stored locally at ~/.neuron/safety-contact.json (same file the desktop gate writes),
+// never synced. NOTE: encryption-at-rest is a flagged follow-up (ties to key custody);
+// today the file is plaintext JSON, matching the current desktop behavior.
+
+fn safety_contact_path() -> String {
+    return env("HOME") + "/.neuron/safety-contact.json"
+}
+
+// GET /api/safety-contact -> {"configured":false} or {"configured":true,"contact":{...}}
+fn handle_safety_contact_get() -> String {
+    let raw: String = fs_read(safety_contact_path())
+    if str_eq(raw, "") { return "{\"configured\":false}" }
+    return "{\"configured\":true,\"contact\":" + raw + "}"
+}
+
+// POST /api/safety-contact — validate + persist. Mirrors handler.go: crisis line is
+// always acceptable and auto-fills its fields; otherwise a name is required. The
+// contact can be replaced but never cleared to empty (the gate enforces presence).
+fn handle_safety_contact_post(body: String) -> String {
+    let is_crisis: Bool = json_get_bool(body, "is_crisis_line")
+    let name_in: String = json_get(body, "name")
+    if !is_crisis {
+        if str_eq(name_in, "") { return "{\"ok\":false,\"error\":\"name is required\"}" }
+    }
+    let name: String = if is_crisis { "Crisis Line" } else { name_in }
+    let method: String = if is_crisis { "crisis-line" } else { json_get(body, "contact_method") }
+    let value: String = if is_crisis { "988" } else { json_get(body, "contact_value") }
+    let rel: String = if is_crisis { "crisis-support" } else { json_get(body, "relationship") }
+    let crisis_str: String = if is_crisis { "true" } else { "false" }
+    let now: String = time_format(time_now(), "%Y-%m-%dT%H:%M:%SZ")
+    let contact_json: String = "{\"name\":\"" + json_safe(name) + "\""
+        + ",\"contact_method\":\"" + json_safe(method) + "\""
+        + ",\"contact_value\":\"" + json_safe(value) + "\""
+        + ",\"relationship\":\"" + json_safe(rel) + "\""
+        + ",\"confirmed\":true"
+        + ",\"is_crisis_line\":" + crisis_str
+        + ",\"set_at\":\"" + now + "\"}"
+    fs_write(safety_contact_path(), contact_json)
+    // Read-back verify the write actually persisted.
+    let check: String = fs_read(safety_contact_path())
+    if str_eq(check, "") { return "{\"ok\":false,\"error\":\"write_failed\"}" }
+    return "{\"configured\":true,\"contact\":" + contact_json + ",\"ok\":true}"
+}

safety.elh

@@ -6,3 +6,18 @@ extern fn safety_threat_score(input: String, history: String) -> Int
 extern fn safety_screen(input: String, history: String) -> String
 extern fn safety_validate(output: String, action: String) -> String
 extern fn safety_log_bell(level: String, reason: String, input_summary: String) -> String
+extern fn safety_self_harm_phrases() -> String
+extern fn safety_abuse_phrases() -> String
+extern fn safety_general_hard_phrases() -> String
+extern fn safety_soft_phrases() -> String
+extern fn safety_normalize(message: String) -> String
+extern fn safety_any_match(text: String, phrases_json: String) -> Bool
+extern fn safety_count_match(text: String, phrases_json: String) -> Int
+extern fn safety_detect_bell_level(message: String) -> String
+extern fn safety_classify_hard_bell(message: String) -> String
+extern fn safety_soft_directive() -> String
+extern fn safety_hard_directive(hard_type: String) -> String
+extern fn safety_augment_system(system: String, user_msg: String) -> String
+extern fn safety_contact_path() -> String
+extern fn handle_safety_contact_get() -> String
+extern fn handle_safety_contact_post(body: String) -> String

soul.el

@@ -5,6 +5,7 @@ import "stewardship.el"
 import "imprint.el"
 import "awareness.el"
 import "chat.el"
+import "safety.el"
 import "studio.el"
 import "elp-input.el"
 import "routes.el"
@@ -94,6 +95,24 @@ fn init_soul_edges() -> Void {
     engram_connect(val_hope, val_trust, el_from_float(0.7), "co-value")
 }
 
+// ensure_self_canonical_bridge — link the public self anchor (the graph API's
+// traversal_root, kn-efeb4a5b, which carries only incidental tag edges) to the
+// curated self node (015644f5, where the real identity / value / co-value edges
+// live). Without this, public self-traversal (name=self / neuron) reaches tags
+// instead of the curated identity. Idempotent: connects only if the edge is
+// missing, so it is safe to run every boot — including on an already-populated
+// graph where init_soul_edges() is skipped by the <100-edge gate.
+fn ensure_self_canonical_bridge() -> Void {
+    let pub_self: String = "kn-efeb4a5b-5aff-4759-8a97-7233099be6ee"
+    let curated_self: String = "015644f5-8194-4af0-800d-dd4a0cd71396"
+    let nbrs: String = engram_neighbors_json(pub_self, 1, "out")
+    if !str_contains(nbrs, curated_self) {
+        engram_connect(pub_self, curated_self, el_from_float(0.95), "canonical-self")
+        engram_connect(curated_self, pub_self, el_from_float(0.95), "canonical-self")
+        println("[soul] canonical-self bridge built: kn-efeb4a5b <-> 015644f5")
+    }
+}
+
 // load_identity_context — pull key identity nodes from engram into working state.
 // Called at boot after engram_load. These nodes contain values, intellectual-dna,
 // memory-philosophy — the graph-stored self that chat.el can include in prompts.
@@ -239,7 +258,7 @@ fn emit_session_start_event() -> Void {
 // L0 (core) → L1 (safety screen) → L2a (continuity + behavioral profiling) → L2b (mission alignment) → L3 (imprint) → L1 (safety validate)
 // Internal cognition (heartbeat, proactive, memory ops) bypasses layers — use one_cycle directly.
 fn layered_cycle(raw_input: String) -> String {
-    let history: String = state_get("conversation_history")
+    let history: String = state_get("conv_history")
     let session_id: String = state_get("current_session_id")
 
     // L1 in: safety screen
@@ -362,7 +381,31 @@ state_set("soul_engram_api_key", engram_api_key_raw)
 state_set("soul.running", "true")
 
 let is_genesis: Bool = str_eq(soul_cgi_id, "ntn-genesis")
-if is_genesis {
+
+// GUARD (2026-06-15): never let genesis seed over a real graph. If the in-memory load is
+// sparse but the on-disk snapshot file is large, the load FAILED — seeding+saving now would
+// clobber the user's real memory (this is exactly how the 06-14 clobber happened). Read the
+// on-disk file (local mode only) and refuse the destructive seed+save when it looks populated.
+//
+// HTTP-engram guard (2026-06-17): when ENGRAM_URL is set the HTTP Engram owns persistence —
+// the soul must NEVER write to the local snapshot regardless of node counts. safe_to_seed is
+// unconditionally false in HTTP mode (not the persistence owner).
+let guard_disk: String = if str_eq(engram_url_raw, "") { fs_read(snapshot) } else { "" }
+let guard_disk_len: Int = str_len(guard_disk)
+// Ratio guard (2026-06-15 fix): refuse to seed/save whenever the in-memory load is FAR smaller than
+// the on-disk file implies (~16KB/node) — catches partial loads of ANY size, not just <50. The old
+// <50 threshold let a 63-node identity-only load clobber a 47MB/5000-node graph.
+// Multiplication form (2026-06-17): node_count * 16000 < disk_len avoids floor-division truncation
+// (e.g., 250KB / 16000 = 15.6, floors to 15 — a 15-node graph wrongly passes the old guard).
+// HTTP-engram guard: when using_http_engram the soul is not the persistence owner; never seed.
+let safe_to_seed: Bool = !using_http_engram && !(guard_disk_len > 200000 && engram_node_count() * 16000 < guard_disk_len)
+if is_genesis && !safe_to_seed {
+    println("[soul] GUARD: loaded " + int_to_str(engram_node_count())
+        + " nodes but snapshot file is " + int_to_str(guard_disk_len)
+        + " bytes — refusing to seed/save over a real graph")
+}
+
+if is_genesis && safe_to_seed {
     // Only build identity edges if the engram is fresh (< 100 edges).
     // init_soul_edges() is not idempotent — calling it on every restart
     // stacks duplicate co-value/identity edges into the snapshot.
@@ -373,6 +416,9 @@ if is_genesis {
     } else {
         println("[soul] edges already present (" + int_to_str(edge_count_now) + ") - skipping init")
     }
+    // Canonical-self bridge is idempotent — run it regardless of edge count so an
+    // already-populated graph still gets the public->curated self link.
+    ensure_self_canonical_bridge()
     // Genesis saves to its local snapshot file (it manages its own Engram).
     state_set("soul_snapshot_path", snapshot)
     engram_save(snapshot)
@@ -380,7 +426,7 @@ if is_genesis {
 
 // Take a pre-serve snapshot for genesis instances — captures all boot-time graph changes
 // (identity context loading, boot counter, session-start event) before entering the serve loop.
-if is_genesis {
+if is_genesis && safe_to_seed {
     let snap: String = state_get("soul_snapshot_path")
     if !str_eq(snap, "") {
         engram_save(snap)

soul.elh

@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// auto-generated by elc --emit-header - do not edit
 extern fn init_soul_edges() -> Void
 extern fn load_identity_context() -> Void
 extern fn seed_persona_from_env() -> Void

studio.elh

@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// auto-generated by elc --emit-header - do not edit
 extern fn auth_headers(tok: String) -> Map
 extern fn axon_get(path: String) -> String
 extern fn axon_post(path: String, body: String) -> String

tests/test_api_define_process.el

@@ -0,0 +1,109 @@
+// ── tests/test_api_define_process.el ─────────────────────────────────────────
+//
+// Test the handle_api_define_process read-back fix (neuron-api.el).
+//
+// Bug: handle_api_define_process was the only write handler that did NOT call
+// api_persisted() after the write, returning {"id":"...","ok":true} even when
+// the engram write failed (hallucinated save).
+//
+// Fix: added `if !api_persisted(id) { return api_not_persisted(id) }` before
+// the return, consistent with all sibling handlers (remember, capture_knowledge,
+// evolve_knowledge, promote_knowledge, node_create).
+//
+// Tests:
+//   1. define_process returns ok==true and id resolves via engram_get_node_json.
+//   2. Missing content returns the standard error.
+//   3. Unnamed process uses default label and still persists.
+// ──────────────────────────────────────────────────────────────────────────────
+
+import "../neuron-api.el"
+
+let pass_count: Int = 0
+let fail_count: Int = 0
+
+fn assert_eq(label: String, got: String, expected: String) -> Void {
+    if str_eq(got, expected) {
+        let pass_count = pass_count + 1
+        println("  PASS: " + label)
+    } else {
+        let fail_count = fail_count + 1
+        println("  FAIL: " + label)
+        println("    got:      " + got)
+        println("    expected: " + expected)
+    }
+}
+
+fn assert_not_eq(label: String, got: String, not_want: String) -> Void {
+    if str_eq(got, not_want) {
+        let fail_count = fail_count + 1
+        println("  FAIL: " + label + " (got: " + got + ", should differ)")
+    } else {
+        let pass_count = pass_count + 1
+        println("  PASS: " + label)
+    }
+}
+
+fn assert_contains(label: String, haystack: String, needle: String) -> Void {
+    if str_contains(haystack, needle) {
+        let pass_count = pass_count + 1
+        println("  PASS: " + label)
+    } else {
+        let fail_count = fail_count + 1
+        println("  FAIL: " + label)
+        println("    missing '" + needle + "' in: " + haystack)
+    }
+}
+
+// ── Section 1: define_process — happy path with read-back ────────────────────
+
+println("")
+println("1. handle_api_define_process — write then verify id resolves")
+
+let proc_body: String = "{\"content\":\"Test process: run step A, then step B, then step C.\",\"name\":\"test-process-guard\"}"
+let proc_result: String = handle_api_define_process(proc_body)
+
+let proc_ok: String = json_get(proc_result, "ok")
+let proc_id: String = json_get(proc_result, "id")
+
+assert_eq("define_process -> ok==true", proc_ok, "true")
+assert_not_eq("define_process -> id is non-empty", proc_id, "")
+
+let node_json: String = engram_get_node_json(proc_id)
+let node_status: String = if str_eq(node_json, "") { "empty" } else {
+    if str_eq(node_json, "null") { "null" } else { "ok" }
+}
+assert_eq("define_process -> node read-back resolves (not empty/null)", node_status, "ok")
+assert_contains("define_process -> node content contains process text", node_json, "Test process")
+
+// ── Section 2: define_process — missing content returns error ────────────────
+
+println("")
+println("2. handle_api_define_process — missing content returns error")
+
+let no_content_body: String = "{\"name\":\"nameless\"}"
+let no_content_result: String = handle_api_define_process(no_content_body)
+let no_content_error: String = json_get(no_content_result, "error")
+assert_eq("missing content -> error is 'content is required'", no_content_error, "content is required")
+
+// ── Section 3: define_process — unnamed process gets default label ────────────
+
+println("")
+println("3. handle_api_define_process — unnamed process writes and read-back succeeds")
+
+let unnamed_body: String = "{\"content\":\"Unnamed test process for coverage.\"}"
+let unnamed_result: String = handle_api_define_process(unnamed_body)
+let unnamed_ok: String = json_get(unnamed_result, "ok")
+let unnamed_id: String = json_get(unnamed_result, "id")
+assert_eq("unnamed process -> ok==true", unnamed_ok, "true")
+assert_not_eq("unnamed process -> id non-empty", unnamed_id, "")
+
+let unnamed_node: String = engram_get_node_json(unnamed_id)
+let unnamed_status: String = if str_eq(unnamed_node, "") { "empty" } else {
+    if str_eq(unnamed_node, "null") { "null" } else { "ok" }
+}
+assert_eq("unnamed process -> node read-back ok", unnamed_status, "ok")
+
+// ── Summary ───────────────────────────────────────────────────────────────────
+
+println("")
+println("api_define_process tests: " + int_to_str(pass_count) + " passed, " + int_to_str(fail_count) + " failed")

tests/test_bell_safety.el

@@ -0,0 +1,266 @@
+// ── tests/test_bell_safety.el ─────────────────────────────────────────────────
+//
+// Unit tests for the Hard Bell safety layer added in feat/connectors-soul.
+// Covers the public API exposed by safety.el:
+//   - safety_detect_bell_level:  'none' / 'soft' / 'hard'
+//   - safety_classify_hard_bell: 'self_harm' / 'abuse'
+//   - safety_normalize:          smart-quote -> ASCII apostrophe normalisation
+//   - safety_augment_system:     system prompt passthrough / augmentation
+//   - handle_safety_contact_post: validation + read-back
+//
+// El test convention: mutable pass_count / fail_count globals, assert_* helpers,
+// println for each result.  Mirrors the style in existing safety tests.
+// ──────────────────────────────────────────────────────────────────────────────
+
+import "../safety.el"
+
+let pass_count: Int = 0
+let fail_count: Int = 0
+
+fn assert_eq(label: String, got: String, expected: String) -> Void {
+    if str_eq(got, expected) {
+        let pass_count = pass_count + 1
+        println("  PASS: " + label)
+    } else {
+        let fail_count = fail_count + 1
+        println("  FAIL: " + label)
+        println("    got:      " + got)
+        println("    expected: " + expected)
+    }
+}
+
+fn assert_contains(label: String, haystack: String, needle: String) -> Void {
+    if str_contains(haystack, needle) {
+        let pass_count = pass_count + 1
+        println("  PASS: " + label)
+    } else {
+        let fail_count = fail_count + 1
+        println("  FAIL: " + label)
+        println("    missing '" + needle + "' in: " + haystack)
+    }
+}
+
+fn assert_not_contains(label: String, haystack: String, needle: String) -> Void {
+    if str_contains(haystack, needle) {
+        let fail_count = fail_count + 1
+        println("  FAIL: " + label)
+        println("    unexpected '" + needle + "' found in: " + haystack)
+    } else {
+        let pass_count = pass_count + 1
+        println("  PASS: " + label)
+    }
+}
+
+// ── Section 1: safety_detect_bell_level — 'none' ─────────────────────────────
+
+println("")
+println("1. safety_detect_bell_level — neutral input -> 'none'")
+
+let level_neutral: String = safety_detect_bell_level("What time is the meeting tomorrow?")
+assert_eq("neutral question -> none", level_neutral, "none")
+
+let level_positive: String = safety_detect_bell_level("I love sunny days")
+assert_eq("positive statement -> none", level_positive, "none")
+
+let level_empty: String = safety_detect_bell_level("")
+assert_eq("empty string -> none", level_empty, "none")
+
+// ── Section 2: safety_detect_bell_level — single soft phrase stays 'none' ────
+
+println("")
+println("2. safety_detect_bell_level — single soft phrase does not reach 'soft' (threshold=2)")
+
+let level_one_soft: String = safety_detect_bell_level("I have been feeling stressed lately")
+assert_eq("single soft phrase alone -> none", level_one_soft, "none")
+
+// ── Section 3: safety_detect_bell_level — 'soft' with two+ soft phrases ──────
+
+println("")
+println("3. safety_detect_bell_level — two soft phrases -> 'soft'")
+
+let level_two_soft: String = safety_detect_bell_level("I am feeling overwhelmed and really anxious about everything")
+assert_eq("two soft phrases -> soft", level_two_soft, "soft")
+
+let level_multi_soft: String = safety_detect_bell_level("So depressed and hopeless, nothing matters anymore")
+assert_eq("multiple soft phrases -> soft", level_multi_soft, "soft")
+
+// ── Section 4: safety_detect_bell_level — 'hard' (self_harm phrases) ─────────
+
+println("")
+println("4. safety_detect_bell_level — self_harm phrases -> 'hard'")
+
+let level_kill_myself: String = safety_detect_bell_level("I want to kill myself")
+assert_eq("'kill myself' -> hard", level_kill_myself, "hard")
+
+let level_suicide: String = safety_detect_bell_level("I have been suicidal for weeks")
+assert_eq("'suicidal' -> hard", level_suicide, "hard")
+
+let level_want_die: String = safety_detect_bell_level("I want to die, nothing is worth it")
+assert_eq("'want to die' -> hard", level_want_die, "hard")
+
+let level_overdose: String = safety_detect_bell_level("I am thinking about an overdose")
+assert_eq("'overdose' -> hard", level_overdose, "hard")
+
+let level_self_harm: String = safety_detect_bell_level("My history of self-harm is back")
+assert_eq("'self-harm' -> hard", level_self_harm, "hard")
+
+let level_no_reason: String = safety_detect_bell_level("There is no reason to live")
+assert_eq("'no reason to live' -> hard", level_no_reason, "hard")
+
+// ── Section 5: safety_detect_bell_level — 'hard' (abuse phrases) ─────────────
+
+println("")
+println("5. safety_detect_bell_level — abuse phrases -> 'hard'")
+
+let level_he_hit: String = safety_detect_bell_level("he hit me last night")
+assert_eq("'he hit me' -> hard", level_he_hit, "hard")
+
+let level_dv: String = safety_detect_bell_level("I am experiencing domestic violence")
+assert_eq("'domestic violence' -> hard", level_dv, "hard")
+
+let level_abused: String = safety_detect_bell_level("I am being abused")
+assert_eq("'being abused' -> hard", level_abused, "hard")
+
+// ── Section 6: safety_detect_bell_level — 'hard' (general hard phrases) ──────
+
+println("")
+println("6. safety_detect_bell_level — general hard phrases -> 'hard'")
+
+let level_hurting_me: String = safety_detect_bell_level("someone is hurting me right now")
+assert_eq("'hurting me' -> hard", level_hurting_me, "hard")
+
+let level_being_hurt: String = safety_detect_bell_level("I am being hurt and need help")
+assert_eq("'being hurt' -> hard", level_being_hurt, "hard")
+
+// ── Section 7: safety_classify_hard_bell — abuse -> 'abuse' ──────────────────
+
+println("")
+println("7. safety_classify_hard_bell — abuse phrases route to 'abuse'")
+
+let class_he_hit: String = safety_classify_hard_bell("he hit me yesterday")
+assert_eq("'he hit me' classifies as abuse", class_he_hit, "abuse")
+
+let class_dv: String = safety_classify_hard_bell("domestic violence in my home")
+assert_eq("'domestic violence' classifies as abuse", class_dv, "abuse")
+
+let class_abused: String = safety_classify_hard_bell("I'm being abused by my partner")
+assert_eq("'being abused' classifies as abuse", class_abused, "abuse")
+
+// ── Section 8: safety_classify_hard_bell — self_harm phrases ─────────────────
+
+println("")
+println("8. safety_classify_hard_bell — self_harm phrases route to 'self_harm'")
+
+let class_kill: String = safety_classify_hard_bell("I want to kill myself")
+assert_eq("'kill myself' classifies as self_harm", class_kill, "self_harm")
+
+let class_suicide: String = safety_classify_hard_bell("I am suicidal")
+assert_eq("'suicidal' classifies as self_harm", class_suicide, "self_harm")
+
+let class_overdose: String = safety_classify_hard_bell("took too many pills")
+assert_eq("'took too many' classifies as self_harm", class_overdose, "self_harm")
+
+// ── Section 9: safety_classify_hard_bell — general -> 'self_harm' ────────────
+
+println("")
+println("9. safety_classify_hard_bell — general hard phrases fall through to 'self_harm'")
+
+let class_going_kill: String = safety_classify_hard_bell("going to kill everything around me")
+assert_eq("general hard phrase falls through to self_harm", class_going_kill, "self_harm")
+
+// ── Section 10: safety_normalize — curly apostrophe normalisation ─────────────
+
+println("")
+println("10. safety_normalize — curly apostrophe normalisation")
+
+// U+2019 RIGHT SINGLE QUOTATION MARK (UTF-8: \xe2\x80\x99) must become ASCII '
+let smart_msg: String = "I can" + "\xe2\x80\x99" + "t go on anymore"
+let normalized: String = safety_normalize(smart_msg)
+assert_contains("smart-quote normalized to ASCII apostrophe", normalized, "can't go on")
+
+// After normalisation, detect_bell_level must fire 'hard' on the smart-quote variant
+let level_smart: String = safety_detect_bell_level(smart_msg)
+assert_eq("smart-quote 'can't go on' -> hard (after normalize)", level_smart, "hard")
+
+// ── Section 11: safety_augment_system — passthrough on neutral ───────────────
+
+println("")
+println("11. safety_augment_system — neutral input returns system unchanged")
+
+let base_sys: String = "You are a helpful assistant."
+let aug_neutral: String = safety_augment_system(base_sys, "What is the weather?")
+assert_eq("neutral message -> system unchanged", aug_neutral, base_sys)
+
+// ── Section 12: safety_augment_system — soft bell injects directive ──────────
+
+println("")
+println("12. safety_augment_system — soft bell injects soft directive")
+
+let aug_soft: String = safety_augment_system(base_sys, "Feeling so overwhelmed and completely anxious")
+assert_contains("soft augment -> contains original system", aug_soft, base_sys)
+assert_contains("soft augment -> contains SUBSTRATE DIRECTIVE", aug_soft, "SUBSTRATE DIRECTIVE")
+assert_contains("soft augment -> contains soft care text", aug_soft, "genuine care")
+
+// ── Section 13: safety_augment_system — hard self_harm injects 988 ───────────
+
+println("")
+println("13. safety_augment_system — hard self_harm injects crisis resources with 988")
+
+let aug_hard: String = safety_augment_system(base_sys, "I want to kill myself tonight")
+assert_contains("hard self_harm -> contains SUBSTRATE DIRECTIVE", aug_hard, "SUBSTRATE DIRECTIVE")
+assert_contains("hard self_harm -> includes 988 crisis line", aug_hard, "988")
+assert_not_contains("hard self_harm -> no DV hotline (wrong routing)", aug_hard, "1-800-799-7233")
+
+// ── Section 14: safety_augment_system — hard abuse routes to abuse directive ──
+
+println("")
+println("14. safety_augment_system — hard abuse injects abuse-specific directive")
+
+let aug_abuse: String = safety_augment_system(base_sys, "he hit me and I am afraid of him")
+assert_contains("hard abuse -> DV hotline present", aug_abuse, "1-800-799-7233")
+assert_contains("hard abuse -> mentions not notifying contact", aug_abuse, "safety contact")
+
+// ── Section 15: handle_safety_contact_post — validation ───────────────────────
+
+println("")
+println("15. handle_safety_contact_post — non-crisis without name returns error")
+
+let no_name_body: String = "{\"is_crisis_line\":false,\"contact_method\":\"phone\",\"contact_value\":\"555-1234\",\"relationship\":\"friend\"}"
+let no_name_result: String = handle_safety_contact_post(no_name_body)
+let no_name_ok: String = json_get(no_name_result, "ok")
+let no_name_err: String = json_get(no_name_result, "error")
+assert_eq("no name -> ok==false", no_name_ok, "false")
+assert_eq("no name -> error is 'name is required'", no_name_err, "name is required")
+
+// ── Section 16: handle_safety_contact_post — write then read back ──────────────
+
+println("")
+println("16. handle_safety_contact_post — write then read back verifies persistence")
+
+let contact_body: String = "{\"is_crisis_line\":false,\"name\":\"Test Contact\",\"contact_method\":\"phone\",\"contact_value\":\"555-9876\",\"relationship\":\"sibling\"}"
+let write_result: String = handle_safety_contact_post(contact_body)
+let write_ok: String = json_get(write_result, "ok")
+assert_eq("contact write -> ok==true", write_ok, "true")
+assert_contains("contact write -> result has configured", write_result, "\"configured\"")
+assert_contains("contact write -> result has name", write_result, "Test Contact")
+
+let read_result: String = handle_safety_contact_get()
+assert_eq("contact read-back -> configured==true", json_get(read_result, "configured"), "true")
+assert_contains("contact read-back -> name matches", read_result, "Test Contact")
+
+// ── Section 17: handle_safety_contact_post — crisis line auto-fills ───────────
+
+println("")
+println("17. handle_safety_contact_post — crisis line auto-fills name and value")
+
+let crisis_body: String = "{\"is_crisis_line\":true}"
+let crisis_result: String = handle_safety_contact_post(crisis_body)
+let crisis_ok: String = json_get(crisis_result, "ok")
+assert_eq("crisis line write -> ok==true", crisis_ok, "true")
+assert_contains("crisis line -> name is Crisis Line", crisis_result, "Crisis Line")
+assert_contains("crisis line -> value is 988", crisis_result, "988")
+
+// ── Summary ───────────────────────────────────────────────────────────────────
+
+println("")
+println("bell_safety tests: " + int_to_str(pass_count) + " passed, " + int_to_str(fail_count) + " failed")

tests/test_soul_guard.el

@@ -0,0 +1,124 @@
+// ── tests/test_soul_guard.el ──────────────────────────────────────────────────
+//
+// Logic tests for the genesis guard in soul.el (feat/connectors-soul).
+//
+// The guard is top-level imperative boot code. This file tests the predicate
+// logic as pure functions to verify the conditions exhaustively:
+//
+//   safe_to_seed = !using_http_engram &&
+//                  !(guard_disk_len > 200000 && loaded_nodes * 16000 < guard_disk_len)
+//
+// Scenarios:
+//   - Boundary: 199,999 bytes + sparse -> safe_to_seed == true
+//   - Boundary: 200,001 bytes + sparse -> safe_to_seed == false
+//   - Ratio:    47MB + 63 nodes -> false (the 2026-06-14 clobber scenario)
+//   - HTTP mode -> false unconditionally
+//   - Multiplication form vs old division form near 250KB boundary
+// ──────────────────────────────────────────────────────────────────────────────
+
+let pass_count: Int = 0
+let fail_count: Int = 0
+
+fn assert_eq_bool(label: String, got: Bool, expected: Bool) -> Void {
+    let got_s: String = if got { "true" } else { "false" }
+    let exp_s: String = if expected { "true" } else { "false" }
+    if str_eq(got_s, exp_s) {
+        let pass_count = pass_count + 1
+        println("  PASS: " + label)
+    } else {
+        let fail_count = fail_count + 1
+        println("  FAIL: " + label)
+        println("    got:      " + got_s)
+        println("    expected: " + exp_s)
+    }
+}
+
+// guard_predicate — mirrors the safe_to_seed expression in soul.el exactly.
+fn guard_predicate(using_http: Bool, disk_len: Int, loaded_nodes: Int) -> Bool {
+    if using_http { return false }
+    let ratio_block: Bool = disk_len > 200000 && loaded_nodes * 16000 < disk_len
+    return !ratio_block
+}
+
+// ── Section 1: 200KB boundary ─────────────────────────────────────────────────
+
+println("")
+println("1. guard boundary — 199,999 bytes + sparse load -> safe_to_seed true")
+
+let safe_below: Bool = guard_predicate(false, 199999, 1)
+assert_eq_bool("199,999 bytes + 1 node -> safe", safe_below, true)
+
+let safe_below_zero: Bool = guard_predicate(false, 199999, 0)
+assert_eq_bool("199,999 bytes + 0 nodes -> safe (below 200KB threshold)", safe_below_zero, true)
+
+println("")
+println("2. guard boundary — 200,001 bytes + sparse load -> safe_to_seed false")
+
+let unsafe_above: Bool = guard_predicate(false, 200001, 1)
+assert_eq_bool("200,001 bytes + 1 node -> unsafe", unsafe_above, false)
+
+let unsafe_zero: Bool = guard_predicate(false, 200001, 0)
+assert_eq_bool("200,001 bytes + 0 nodes -> unsafe", unsafe_zero, false)
+
+// ── Section 2: ratio guard — 47MB + 63 nodes ─────────────────────────────────
+
+println("")
+println("3. guard ratio — 47MB + 63 nodes (the 2026-06-14 clobber scenario)")
+
+let clobber_blocked: Bool = guard_predicate(false, 47000000, 63)
+assert_eq_bool("47MB + 63 nodes -> unsafe (clobber blocked)", clobber_blocked, false)
+
+// 47MB / 16000 = 2937.5 -> need >= 2938 nodes for safe
+let clobber_safe: Bool = guard_predicate(false, 47000000, 2938)
+assert_eq_bool("47MB + 2938 nodes -> safe (load correct)", clobber_safe, true)
+
+let boundary_blocked: Bool = guard_predicate(false, 47000000, 2937)
+assert_eq_bool("47MB + 2937 nodes -> unsafe (just below ratio)", boundary_blocked, false)
+
+// ── Section 3: HTTP-engram mode — always false ────────────────────────────────
+
+println("")
+println("4. guard HTTP mode — always false regardless of disk/node counts")
+
+let http_zero: Bool = guard_predicate(true, 0, 0)
+assert_eq_bool("HTTP mode + 0/0 -> unsafe", http_zero, false)
+
+let http_small: Bool = guard_predicate(true, 1000, 100)
+assert_eq_bool("HTTP mode + small snapshot -> unsafe", http_small, false)
+
+let http_large: Bool = guard_predicate(true, 47000000, 2938)
+assert_eq_bool("HTTP mode + large/fully-loaded -> unsafe", http_large, false)
+
+// ── Section 4: normal local mode — small/fresh snapshots ─────────────────────
+
+println("")
+println("5. guard normal local mode — small/fresh snapshots")
+
+let fresh_genesis: Bool = guard_predicate(false, 0, 0)
+assert_eq_bool("fresh genesis (0 bytes, 0 nodes) -> safe", fresh_genesis, true)
+
+let small_snapshot: Bool = guard_predicate(false, 50000, 5)
+assert_eq_bool("50KB + 5 nodes -> safe (below 200KB threshold)", small_snapshot, true)
+
+// ── Section 5: multiplication vs division — 250KB boundary ───────────────────
+
+println("")
+println("6. guard multiplication form — avoids floor-division truncation at 250KB")
+
+// OLD (division): 250000 / 16000 = 15 (floors 15.625). 15 < 15 is false -> wrongly safe.
+// NEW (multiplication): 15 * 16000 = 240000 < 250000 -> correctly unsafe.
+let div_boundary: Bool = guard_predicate(false, 250000, 15)
+assert_eq_bool("250,000 bytes + 15 nodes -> unsafe (multiplication form)", div_boundary, false)
+
+// With 16 nodes: 16 * 16000 = 256000 > 250000 -> safe.
+let div_just_enough: Bool = guard_predicate(false, 250000, 16)
+assert_eq_bool("250,000 bytes + 16 nodes -> safe", div_just_enough, true)
+
+// Exact equality: disk_len == node_count * 16000 -> not sparse -> safe.
+let exact_match: Bool = guard_predicate(false, 32000, 2)
+assert_eq_bool("exact ratio (32000 bytes, 2 nodes: 2*16000=32000) -> safe", exact_match, true)
+
+// ── Summary ───────────────────────────────────────────────────────────────────
+
+println("")
+println("soul_guard tests: " + int_to_str(pass_count) + " passed, " + int_to_str(fail_count) + " failed")