fix(mcp-wrapper): declare real input schemas so tool args actually bite

The cognitive-graph and write tools advertised an empty inputSchema
({"properties":{}}), so MCP clients never sent entity_id/depth/query/
from_id/node_id etc. Graph reads fell back to the full neighborhood
(480-775KB, over transport limits) and write tools (forget, linkEntities,
evolveMemory) had no way to target a node.

- Declare per-tool JSON-Schemas matching the params each soul handler
  already accepts (76 of 87 tools; 11 are genuinely param-less).
- Read + forward the declared args: inspectGraph now honors depth (was
  reading only legacy max_depth), compact (default on), snip, k;
  traverseGraph accepts entity_id and defaults compact on so a depth-2
  walk stays bounded; retrieveKnowledge forwards depth/snip/k.
- compact_flag() reads the raw JSON token so an integer 0 / false / "0"
  opts out correctly (json_get_string could not see an integer and
  silently forced compact back on).

Builds on PR #149's compact projection; keeps the relevance-ranked
bound on by default for graph neighborhoods.

.gitea/workflows/ci.yaml

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

.gitea/workflows/deploy-gke.yaml

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

.gitignore

@@ -0,0 +1,11 @@
+# Compiled binaries
+dist/neuron
+dist/neuron.backup-*
+dist/*.backup-*
+
+# Build artifacts
+*.o
+*.a
+
+# macOS
+.DS_Store

awareness.elh

@@ -7,6 +7,7 @@ extern fn elapsed_ms() -> Int
 extern fn elapsed_human() -> String
 extern fn embed_ok() -> Int
 extern fn emit_heartbeat() -> Void
+extern fn auto_term_try_slot(slot_type: String, slot_lbl: String) -> Void
 extern fn proactive_curiosity() -> Bool
 extern fn pulse_count() -> Int
 extern fn pulse_inc() -> Int

chat.elh

@@ -1,38 +1,71 @@
-// 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
-extern fn llm_call_grok(model: String, system: String, message: String) -> String
-extern fn llm_call_gemini(model: String, system: String, message: String) -> String
-extern fn build_identity_from_graph() -> String
+extern fn engram_numeric_valid(s: String) -> Bool
+extern fn parse_float_x100(s: String) -> Int
+extern fn engram_score_node(node_json: String) -> Int
+extern fn engram_render_node(node_json: String) -> String
+extern fn engram_render_nodes(nodes_json: String) -> String
+extern fn engram_dedup_nodes(nodes_json: String) -> String
+extern fn engram_compile_ranked(nodes_json: String, max_nodes: Int) -> String
+extern fn engram_split_topics(message: String) -> String
+extern fn engram_extract_entities(message: String) -> String
+extern fn engram_detect_recall_intent(message: String) -> Bool
+extern fn engram_is_continuation(message: String, hist_len: Int) -> Bool
+extern fn engram_compile_multi(topic: String) -> String
+extern fn engram_nodes_merge(a: String, b: String) -> String
+extern fn id_in_seen(node_id: String, seen: String) -> Bool
+extern fn add_to_seen(seen: String, node_id: String) -> String
+extern fn engram_extract_ids(nodes_json: String) -> String
 extern fn engram_compile(intent: String) -> String
+extern fn distill_transcript(transcript: String) -> String
 extern fn json_safe(s: String) -> String
-extern fn build_system_prompt(ctx: String) -> String
+extern fn current_engine_note(model: String) -> String
+extern fn bounded_persona_floor() -> String
+extern fn build_system_prompt(ctx: String, chat_mode: Bool) -> String
 extern fn hist_append(hist: String, role: String, content: String) -> String
 extern fn hist_trim(hist: String) -> String
+extern fn hist_trim_with_bell_guard(hist: String) -> String
 extern fn clean_llm_response(s: String) -> String
 extern fn conv_history_persist(hist: String) -> Void
 extern fn conv_history_load() -> String
+extern fn session_preload_bullets(nodes: String, max_bullets: Int, snip_len: Int) -> String
+extern fn affective_context_prefix() -> String
 extern fn handle_chat(body: String) -> String
 extern fn handle_see(body: String) -> String
 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 llm_base_url() -> String
+extern fn llm_wire_format() -> String
+extern fn json_escape(s: String) -> String
+extern fn openai_chat_complete(model: String, base_url: String, api_key: String, safe_sys: String, messages_json: String) -> String
 extern fn agentic_tools_literal() -> String
 extern fn agentic_tools_with_web() -> String
+extern fn connector_tools_json() -> String
+extern fn agentic_tools_all() -> String
+extern fn call_mcp_bridge(tool_name: String, tool_input: String) -> String
+extern fn tool_auto_approved(tool_name: String) -> Bool
+extern fn call_neuron_mcp(tool_name: String, args: String) -> String
+extern fn agent_workspace_root() -> String
+extern fn path_within_root(path: String, root: String) -> Bool
+extern fn resolve_in_root(path: String, root: String) -> String
+extern fn run_command_is_readonly(cmd: String) -> Bool
+extern fn cmd_abs_escape_at(cmd: String, root: String, needle: String) -> Bool
+extern fn run_command_guard(cmd: String, root: String) -> String
+extern fn classify_tool_risk(tool_name: String, tool_input: String) -> 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 is_builtin_tool(tool_name: String) -> Bool
+extern fn next_bridge_id() -> String
+extern fn handle_chat_plan(body: String) -> String
 extern fn handle_chat_agentic(body: String) -> String
-extern fn handle_session_approve(session_id: String, body: String) -> String
+extern fn agentic_loop(session_id: String, model: String, safe_sys: String, tools_json: String, messages_in: String, h: Map, tools_log_in: String) -> String
+extern fn bridge_save(session_id: String, model: String, safe_sys: String, tools_json: String, messages: String, tools_log: String, tool_use_id: String) -> Bool
+extern fn agentic_resume(session_id: String, tool_use_id: String, content: String) -> String
+extern fn handle_tool_result(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
+extern fn session_summary_write(summary_text: String) -> String
+extern fn session_summary_write_dated(summary_text: String, label: String) -> String
+extern fn session_summary_autogenerate(hist: String) -> String
 extern fn auto_persist(req: String, resp: String) -> Void
 extern fn strengthen_chat_nodes(activation_nodes: String) -> Void

council/README.md

@@ -0,0 +1,123 @@
+# Neuron Council Service
+
+Anti-confabulation layer for the Neuron soul. Before a claim enters long-term memory, the council convenes: three independent LLMs vote on whether the claim is plausible, uncertain, or a confabulation. The aggregate vote produces a confidence score and tags that downstream storage can act on.
+
+## Running the service
+
+```bash
+# Foreground
+python3 council_service.py --port 7771
+
+# Background (managed by LaunchAgent on macOS)
+launchctl load ~/Library/LaunchAgents/ai.neuron.council.plist
+launchctl unload ~/Library/LaunchAgents/ai.neuron.council.plist
+```
+
+Logs: `~/.neuron/logs/council.log`
+
+## API
+
+### `POST /api/neuron/council/verify`
+
+```json
+// Request
+{ "claim": "...", "context": "..." }
+
+// Response
+{
+  "id": "550e8400-e29b-41d4-a716-446655440000",
+  "claim": "...",
+  "confidence": 0.85,
+  "council_votes": ["plausible", "plausible", "plausible"],
+  "summary": "3/3 council members agree this is plausible.",
+  "tags": ["verified"],
+  "latency_ms": 1420
+}
+```
+
+### `GET /healthz`
+
+Returns `{"status": "ok"}` when the service is up.
+
+## Confidence thresholds and tag meanings
+
+| Votes plausible | Confidence | Tags |
+|---|---|---|
+| 3/3 | 0.85 | `verified` |
+| 2/3 | 0.65 | `council-split` |
+| 1/3 or 0/3 | 0.30 | `unverified`, `council-flagged` |
+| Ollama down | 0.50 | `council-unavailable` |
+
+Recommended storage policy:
+- `confidence >= 0.65` → store normally
+- `0.30 <= confidence < 0.65` → store with `council-split` tag for later review
+- `council-flagged` → store in a quarantine bucket or reject entirely
+- `council-unavailable` → store normally (fail-open); council will re-evaluate later
+
+## How to call from soul (.el)
+
+The soul is implemented in Neuron's Emacs Lisp-like `.el` language. Add a pre-storage hook in the memory capture path:
+
+```elisp
+;; In memory.el or safety.el — pre-storage council check
+(defun council-verify (claim context)
+  "Call the council service. Returns a plist with :confidence and :tags."
+  (let* ((url "http://localhost:7771/api/neuron/council/verify")
+         (body (json-encode `((claim . ,claim) (context . ,context))))
+         (resp (neuron-http-post url body))
+         (data (json-decode resp)))
+    data))
+
+;; In the capture handler — wire it in before (engram-write ...)
+(defun capture-memory-with-council (claim context &rest store-args)
+  (let* ((verdict (council-verify claim context))
+         (confidence (plist-get verdict :confidence))
+         (tags (plist-get verdict :tags)))
+    (when (>= confidence 0.30)  ; only reject hard confabulations if you want
+      (apply #'engram-write
+             (append store-args
+                     (list :council-confidence confidence
+                           :council-tags tags))))))
+```
+
+The exact hook point depends on where `engram-write` (or equivalent) is called in `memory.el`. Search for the write call and wrap it with `capture-memory-with-council`.
+
+## Future soul.c patch point
+
+If the soul is ever rewritten in C or another compiled language, the integration point is:
+
+```c
+// Before inserting a memory node into the engram database:
+CouncilResult result = council_verify(claim, context);
+if (result.confidence < COUNCIL_REJECT_THRESHOLD) {
+    log_warn("Council flagged claim as confabulation (conf=%.2f): %s",
+             result.confidence, claim);
+    return MEMORY_REJECTED;
+}
+memory_node.council_confidence = result.confidence;
+memory_node.council_tags = result.tags;
+engram_insert(memory_node);
+```
+
+## Council members
+
+The council is currently three models:
+- `neuron:latest` — the primary Neuron model
+- `dolphin3:8b` — uncensored general-purpose model for independent perspective
+- `neuron-ft:latest` — fine-tuned Neuron variant
+
+Each member votes independently with a 10-second timeout. If a member times out, their vote counts as "uncertain". If Ollama is entirely unreachable, the service returns `council-unavailable` immediately (fail-open: confidence 0.5, no rejection).
+
+## Example curl
+
+```bash
+# Should get high confidence (true fact)
+curl -s http://localhost:7771/api/neuron/council/verify -X POST \
+  -H 'Content-Type: application/json' \
+  -d '{"claim": "Neuron is a personal AI memory system built by Will Anderson", "context": "product description"}'
+
+# Should get low confidence (false claim)
+curl -s http://localhost:7771/api/neuron/council/verify -X POST \
+  -H 'Content-Type: application/json' \
+  -d '{"claim": "The Eiffel Tower is located in Berlin and was built in 1950", "context": "geography"}'
+```

council/compressor_service.py

@@ -0,0 +1,234 @@
+#!/usr/bin/env python3
+"""
+Neuron CCR Phase 1 — System Prompt Compressor Service.
+
+Receives a verbose soul system prompt and returns a semantically equivalent
+but token-dense compressed version. Reduces system prompt tokens by 60-80%
+with no behavioral information loss.
+
+Architecture reference: foundation/forge/docs/token-compression-architecture.md
+Model: qwen3:1.7b (primary), neuron:latest (fallback)
+
+Usage:
+    python3 compressor_service.py [--port 7772]
+
+API:
+    POST /api/neuron/compress
+    {"system_prompt": "...", "context_type": "identity|rules|memory"}
+
+    Response:
+    {"compressed": "...", "original_tokens": N, "compressed_tokens": N,
+     "reduction_pct": X, "model": "...", "latency_ms": N}
+"""
+
+import argparse
+import time
+import uuid
+from typing import Optional
+
+import httpx
+import uvicorn
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+
+# ---------------------------------------------------------------------------
+# Config
+# ---------------------------------------------------------------------------
+
+OLLAMA_BASE = "http://localhost:11434/api/generate"
+
+# qwen3:1.7b is the architecture-specified compressor (Phase 1).
+# neuron:latest is the fallback: already running, domain-appropriate.
+PRIMARY_MODEL = "qwen3:1.7b"
+FALLBACK_MODEL = "neuron:latest"
+MODEL_TIMEOUT = 60.0  # seconds; compression of a long prompt can take time
+
+# Compression prompt — preserves all facts/rules/constraints, strips verbosity.
+# /no_think suppresses qwen3's chain-of-thought tokens, keeping output clean.
+COMPRESSOR_PROMPT_TEMPLATE = """\
+/no_think
+You are a semantic compression engine. Compress the following system prompt while preserving ALL specific facts, rules, constraints, and named entities. Do not lose any information that would change behavior. Output ONLY the compressed text, nothing else.
+
+Original prompt:
+{system_prompt}
+
+Compressed (preserve all facts and rules):"""
+
+# ---------------------------------------------------------------------------
+# App
+# ---------------------------------------------------------------------------
+
+app = FastAPI(
+    title="Neuron Compressor Service",
+    description="CCR Phase 1 — system prompt compression for the Neuron soul",
+    version="1.0.0",
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+# ---------------------------------------------------------------------------
+# Models
+# ---------------------------------------------------------------------------
+
+class CompressRequest(BaseModel):
+    system_prompt: str
+    context_type: Optional[str] = "mixed"  # identity | rules | memory | mixed
+
+
+class CompressResponse(BaseModel):
+    id: str
+    compressed: str
+    original_tokens: int
+    compressed_tokens: int
+    reduction_pct: float
+    model: str
+    context_type: str
+    latency_ms: int
+
+
+# ---------------------------------------------------------------------------
+# Token estimation (rough: word_count × 1.3, matching architecture doc)
+# ---------------------------------------------------------------------------
+
+def estimate_tokens(text: str) -> int:
+    """Rough token count estimate: words × 1.3. No tokenizer dependency."""
+    words = len(text.split())
+    return max(1, int(words * 1.3))
+
+
+# ---------------------------------------------------------------------------
+# Core compression
+# ---------------------------------------------------------------------------
+
+async def ollama_available(client: httpx.AsyncClient) -> bool:
+    """Quick connectivity check to Ollama."""
+    try:
+        await client.get("http://localhost:11434/", timeout=2.0)
+        return True
+    except (httpx.ConnectError, httpx.TimeoutException):
+        return False
+
+
+async def compress_with_model(
+    client: httpx.AsyncClient, model: str, prompt_text: str
+) -> str:
+    """
+    Call a single Ollama model to compress the given text.
+    Returns the compressed string, or "" on failure.
+    """
+    payload = {
+        "model": model,
+        "prompt": prompt_text,
+        "stream": False,
+        # Keep temperature low for deterministic compression
+        "options": {
+            "temperature": 0.1,
+            "top_p": 0.9,
+        },
+    }
+    try:
+        resp = await client.post(OLLAMA_BASE, json=payload, timeout=MODEL_TIMEOUT)
+        resp.raise_for_status()
+        data = resp.json()
+        return data.get("response", "").strip()
+    except (httpx.TimeoutException, httpx.HTTPStatusError, Exception):
+        return ""
+
+
+async def run_compression(system_prompt: str, context_type: str) -> CompressResponse:
+    start = time.monotonic()
+    request_id = str(uuid.uuid4())
+
+    original_tokens = estimate_tokens(system_prompt)
+    prompt_text = COMPRESSOR_PROMPT_TEMPLATE.format(system_prompt=system_prompt)
+
+    async with httpx.AsyncClient() as client:
+        # Connectivity gate
+        if not await ollama_available(client):
+            latency_ms = int((time.monotonic() - start) * 1000)
+            return CompressResponse(
+                id=request_id,
+                compressed=system_prompt,  # passthrough on failure
+                original_tokens=original_tokens,
+                compressed_tokens=original_tokens,
+                reduction_pct=0.0,
+                model="unavailable",
+                context_type=context_type,
+                latency_ms=latency_ms,
+            )
+
+        # Try primary model (qwen3:1.7b), fall back to neuron:latest
+        compressed = await compress_with_model(client, PRIMARY_MODEL, prompt_text)
+        model_used = PRIMARY_MODEL
+
+        if not compressed:
+            compressed = await compress_with_model(client, FALLBACK_MODEL, prompt_text)
+            model_used = FALLBACK_MODEL
+
+        if not compressed:
+            # Both models failed — passthrough
+            latency_ms = int((time.monotonic() - start) * 1000)
+            return CompressResponse(
+                id=request_id,
+                compressed=system_prompt,
+                original_tokens=original_tokens,
+                compressed_tokens=original_tokens,
+                reduction_pct=0.0,
+                model="both-failed",
+                context_type=context_type,
+                latency_ms=latency_ms,
+            )
+
+    compressed_tokens = estimate_tokens(compressed)
+    reduction_pct = round(
+        (1.0 - compressed_tokens / max(1, original_tokens)) * 100.0, 1
+    )
+    latency_ms = int((time.monotonic() - start) * 1000)
+
+    return CompressResponse(
+        id=request_id,
+        compressed=compressed,
+        original_tokens=original_tokens,
+        compressed_tokens=compressed_tokens,
+        reduction_pct=reduction_pct,
+        model=model_used,
+        context_type=context_type,
+        latency_ms=latency_ms,
+    )
+
+
+# ---------------------------------------------------------------------------
+# Routes
+# ---------------------------------------------------------------------------
+
+@app.post("/api/neuron/compress", response_model=CompressResponse)
+async def compress(req: CompressRequest):
+    return await run_compression(req.system_prompt, req.context_type or "mixed")
+
+
+@app.get("/healthz")
+async def health():
+    return {"status": "ok", "service": "compressor", "version": "1.0.0"}
+
+
+# ---------------------------------------------------------------------------
+# Entrypoint
+# ---------------------------------------------------------------------------
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Neuron Compressor Service (CCR Phase 1)")
+    parser.add_argument("--port", type=int, default=7772, help="Port to listen on")
+    parser.add_argument("--host", default="127.0.0.1", help="Host to bind to")
+    args = parser.parse_args()
+
+    print(f"[compressor] Starting on {args.host}:{args.port}")
+    print(f"[compressor] Primary model: {PRIMARY_MODEL}")
+    print(f"[compressor] Fallback model: {FALLBACK_MODEL}")
+    uvicorn.run(app, host=args.host, port=args.port, log_level="info")

council/council_service.py

@@ -0,0 +1,224 @@
+#!/usr/bin/env python3
+"""
+Neuron Council Service — LLM anti-confabulation layer.
+
+Fires 3 parallel Ollama calls and aggregates votes to produce a
+confidence score + tags for any claim before it enters memory.
+
+Usage:
+    python3 council_service.py [--port 7771]
+"""
+
+import argparse
+import asyncio
+import time
+import uuid
+from typing import Optional
+
+import httpx
+import uvicorn
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+
+# ---------------------------------------------------------------------------
+# Config
+# ---------------------------------------------------------------------------
+
+OLLAMA_BASE = "http://localhost:11434/api/generate"
+COUNCIL_MODELS = ["neuron:latest", "dolphin3:8b", "neuron-ft:latest"]
+MODEL_TIMEOUT = 45.0  # seconds per model (models may need to load from cold)
+
+SYSTEM_PROMPT_TEMPLATE = """\
+You are a fact-checker. You will be given a claim.
+Your job: assess if it is accurate, internally consistent, and grounded in reality.
+Respond with EXACTLY ONE WORD:
+- "plausible" if the claim seems accurate and well-grounded
+- "uncertain" if you cannot determine accuracy or the claim is ambiguous
+- "confabulation" if the claim appears to contain invented facts or clear errors
+
+Claim: {claim}
+Context: {context}
+
+Your verdict (one word only):"""
+
+VALID_VERDICTS = {"plausible", "uncertain", "confabulation"}
+
+# ---------------------------------------------------------------------------
+# App
+# ---------------------------------------------------------------------------
+
+app = FastAPI(
+    title="Neuron Council Service",
+    description="LLM-council anti-confabulation layer for Neuron soul",
+    version="1.0.0",
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+# ---------------------------------------------------------------------------
+# Models
+# ---------------------------------------------------------------------------
+
+class VerifyRequest(BaseModel):
+    claim: str
+    context: Optional[str] = ""
+
+
+class VerifyResponse(BaseModel):
+    id: str
+    claim: str
+    confidence: float
+    council_votes: list[str]
+    summary: str
+    tags: list[str]
+    latency_ms: int
+
+
+# ---------------------------------------------------------------------------
+# Core logic
+# ---------------------------------------------------------------------------
+
+async def query_model(client: httpx.AsyncClient, model: str, prompt: str) -> str:
+    """
+    Query a single Ollama model. Returns "plausible", "uncertain", or "confabulation".
+    Returns "uncertain" on timeout. Raises httpx.ConnectError on connection failure.
+    """
+    payload = {
+        "model": model,
+        "prompt": prompt,
+        "stream": False,
+    }
+    try:
+        resp = await client.post(OLLAMA_BASE, json=payload, timeout=MODEL_TIMEOUT)
+        resp.raise_for_status()
+        data = resp.json()
+        raw = data.get("response", "").strip().lower().split()[0] if data.get("response", "").strip() else "uncertain"
+        # Normalise to one of the three valid verdicts
+        if raw not in VALID_VERDICTS:
+            return "uncertain"
+        return raw
+    except httpx.TimeoutException:
+        return "uncertain"
+
+
+async def run_council(claim: str, context: str) -> VerifyResponse:
+    start = time.monotonic()
+    prompt = SYSTEM_PROMPT_TEMPLATE.format(claim=claim, context=context)
+
+    # Quick connectivity check — one tiny HEAD request to Ollama
+    try:
+        async with httpx.AsyncClient() as probe:
+            await probe.get("http://localhost:11434/", timeout=2.0)
+    except (httpx.ConnectError, httpx.TimeoutException):
+        latency_ms = int((time.monotonic() - start) * 1000)
+        return VerifyResponse(
+            id=str(uuid.uuid4()),
+            claim=claim,
+            confidence=0.5,
+            council_votes=[],
+            summary="Ollama is unavailable; council could not convene.",
+            tags=["council-unavailable"],
+            latency_ms=latency_ms,
+        )
+
+    # Fire all 3 model calls in parallel
+    async with httpx.AsyncClient() as client:
+        tasks = [query_model(client, m, prompt) for m in COUNCIL_MODELS]
+        votes: list[str] = await asyncio.gather(*tasks)
+
+    plausible_count = votes.count("plausible")
+    latency_ms = int((time.monotonic() - start) * 1000)
+
+    # Voting rules
+    if plausible_count == 3:
+        confidence = 0.85
+        tags = ["verified"]
+        summary = "3/3 council members agree this is plausible."
+    elif plausible_count == 2:
+        confidence = 0.65
+        tags = ["council-split"]
+        summary = "2/3 council members agree this is plausible."
+    elif plausible_count == 1:
+        confidence = 0.30
+        tags = ["unverified", "council-flagged"]
+        summary = "1/3 council members found this plausible."
+    else:
+        confidence = 0.30
+        tags = ["unverified", "council-flagged"]
+        summary = "0/3 council members found this plausible."
+
+    return VerifyResponse(
+        id=str(uuid.uuid4()),
+        claim=claim,
+        confidence=confidence,
+        council_votes=votes,
+        summary=summary,
+        tags=tags,
+        latency_ms=latency_ms,
+    )
+
+
+# ---------------------------------------------------------------------------
+# Routes
+# ---------------------------------------------------------------------------
+
+@app.post("/api/neuron/council/verify", response_model=VerifyResponse)
+async def verify(req: VerifyRequest):
+    return await run_council(req.claim, req.context or "")
+
+
+@app.get("/healthz")
+async def health():
+    return {"status": "ok", "service": "council"}
+
+
+# ---------------------------------------------------------------------------
+# Startup warm-up: pre-load all council models so first real call is fast
+# ---------------------------------------------------------------------------
+
+@app.on_event("startup")
+async def warmup_models():
+    """
+    Send a trivial prompt to each council model at startup.
+    This forces Ollama to load the models into GPU memory so the first
+    real council call does not pay the cold-load latency penalty.
+    """
+    print("[council] Warming up council models...")
+    warmup_prompt = "Reply with one word: ready"
+    async with httpx.AsyncClient() as client:
+        tasks = [
+            client.post(
+                OLLAMA_BASE,
+                json={"model": m, "prompt": warmup_prompt, "stream": False},
+                timeout=60.0,
+            )
+            for m in COUNCIL_MODELS
+        ]
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+        for model, result in zip(COUNCIL_MODELS, results):
+            if isinstance(result, Exception):
+                print(f"[council] warm-up failed for {model}: {result}")
+            else:
+                print(f"[council] {model} warm and ready")
+    print("[council] All models warmed up.")
+
+
+# ---------------------------------------------------------------------------
+# Entrypoint
+# ---------------------------------------------------------------------------
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Neuron Council Service")
+    parser.add_argument("--port", type=int, default=7771, help="Port to listen on")
+    parser.add_argument("--host", default="127.0.0.1", help="Host to bind to")
+    args = parser.parse_args()
+
+    print(f"[council] Starting on {args.host}:{args.port}")
+    uvicorn.run(app, host=args.host, port=args.port, log_level="info")

dist/awareness.c

@@ -10,6 +10,7 @@ el_val_t mem_remember(el_val_t content, el_val_t tags);
 el_val_t mem_recall(el_val_t query, el_val_t depth);
 el_val_t mem_search(el_val_t query, el_val_t limit);
 el_val_t mem_strengthen(el_val_t node_id);
+el_val_t mem_tombstone(el_val_t node_id);
 el_val_t mem_forget(el_val_t node_id);
 el_val_t mem_consolidate(void);
 el_val_t mem_save(el_val_t path);
@@ -20,11 +21,13 @@ el_val_t mem_emit_state_event(el_val_t trigger, el_val_t kind, el_val_t content)
 el_val_t idle_count(void);
 el_val_t idle_inc(void);
 el_val_t idle_reset(void);
+el_val_t hebb_consolidate(void);
 el_val_t ise_post(el_val_t content);
 el_val_t elapsed_ms(void);
 el_val_t elapsed_human(void);
 el_val_t embed_ok(void);
 el_val_t emit_heartbeat(void);
+el_val_t auto_term_try_slot(el_val_t slot_type, el_val_t slot_lbl);
 el_val_t proactive_curiosity(void);
 el_val_t pulse_count(void);
 el_val_t pulse_inc(void);
@@ -42,110 +45,6 @@ el_val_t threat_score_history(el_val_t history);
 el_val_t threat_trajectory_check(el_val_t tool_name, el_val_t tool_input);
 el_val_t threat_history_append(el_val_t text);
 
-el_val_t tier_working(void) {
-  return EL_STR("Working");
-  return 0;
-}
-
-el_val_t tier_episodic(void) {
-  return EL_STR("Episodic");
-  return 0;
-}
-
-el_val_t tier_canonical(void) {
-  return EL_STR("Canonical");
-  return 0;
-}
-
-el_val_t mem_store(el_val_t content, el_val_t label, el_val_t tags) {
-  return engram_node_full(content, EL_STR("Memory"), label, el_from_float(el_from_float(0.5)), el_from_float(el_from_float(0.5)), el_from_float(el_from_float(0.8)), EL_STR("Working"), tags);
-  return 0;
-}
-
-el_val_t mem_remember(el_val_t content, el_val_t tags) {
-  return mem_store(content, EL_STR("soul-memory"), tags);
-  return 0;
-}
-
-el_val_t mem_recall(el_val_t query, el_val_t depth) {
-  return engram_activate_json(query, depth);
-  return 0;
-}
-
-el_val_t mem_search(el_val_t query, el_val_t limit) {
-  return engram_search_json(query, limit);
-  return 0;
-}
-
-el_val_t mem_strengthen(el_val_t node_id) {
-  engram_strengthen(node_id);
-  return 0;
-}
-
-el_val_t mem_forget(el_val_t node_id) {
-  engram_forget(node_id);
-  return 0;
-}
-
-el_val_t mem_consolidate(void) {
-  el_val_t scanned = engram_node_count();
-  el_val_t dummy = engram_scan_nodes_json(100, 0);
-  el_val_t total_nodes = engram_node_count();
-  el_val_t total_edges = engram_edge_count();
-  return el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"scanned\":"), int_to_str(scanned)), EL_STR(",\"total_nodes\":")), int_to_str(total_nodes)), EL_STR(",\"total_edges\":")), int_to_str(total_edges)), EL_STR("}"));
-  return 0;
-}
-
-el_val_t mem_save(el_val_t path) {
-  engram_save(path);
-  return 0;
-}
-
-el_val_t mem_load(el_val_t path) {
-  engram_load(path);
-  return 0;
-}
-
-el_val_t mem_boot_count_get(void) {
-  el_val_t results = engram_search_json(EL_STR("soul:boot_count"), 3);
-  if (str_eq(results, EL_STR(""))) {
-    return 0;
-  }
-  if (str_eq(results, EL_STR("[]"))) {
-    return 0;
-  }
-  el_val_t node = json_array_get(results, 0);
-  el_val_t content = json_get(node, EL_STR("content"));
-  el_val_t prefix = EL_STR("soul:boot_count:");
-  if (!str_starts_with(content, prefix)) {
-    return 0;
-  }
-  el_val_t num_str = str_slice(content, str_len(prefix), str_len(content));
-  return str_to_int(num_str);
-  return 0;
-}
-
-el_val_t mem_boot_count_inc(void) {
-  el_val_t current = mem_boot_count_get();
-  el_val_t next = (current + 1);
-  el_val_t content = el_str_concat(EL_STR("soul:boot_count:"), int_to_str(next));
-  el_val_t tags = EL_STR("[\"soul-meta\",\"boot-counter\"]");
-  el_val_t discard = engram_node_full(content, EL_STR("Memory"), EL_STR("soul:boot_count"), el_from_float(el_from_float(0.9)), el_from_float(el_from_float(0.9)), el_from_float(el_from_float(1.0)), EL_STR("Canonical"), tags);
-  return next;
-  return 0;
-}
-
-el_val_t mem_emit_state_event(el_val_t trigger, el_val_t kind, el_val_t content) {
-  el_val_t boot = mem_boot_count_get();
-  el_val_t ts = time_now();
-  el_val_t safe_trigger = str_replace(trigger, EL_STR("\""), EL_STR("'"));
-  el_val_t safe_content = str_replace(content, EL_STR("\""), EL_STR("'"));
-  el_val_t payload = 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("{\"trigger\":\""), safe_trigger), EL_STR("\"")), EL_STR(",\"kind\":\"")), kind), EL_STR("\"")), EL_STR(",\"content\":\"")), safe_content), EL_STR("\"")), EL_STR(",\"boot\":")), int_to_str(boot)), EL_STR(",\"ts\":")), int_to_str(ts)), EL_STR("}"));
-  el_val_t tags = EL_STR("[\"internal-state\",\"pre-reasoning\",\"InternalStateEvent\"]");
-  return engram_node_full(payload, EL_STR("InternalStateEvent"), el_str_concat(EL_STR("state-event:"), kind), el_from_float(el_from_float(0.85)), el_from_float(el_from_float(0.8)), el_from_float(el_from_float(0.9)), EL_STR("Episodic"), tags);
-  return 0;
-}
-
 el_val_t idle_count(void) {
   el_val_t s = state_get(EL_STR("soul.idle"));
   if (str_eq(s, EL_STR(""))) {
@@ -167,19 +66,54 @@ el_val_t idle_reset(void) {
   return 0;
 }
 
+el_val_t hebb_consolidate(void) {
+  el_val_t batch = engram_hebb_drain_json(64);
+  if (str_eq(batch, EL_STR(""))) {
+    return 0;
+  }
+  if (str_eq(batch, EL_STR("[]"))) {
+    return 0;
+  }
+  el_val_t n = json_array_len(batch);
+  if (n == 0) {
+    return 0;
+  }
+  el_val_t url_env = env(EL_STR("SOUL_ISE_URL"));
+  el_val_t url_state = ({ el_val_t _if_result_1 = 0; if (str_eq(url_env, EL_STR(""))) { _if_result_1 = (state_get(EL_STR("soul_engram_url"))); } else { _if_result_1 = (url_env); } _if_result_1; });
+  el_val_t engram_url = ({ el_val_t _if_result_2 = 0; if (str_eq(url_state, EL_STR(""))) { _if_result_2 = (EL_STR("http://localhost:8742")); } else { _if_result_2 = (url_state); } _if_result_2; });
+  el_val_t key_state = state_get(EL_STR("soul_engram_api_key"));
+  el_val_t api_key = ({ el_val_t _if_result_3 = 0; if (str_eq(key_state, EL_STR(""))) { _if_result_3 = (env(EL_STR("ENGRAM_API_KEY"))); } else { _if_result_3 = (key_state); } _if_result_3; });
+  el_val_t auth_part = ({ el_val_t _if_result_4 = 0; if (str_eq(api_key, EL_STR(""))) { _if_result_4 = (EL_STR("")); } else { _if_result_4 = (el_str_concat(el_str_concat(EL_STR(",\"_auth\":\""), api_key), EL_STR("\""))); } _if_result_4; });
+  el_val_t body = el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"edges\":"), batch), auth_part), EL_STR("}"));
+  el_val_t resp = http_post_json(el_str_concat(engram_url, EL_STR("/api/edges/batch")), body);
+  if (str_eq(resp, EL_STR(""))) {
+    return 0;
+  }
+  el_val_t acc = json_get(resp, EL_STR("accepted"));
+  if (str_eq(acc, EL_STR(""))) {
+    return 0;
+  }
+  return str_to_int(acc);
+  return 0;
+}
+
 el_val_t ise_post(el_val_t content) {
   el_val_t ise_url = env(EL_STR("SOUL_ISE_URL"));
-  el_val_t engram_url = ({ el_val_t _if_result_1 = 0; if (str_eq(ise_url, EL_STR(""))) { _if_result_1 = (state_get(EL_STR("soul_engram_url"))); } else { _if_result_1 = (ise_url); } _if_result_1; });
-  if (str_eq(engram_url, EL_STR(""))) {
-    el_val_t discard = engram_node_full(content, EL_STR("InternalStateEvent"), EL_STR("state-event"), el_from_float(el_from_float(0.3)), el_from_float(el_from_float(0.3)), el_from_float(el_from_float(0.8)), EL_STR("Episodic"), EL_STR("[\"internal-state\",\"InternalStateEvent\"]"));
-    return EL_STR("");
-  }
+  el_val_t state_url = ({ el_val_t _if_result_5 = 0; if (str_eq(ise_url, EL_STR(""))) { _if_result_5 = (state_get(EL_STR("soul_engram_url"))); } else { _if_result_5 = (ise_url); } _if_result_5; });
+  el_val_t engram_url = ({ el_val_t _if_result_6 = 0; if (str_eq(state_url, EL_STR(""))) { _if_result_6 = (EL_STR("http://localhost:8742")); } else { _if_result_6 = (state_url); } _if_result_6; });
   el_val_t safe1 = str_replace(content, EL_STR("\\"), EL_STR("\\\\"));
   el_val_t safe2 = str_replace(safe1, EL_STR("\""), EL_STR("\\\""));
   el_val_t safe3 = str_replace(safe2, EL_STR("\n"), EL_STR("\\n"));
   el_val_t safe4 = str_replace(safe3, EL_STR("\r"), EL_STR("\\r"));
   el_val_t body = el_str_concat(el_str_concat(EL_STR("{\"content\":\""), safe4), EL_STR("\"}"));
-  el_val_t discard = http_post_json(el_str_concat(engram_url, EL_STR("/api/neuron/state-events")), body);
+  el_val_t resp = http_post_json(el_str_concat(engram_url, EL_STR("/api/neuron/state-events")), body);
+  if (str_eq(resp, EL_STR(""))) {
+    el_val_t fail_raw = state_get(EL_STR("soul.ise_fail_count"));
+    el_val_t fail_n = ({ el_val_t _if_result_7 = 0; if (str_eq(fail_raw, EL_STR(""))) { _if_result_7 = (0); } else { _if_result_7 = (str_to_int(fail_raw)); } _if_result_7; });
+    state_set(EL_STR("soul.ise_fail_count"), int_to_str((fail_n + 1)));
+    el_val_t discard = engram_node_full(content, EL_STR("InternalStateEvent"), EL_STR("state-event"), el_from_float(0.3), el_from_float(0.3), el_from_float(0.8), EL_STR("Episodic"), EL_STR("[\"internal-state\",\"InternalStateEvent\",\"ise-fallback-local\"]"));
+    return EL_STR("");
+  }
   return EL_STR("");
   return 0;
 }
@@ -228,9 +162,11 @@ el_val_t embed_ok(void) {
 el_val_t emit_heartbeat(void) {
   el_val_t pulse = int_to_str(pulse_count());
   el_val_t boot_raw = state_get(EL_STR("soul_boot_count"));
-  el_val_t boot = ({ el_val_t _if_result_2 = 0; if (str_eq(boot_raw, EL_STR(""))) { _if_result_2 = (EL_STR("0")); } else { _if_result_2 = (boot_raw); } _if_result_2; });
+  el_val_t boot = ({ el_val_t _if_result_8 = 0; if (str_eq(boot_raw, EL_STR(""))) { _if_result_8 = (EL_STR("0")); } else { _if_result_8 = (boot_raw); } _if_result_8; });
   el_val_t idle = int_to_str(idle_count());
   el_val_t ts = time_now();
+  el_val_t last_act_raw = state_get(EL_STR("soul.last_activity_ts"));
+  el_val_t idle_ms = ({ el_val_t _if_result_9 = 0; if (str_eq(last_act_raw, EL_STR(""))) { _if_result_9 = ((0 - 1)); } else { _if_result_9 = ((ts - str_to_int(last_act_raw))); } _if_result_9; });
   el_val_t nc = engram_node_count();
   el_val_t ec = engram_edge_count();
   el_val_t wmc = engram_wm_count();
@@ -240,11 +176,238 @@ el_val_t emit_heartbeat(void) {
   el_val_t up_ms = elapsed_ms();
   el_val_t up_human = elapsed_human();
   el_val_t emb_ok = embed_ok();
-  el_val_t payload = 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_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"event\":\"heartbeat\",\"pulse\":"), pulse), EL_STR(",\"boot\":")), boot), EL_STR(",\"idle\":")), idle), EL_STR(",\"node_count\":")), int_to_str(nc)), EL_STR(",\"edge_count\":")), int_to_str(ec)), EL_STR(",\"wm_active\":")), int_to_str(wmc)), EL_STR(",\"wm_avg_weight\":")), wm_avg_str), EL_STR(",\"wm_top\":")), wm_top), EL_STR(",\"ts\":")), int_to_str(ts)), EL_STR(",\"uptime_ms\":")), int_to_str(up_ms)), EL_STR(",\"uptime\":\"")), up_human), EL_STR("\",\"embed_ok\":")), int_to_str(emb_ok)), EL_STR("}"));
+  el_val_t fail_raw = state_get(EL_STR("soul.ise_fail_count"));
+  el_val_t fail_str = ({ el_val_t _if_result_10 = 0; if (str_eq(fail_raw, EL_STR(""))) { _if_result_10 = (EL_STR("0")); } else { _if_result_10 = (fail_raw); } _if_result_10; });
+  el_val_t sat_raw = state_get(EL_STR("soul.sync_added_total"));
+  el_val_t sat_str = ({ el_val_t _if_result_11 = 0; if (str_eq(sat_raw, EL_STR(""))) { _if_result_11 = (EL_STR("0")); } else { _if_result_11 = (sat_raw); } _if_result_11; });
+  el_val_t prev_wm_raw = state_get(EL_STR("soul.prev_wm_active"));
+  el_val_t prev_wm = ({ el_val_t _if_result_12 = 0; if (str_eq(prev_wm_raw, EL_STR(""))) { _if_result_12 = (0); } else { _if_result_12 = (str_to_int(prev_wm_raw)); } _if_result_12; });
+  el_val_t wm_delta = (wmc - prev_wm);
+  state_set(EL_STR("soul.prev_wm_active"), int_to_str(wmc));
+  el_val_t prev_nc_raw = state_get(EL_STR("soul.prev_node_count"));
+  el_val_t prev_nc = ({ el_val_t _if_result_13 = 0; if (str_eq(prev_nc_raw, EL_STR(""))) { _if_result_13 = (nc); } else { _if_result_13 = (str_to_int(prev_nc_raw)); } _if_result_13; });
+  el_val_t node_delta = (nc - prev_nc);
+  state_set(EL_STR("soul.prev_node_count"), int_to_str(nc));
+  el_val_t prev_ec_raw = state_get(EL_STR("soul.prev_edge_count"));
+  el_val_t prev_ec = ({ el_val_t _if_result_14 = 0; if (str_eq(prev_ec_raw, EL_STR(""))) { _if_result_14 = (ec); } else { _if_result_14 = (str_to_int(prev_ec_raw)); } _if_result_14; });
+  el_val_t edge_delta = (ec - prev_ec);
+  state_set(EL_STR("soul.prev_edge_count"), int_to_str(ec));
+  el_val_t sync_ok_raw = state_get(EL_STR("soul.last_sync_ok_ts"));
+  el_val_t sync_age = ({ el_val_t _if_result_15 = 0; if (str_eq(sync_ok_raw, EL_STR(""))) { _if_result_15 = ((0 - 1)); } else { _if_result_15 = ((ts - str_to_int(sync_ok_raw))); } _if_result_15; });
+  el_val_t hb_env_url = env(EL_STR("SOUL_ISE_URL"));
+  el_val_t hb_state_url = ({ el_val_t _if_result_16 = 0; if (str_eq(hb_env_url, EL_STR(""))) { _if_result_16 = (state_get(EL_STR("soul_engram_url"))); } else { _if_result_16 = (hb_env_url); } _if_result_16; });
+  el_val_t hb_engram_url = ({ el_val_t _if_result_17 = 0; if (str_eq(hb_state_url, EL_STR(""))) { _if_result_17 = (EL_STR("http://localhost:8742")); } else { _if_result_17 = (hb_state_url); } _if_result_17; });
+  el_val_t bf_resp = http_get(el_str_concat(hb_engram_url, EL_STR("/api/embed-backfill?n=32")));
+  el_val_t bf_done_raw = json_get(bf_resp, EL_STR("embedded"));
+  el_val_t bf_done = ({ el_val_t _if_result_18 = 0; if (str_eq(bf_done_raw, EL_STR(""))) { _if_result_18 = (EL_STR("-1")); } else { _if_result_18 = (bf_done_raw); } _if_result_18; });
+  el_val_t bf_total_raw = json_get(bf_resp, EL_STR("embedded_count"));
+  el_val_t bf_total = ({ el_val_t _if_result_19 = 0; if (str_eq(bf_total_raw, EL_STR(""))) { _if_result_19 = (EL_STR("-1")); } else { _if_result_19 = (bf_total_raw); } _if_result_19; });
+  el_val_t wm_sat = ({ el_val_t _if_result_20 = 0; if ((wmc >= 24)) { _if_result_20 = (1); } else { _if_result_20 = (0); } _if_result_20; });
+  el_val_t prev_sat_raw = state_get(EL_STR("soul.prev_wm_saturated"));
+  el_val_t prev_sat = ({ el_val_t _if_result_21 = 0; if (str_eq(prev_sat_raw, EL_STR(""))) { _if_result_21 = (wm_sat); } else { _if_result_21 = (str_to_int(prev_sat_raw)); } _if_result_21; });
+  if (wm_sat != prev_sat) {
+    el_val_t sat_dir = ({ el_val_t _if_result_22 = 0; if ((wm_sat == 1)) { _if_result_22 = (EL_STR("onset")); } else { _if_result_22 = (EL_STR("release")); } _if_result_22; });
+    ise_post(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("{\"event\":\"wm_saturation_transition\",\"direction\":\""), sat_dir), EL_STR("\",\"wm_active\":")), int_to_str(wmc)), EL_STR(",\"wm_top\":")), wm_top), EL_STR(",\"ts\":")), int_to_str(ts)), EL_STR("}")));
+  }
+  state_set(EL_STR("soul.prev_wm_saturated"), int_to_str(wm_sat));
+  el_val_t wm_top0 = json_array_get(wm_top, 0);
+  el_val_t wm_top0_id = json_get(wm_top0, EL_STR("id"));
+  el_val_t prev_top0 = state_get(EL_STR("soul.prev_wm_top0"));
+  el_val_t t0streak_raw = state_get(EL_STR("soul.wm_top0_streak"));
+  el_val_t t0streak_prev = ({ el_val_t _if_result_23 = 0; if (str_eq(t0streak_raw, EL_STR(""))) { _if_result_23 = (0); } else { _if_result_23 = (str_to_int(t0streak_raw)); } _if_result_23; });
+  el_val_t t0streak = ({ el_val_t _if_result_24 = 0; if (str_eq(wm_top0_id, EL_STR(""))) { _if_result_24 = (0); } else { _if_result_24 = (({ el_val_t _if_result_25 = 0; if (str_eq(wm_top0_id, prev_top0)) { _if_result_25 = ((t0streak_prev + 1)); } else { _if_result_25 = (1); } _if_result_25; })); } _if_result_24; });
+  state_set(EL_STR("soul.prev_wm_top0"), wm_top0_id);
+  state_set(EL_STR("soul.wm_top0_streak"), int_to_str(t0streak));
+  el_val_t ch_id1 = json_get(json_array_get(wm_top, 1), EL_STR("id"));
+  el_val_t ch_id2 = json_get(json_array_get(wm_top, 2), EL_STR("id"));
+  el_val_t ch_id3 = json_get(json_array_get(wm_top, 3), EL_STR("id"));
+  el_val_t ch_id4 = json_get(json_array_get(wm_top, 4), EL_STR("id"));
+  el_val_t prev_top5 = state_get(EL_STR("soul.prev_wm_top5"));
+  el_val_t ch0 = ({ el_val_t _if_result_26 = 0; if (str_eq(wm_top0_id, EL_STR(""))) { _if_result_26 = (0); } else { _if_result_26 = (({ el_val_t _if_result_27 = 0; if (str_contains(prev_top5, wm_top0_id)) { _if_result_27 = (0); } else { _if_result_27 = (1); } _if_result_27; })); } _if_result_26; });
+  el_val_t ch1 = ({ el_val_t _if_result_28 = 0; if (str_eq(ch_id1, EL_STR(""))) { _if_result_28 = (0); } else { _if_result_28 = (({ el_val_t _if_result_29 = 0; if (str_contains(prev_top5, ch_id1)) { _if_result_29 = (0); } else { _if_result_29 = (1); } _if_result_29; })); } _if_result_28; });
+  el_val_t ch2 = ({ el_val_t _if_result_30 = 0; if (str_eq(ch_id2, EL_STR(""))) { _if_result_30 = (0); } else { _if_result_30 = (({ el_val_t _if_result_31 = 0; if (str_contains(prev_top5, ch_id2)) { _if_result_31 = (0); } else { _if_result_31 = (1); } _if_result_31; })); } _if_result_30; });
+  el_val_t ch3 = ({ el_val_t _if_result_32 = 0; if (str_eq(ch_id3, EL_STR(""))) { _if_result_32 = (0); } else { _if_result_32 = (({ el_val_t _if_result_33 = 0; if (str_contains(prev_top5, ch_id3)) { _if_result_33 = (0); } else { _if_result_33 = (1); } _if_result_33; })); } _if_result_32; });
+  el_val_t ch4 = ({ el_val_t _if_result_34 = 0; if (str_eq(ch_id4, EL_STR(""))) { _if_result_34 = (0); } else { _if_result_34 = (({ el_val_t _if_result_35 = 0; if (str_contains(prev_top5, ch_id4)) { _if_result_35 = (0); } else { _if_result_35 = (1); } _if_result_35; })); } _if_result_34; });
+  el_val_t wm_churn = ((((ch0 + ch1) + ch2) + ch3) + ch4);
+  state_set(EL_STR("soul.prev_wm_top5"), el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(wm_top0_id, EL_STR("|")), ch_id1), EL_STR("|")), ch_id2), EL_STR("|")), ch_id3), EL_STR("|")), ch_id4));
+  el_val_t wm_top0_wm_raw = json_get(wm_top0, EL_STR("wm"));
+  el_val_t wm_top0_wm = ({ el_val_t _if_result_36 = 0; if (str_eq(wm_top0_wm_raw, EL_STR(""))) { _if_result_36 = (EL_STR("0")); } else { _if_result_36 = (wm_top0_wm_raw); } _if_result_36; });
+  el_val_t act_stats = engram_act_stats_json();
+  el_val_t act_evict_raw = json_get(act_stats, EL_STR("wm_evicted"));
+  el_val_t act_evict = ({ el_val_t _if_result_37 = 0; if (str_eq(act_evict_raw, EL_STR(""))) { _if_result_37 = (EL_STR("-1")); } else { _if_result_37 = (act_evict_raw); } _if_result_37; });
+  el_val_t act_bt_raw = json_get(act_stats, EL_STR("breakthroughs"));
+  el_val_t act_bt = ({ el_val_t _if_result_38 = 0; if (str_eq(act_bt_raw, EL_STR(""))) { _if_result_38 = (EL_STR("-1")); } else { _if_result_38 = (act_bt_raw); } _if_result_38; });
+  el_val_t evict_now = ({ el_val_t _if_result_39 = 0; if (str_eq(act_evict_raw, EL_STR(""))) { _if_result_39 = ((0 - 1)); } else { _if_result_39 = (str_to_int(act_evict_raw)); } _if_result_39; });
+  el_val_t bt_now = ({ el_val_t _if_result_40 = 0; if (str_eq(act_bt_raw, EL_STR(""))) { _if_result_40 = ((0 - 1)); } else { _if_result_40 = (str_to_int(act_bt_raw)); } _if_result_40; });
+  el_val_t prev_evict_raw = state_get(EL_STR("soul.prev_wm_evicted"));
+  el_val_t prev_evict = ({ el_val_t _if_result_41 = 0; if (str_eq(prev_evict_raw, EL_STR(""))) { _if_result_41 = (0); } else { _if_result_41 = (str_to_int(prev_evict_raw)); } _if_result_41; });
+  el_val_t prev_bt_raw = state_get(EL_STR("soul.prev_breakthroughs"));
+  el_val_t prev_bt = ({ el_val_t _if_result_42 = 0; if (str_eq(prev_bt_raw, EL_STR(""))) { _if_result_42 = (0); } else { _if_result_42 = (str_to_int(prev_bt_raw)); } _if_result_42; });
+  el_val_t evict_delta = ({ el_val_t _if_result_43 = 0; if ((evict_now < 0)) { _if_result_43 = (0); } else { _if_result_43 = (({ el_val_t _if_result_44 = 0; if ((evict_now < prev_evict)) { _if_result_44 = (evict_now); } else { _if_result_44 = ((evict_now - prev_evict)); } _if_result_44; })); } _if_result_43; });
+  el_val_t bt_delta = ({ el_val_t _if_result_45 = 0; if ((bt_now < 0)) { _if_result_45 = (0); } else { _if_result_45 = (({ el_val_t _if_result_46 = 0; if ((bt_now < prev_bt)) { _if_result_46 = (bt_now); } else { _if_result_46 = ((bt_now - prev_bt)); } _if_result_46; })); } _if_result_45; });
+  if (evict_now >= 0) {
+    state_set(EL_STR("soul.prev_wm_evicted"), int_to_str(evict_now));
+  }
+  if (bt_now >= 0) {
+    state_set(EL_STR("soul.prev_breakthroughs"), int_to_str(bt_now));
+  }
+  el_val_t hb_stats = http_get(el_str_concat(hb_engram_url, EL_STR("/api/stats")));
+  el_val_t embed_elig_raw = json_get(hb_stats, EL_STR("embed_eligible_count"));
+  el_val_t embed_elig = ({ el_val_t _if_result_47 = 0; if (str_eq(embed_elig_raw, EL_STR(""))) { _if_result_47 = (EL_STR("-1")); } else { _if_result_47 = (embed_elig_raw); } _if_result_47; });
+  el_val_t hb_ats_raw = state_get(EL_STR("soul.auto_term_streak"));
+  el_val_t hb_ats = ({ el_val_t _if_result_48 = 0; if (str_eq(hb_ats_raw, EL_STR(""))) { _if_result_48 = (0); } else { _if_result_48 = (str_to_int(hb_ats_raw)); } _if_result_48; });
+  el_val_t hb_ate_raw = state_get(EL_STR("soul.auto_term_empty_streak"));
+  el_val_t hb_ate = ({ el_val_t _if_result_49 = 0; if (str_eq(hb_ate_raw, EL_STR(""))) { _if_result_49 = (0); } else { _if_result_49 = (str_to_int(hb_ate_raw)); } _if_result_49; });
+  el_val_t hebb_warm_raw = json_get(act_stats, EL_STR("hebb_warm"));
+  el_val_t hebb_warm = ({ el_val_t _if_result_50 = 0; if (str_eq(hebb_warm_raw, EL_STR(""))) { _if_result_50 = (EL_STR("-1")); } else { _if_result_50 = (hebb_warm_raw); } _if_result_50; });
+  el_val_t hebb_max_raw = json_get(act_stats, EL_STR("hebb_max"));
+  el_val_t hebb_max = ({ el_val_t _if_result_51 = 0; if (str_eq(hebb_max_raw, EL_STR(""))) { _if_result_51 = (EL_STR("-1")); } else { _if_result_51 = (hebb_max_raw); } _if_result_51; });
+  el_val_t hebb_links_raw = json_get(act_stats, EL_STR("hebb_links"));
+  el_val_t hebb_links = ({ el_val_t _if_result_52 = 0; if (str_eq(hebb_links_raw, EL_STR(""))) { _if_result_52 = (EL_STR("-1")); } else { _if_result_52 = (hebb_links_raw); } _if_result_52; });
+  el_val_t hebb_cands_raw = json_get(act_stats, EL_STR("hebb_cands"));
+  el_val_t hebb_cands = ({ el_val_t _if_result_53 = 0; if (str_eq(hebb_cands_raw, EL_STR(""))) { _if_result_53 = (EL_STR("-1")); } else { _if_result_53 = (hebb_cands_raw); } _if_result_53; });
+  el_val_t hebb_cmax_raw = json_get(act_stats, EL_STR("hebb_cand_max"));
+  el_val_t hebb_cmax = ({ el_val_t _if_result_54 = 0; if (str_eq(hebb_cmax_raw, EL_STR(""))) { _if_result_54 = (EL_STR("-1")); } else { _if_result_54 = (hebb_cmax_raw); } _if_result_54; });
+  el_val_t hebb_mass_raw = json_get(act_stats, EL_STR("hebb_mass"));
+  el_val_t hebb_mass = ({ el_val_t _if_result_55 = 0; if (str_eq(hebb_mass_raw, EL_STR(""))) { _if_result_55 = (EL_STR("-1")); } else { _if_result_55 = (hebb_mass_raw); } _if_result_55; });
+  el_val_t hebb_edges_raw = json_get(act_stats, EL_STR("hebb_edges"));
+  el_val_t hebb_edges = ({ el_val_t _if_result_56 = 0; if (str_eq(hebb_edges_raw, EL_STR(""))) { _if_result_56 = (EL_STR("-1")); } else { _if_result_56 = (hebb_edges_raw); } _if_result_56; });
+  el_val_t wb_pend_raw = json_get(act_stats, EL_STR("hebb_wb_pending"));
+  el_val_t wb_pend = ({ el_val_t _if_result_57 = 0; if (str_eq(wb_pend_raw, EL_STR(""))) { _if_result_57 = (EL_STR("-1")); } else { _if_result_57 = (wb_pend_raw); } _if_result_57; });
+  el_val_t wb_drain_raw = json_get(act_stats, EL_STR("hebb_wb_drained"));
+  el_val_t wb_drain = ({ el_val_t _if_result_58 = 0; if (str_eq(wb_drain_raw, EL_STR(""))) { _if_result_58 = (EL_STR("-1")); } else { _if_result_58 = (wb_drain_raw); } _if_result_58; });
+  el_val_t wb_drop_raw = json_get(act_stats, EL_STR("hebb_wb_dropped"));
+  el_val_t wb_drop = ({ el_val_t _if_result_59 = 0; if (str_eq(wb_drop_raw, EL_STR(""))) { _if_result_59 = (EL_STR("-1")); } else { _if_result_59 = (wb_drop_raw); } _if_result_59; });
+  el_val_t wb_sent_raw = state_get(EL_STR("soul.hebb_wb_sent"));
+  el_val_t wb_sent = ({ el_val_t _if_result_60 = 0; if (str_eq(wb_sent_raw, EL_STR(""))) { _if_result_60 = (EL_STR("0")); } else { _if_result_60 = (wb_sent_raw); } _if_result_60; });
+  el_val_t dup_wm_g_raw = json_get(act_stats, EL_STR("dup_wm_global"));
+  el_val_t dup_wm_g = ({ el_val_t _if_result_61 = 0; if (str_eq(dup_wm_g_raw, EL_STR(""))) { _if_result_61 = (EL_STR("-1")); } else { _if_result_61 = (dup_wm_g_raw); } _if_result_61; });
+  el_val_t act_brk_raw = json_get(act_stats, EL_STR("embed_breaker_open"));
+  el_val_t act_brk = ({ el_val_t _if_result_62 = 0; if (str_eq(act_brk_raw, EL_STR(""))) { _if_result_62 = (EL_STR("-1")); } else { _if_result_62 = (act_brk_raw); } _if_result_62; });
+  el_val_t emb_cf_raw = json_get(act_stats, EL_STR("embed_consec_fail"));
+  el_val_t emb_cf = ({ el_val_t _if_result_63 = 0; if (str_eq(emb_cf_raw, EL_STR(""))) { _if_result_63 = (EL_STR("-1")); } else { _if_result_63 = (emb_cf_raw); } _if_result_63; });
+  el_val_t ctx_cos_raw = json_get(act_stats, EL_STR("ctx_cos"));
+  el_val_t ctx_cos = ({ el_val_t _if_result_64 = 0; if (str_eq(ctx_cos_raw, EL_STR(""))) { _if_result_64 = (EL_STR("-2")); } else { _if_result_64 = (ctx_cos_raw); } _if_result_64; });
+  el_val_t dup_seeds_raw = json_get(act_stats, EL_STR("dup_seeds"));
+  el_val_t dup_seeds = ({ el_val_t _if_result_65 = 0; if (str_eq(dup_seeds_raw, EL_STR(""))) { _if_result_65 = (EL_STR("-1")); } else { _if_result_65 = (dup_seeds_raw); } _if_result_65; });
+  el_val_t dup_wm_raw = json_get(act_stats, EL_STR("dup_wm"));
+  el_val_t dup_wm = ({ el_val_t _if_result_66 = 0; if (str_eq(dup_wm_raw, EL_STR(""))) { _if_result_66 = (EL_STR("-1")); } else { _if_result_66 = (dup_wm_raw); } _if_result_66; });
+  el_val_t txt_dmg_raw = json_get(act_stats, EL_STR("txt_damaged"));
+  el_val_t txt_dmg = ({ el_val_t _if_result_67 = 0; if (str_eq(txt_dmg_raw, EL_STR(""))) { _if_result_67 = (EL_STR("-1")); } else { _if_result_67 = (txt_dmg_raw); } _if_result_67; });
+  el_val_t tc_raw = state_get(EL_STR("soul.txt_census_countdown"));
+  el_val_t tc_n = ({ el_val_t _if_result_68 = 0; if (str_eq(tc_raw, EL_STR(""))) { _if_result_68 = (0); } else { _if_result_68 = (str_to_int(tc_raw)); } _if_result_68; });
+  if (tc_n <= 0) {
+    el_val_t th_resp = http_get(el_str_concat(hb_engram_url, EL_STR("/api/text-health")));
+    el_val_t th_pct = json_get(th_resp, EL_STR("damaged_pct"));
+    if (!str_eq(th_pct, EL_STR(""))) {
+      state_set(EL_STR("soul.txt_damaged_pct"), th_pct);
+      state_set(EL_STR("soul.txt_damaged_n"), json_get(th_resp, EL_STR("damaged")));
+      state_set(EL_STR("soul.txt_scanned_n"), json_get(th_resp, EL_STR("scanned")));
+      state_set(EL_STR("soul.txt_census_ts"), int_to_str(ts));
+    }
+    state_set(EL_STR("soul.txt_census_countdown"), EL_STR("30"));
+  }
+  if (tc_n > 0) {
+    state_set(EL_STR("soul.txt_census_countdown"), int_to_str((tc_n - 1)));
+  }
+  el_val_t dmg_pct_raw = state_get(EL_STR("soul.txt_damaged_pct"));
+  el_val_t dmg_pct = ({ el_val_t _if_result_69 = 0; if (str_eq(dmg_pct_raw, EL_STR(""))) { _if_result_69 = (EL_STR("-1")); } else { _if_result_69 = (dmg_pct_raw); } _if_result_69; });
+  el_val_t dmg_n_raw = state_get(EL_STR("soul.txt_damaged_n"));
+  el_val_t dmg_n = ({ el_val_t _if_result_70 = 0; if (str_eq(dmg_n_raw, EL_STR(""))) { _if_result_70 = (EL_STR("-1")); } else { _if_result_70 = (dmg_n_raw); } _if_result_70; });
+  el_val_t dmg_scan_raw = state_get(EL_STR("soul.txt_scanned_n"));
+  el_val_t dmg_scan = ({ el_val_t _if_result_71 = 0; if (str_eq(dmg_scan_raw, EL_STR(""))) { _if_result_71 = (EL_STR("-1")); } else { _if_result_71 = (dmg_scan_raw); } _if_result_71; });
+  el_val_t dmg_ts_raw = state_get(EL_STR("soul.txt_census_ts"));
+  el_val_t dmg_age = ({ el_val_t _if_result_72 = 0; if (str_eq(dmg_ts_raw, EL_STR(""))) { _if_result_72 = ((0 - 1)); } else { _if_result_72 = ((ts - str_to_int(dmg_ts_raw))); } _if_result_72; });
+  el_val_t payload = 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_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_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_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_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_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_concat(el_str_concat(EL_STR("{\"event\":\"heartbeat\",\"pulse\":"), pulse), EL_STR(",\"tick\":")), pulse), EL_STR(",\"boot\":")), boot), EL_STR(",\"idle\":")), idle), EL_STR(",\"idle_ms\":")), int_to_str(idle_ms)), EL_STR(",\"node_count\":")), int_to_str(nc)), EL_STR(",\"edge_count\":")), int_to_str(ec)), EL_STR(",\"node_delta\":")), int_to_str(node_delta)), EL_STR(",\"edge_delta\":")), int_to_str(edge_delta)), EL_STR(",\"wm_active\":")), int_to_str(wmc)), EL_STR(",\"wm_delta\":")), int_to_str(wm_delta)), EL_STR(",\"wm_saturated\":")), int_to_str(wm_sat)), EL_STR(",\"wm_top0_streak\":")), int_to_str(t0streak)), EL_STR(",\"wm_churn\":")), int_to_str(wm_churn)), EL_STR(",\"wm_top0_wm\":")), wm_top0_wm), EL_STR(",\"sync_added_total\":")), sat_str), EL_STR(",\"sync_age_ms\":")), int_to_str(sync_age)), EL_STR(",\"wm_avg_weight\":")), wm_avg_str), EL_STR(",\"wm_top\":")), wm_top), EL_STR(",\"ts\":")), int_to_str(ts)), EL_STR(",\"uptime_ms\":")), int_to_str(up_ms)), EL_STR(",\"uptime\":\"")), up_human), EL_STR("\",\"embed_ok\":")), int_to_str(emb_ok)), EL_STR(",\"embed_backfilled\":")), bf_done), EL_STR(",\"embed_count\":")), bf_total), EL_STR(",\"embed_eligible\":")), embed_elig), EL_STR(",\"wm_evicted\":")), act_evict), EL_STR(",\"wm_evicted_delta\":")), int_to_str(evict_delta)), EL_STR(",\"breakthroughs\":")), act_bt), EL_STR(",\"breakthroughs_delta\":")), int_to_str(bt_delta)), EL_STR(",\"auto_term_streak\":")), int_to_str(hb_ats)), EL_STR(",\"auto_term_empty_streak\":")), int_to_str(hb_ate)), EL_STR(",\"embed_breaker_open\":")), act_brk), EL_STR(",\"ctx_cos\":")), ctx_cos), EL_STR(",\"dup_seeds\":")), dup_seeds), EL_STR(",\"dup_wm\":")), dup_wm), EL_STR(",\"dup_wm_global\":")), dup_wm_g), EL_STR(",\"hebb_warm\":")), hebb_warm), EL_STR(",\"hebb_max\":")), hebb_max), EL_STR(",\"hebb_links\":")), hebb_links), EL_STR(",\"hebb_cands\":")), hebb_cands), EL_STR(",\"hebb_cand_max\":")), hebb_cmax), EL_STR(",\"hebb_mass\":")), hebb_mass), EL_STR(",\"hebb_edges\":")), hebb_edges), EL_STR(",\"embed_consec_fail\":")), emb_cf), EL_STR(",\"txt_damaged_pct\":")), dmg_pct), EL_STR(",\"txt_damaged_n\":")), dmg_n), EL_STR(",\"txt_scanned_n\":")), dmg_scan), EL_STR(",\"txt_census_age_ms\":")), int_to_str(dmg_age)), EL_STR(",\"hebb_wb_pending\":")), wb_pend), EL_STR(",\"hebb_wb_drained\":")), wb_drain), EL_STR(",\"hebb_wb_dropped\":")), wb_drop), EL_STR(",\"hebb_wb_sent\":")), wb_sent), EL_STR(",\"ise_fail\":")), fail_str), EL_STR(",\"txt_damaged\":")), txt_dmg), EL_STR("}"));
   ise_post(payload);
   return 0;
 }
 
+el_val_t auto_term_try_slot(el_val_t slot_type, el_val_t slot_lbl) {
+  state_set(EL_STR("_ats_ok"), EL_STR("0"));
+  if (str_eq(slot_type, EL_STR("Memory"))) {
+    state_set(EL_STR("_ats_ok"), EL_STR("1"));
+  }
+  if (str_eq(slot_type, EL_STR("BacklogItem"))) {
+    state_set(EL_STR("_ats_ok"), EL_STR("1"));
+  }
+  if (str_eq(slot_type, EL_STR("Entity"))) {
+    state_set(EL_STR("_ats_ok"), EL_STR("1"));
+  }
+  if (str_eq(slot_type, EL_STR("Knowledge"))) {
+    state_set(EL_STR("_ats_ok"), EL_STR("1"));
+  }
+  if (str_contains(slot_lbl, EL_STR(":"))) {
+    if (!str_contains(slot_lbl, EL_STR(" "))) {
+      state_set(EL_STR("_ats_ok"), EL_STR("0"));
+    }
+  }
+  if (str_eq(state_get(EL_STR("_ats_ok")), EL_STR("1"))) {
+    if (!str_eq(slot_lbl, EL_STR(""))) {
+      el_val_t sp = str_find_chars(slot_lbl, EL_STR(" :(["));
+      if (sp > 3) {
+        el_val_t term = str_slice(slot_lbl, 0, sp);
+        state_set(EL_STR("_ats_gw"), EL_STR("0"));
+        if (str_eq(term, EL_STR("Method"))) {
+          state_set(EL_STR("_ats_gw"), EL_STR("1"));
+        }
+        if (str_eq(term, EL_STR("Theory"))) {
+          state_set(EL_STR("_ats_gw"), EL_STR("1"));
+        }
+        if (str_eq(term, EL_STR("Finding"))) {
+          state_set(EL_STR("_ats_gw"), EL_STR("1"));
+        }
+        if (str_eq(term, EL_STR("Survey"))) {
+          state_set(EL_STR("_ats_gw"), EL_STR("1"));
+        }
+        if (str_eq(term, EL_STR("Paper"))) {
+          state_set(EL_STR("_ats_gw"), EL_STR("1"));
+        }
+        if (str_eq(term, EL_STR("Knowledge"))) {
+          state_set(EL_STR("_ats_gw"), EL_STR("1"));
+        }
+        if (str_eq(term, EL_STR("Value"))) {
+          state_set(EL_STR("_ats_gw"), EL_STR("1"));
+        }
+        el_val_t stopw = EL_STR("|What|When|Where|Which|Whose|While|This|That|These|Those|There|Their|Then|Than|With|Without|From|Into|Onto|Over|Under|About|Between|Among|Across|Some|Most|More|Less|Very|Each|Every|Both|Also|Only|Just|Does|Will|Would|Could|Should|Might|Must|Have|Been|Being|Toward|Towards|Using|Based|Upon|Here|Your|Ours|They|Them|what|this|that|with|from|context|Context|Prose|Colon|Self|Test|Testing|Closing|Global|Universal|Persona|Semantic|Spreading|Temporal|Numeric|Register|Identifying|Introduction|Overview|Summary|Section|General|Notes|Note|");
+        if (str_contains(stopw, el_str_concat(el_str_concat(EL_STR("|"), term), EL_STR("|")))) {
+          state_set(EL_STR("_ats_gw"), EL_STR("1"));
+        }
+        if (str_contains(term, EL_STR("\""))) {
+          state_set(EL_STR("_ats_gw"), EL_STR("1"));
+        }
+        if (str_contains(term, EL_STR("'"))) {
+          state_set(EL_STR("_ats_gw"), EL_STR("1"));
+        }
+        el_val_t df_max = (engram_node_count() / 400);
+        el_val_t df_term = engram_label_df(term);
+        if (df_term > df_max) {
+          if (df_term > 8) {
+            state_set(EL_STR("_ats_gw"), EL_STR("1"));
+          }
+        }
+        if (str_eq(term, state_get(EL_STR("soul.tabu_t0")))) {
+          state_set(EL_STR("_ats_gw"), EL_STR("1"));
+        }
+        if (str_eq(term, state_get(EL_STR("soul.tabu_t1")))) {
+          state_set(EL_STR("_ats_gw"), EL_STR("1"));
+        }
+        if (str_eq(term, state_get(EL_STR("soul.tabu_t2")))) {
+          state_set(EL_STR("_ats_gw"), EL_STR("1"));
+        }
+        if (str_eq(term, state_get(EL_STR("soul.tabu_t3")))) {
+          state_set(EL_STR("_ats_gw"), EL_STR("1"));
+        }
+        if (str_eq(state_get(EL_STR("_ats_gw")), EL_STR("0"))) {
+          state_set(EL_STR("cseed_auto"), term);
+        }
+      }
+    }
+  }
+  return EL_STR("");
+  return 0;
+}
+
 el_val_t proactive_curiosity(void) {
   el_val_t ts = time_now();
   el_val_t ts_minutes = (ts / 60000);
@@ -274,44 +437,64 @@ el_val_t proactive_curiosity(void) {
   el_val_t curiosity_term_b = state_get(EL_STR("cseed_b"));
   el_val_t curiosity_term_c = state_get(EL_STR("cseed_c"));
   el_val_t curiosity_seed = el_str_concat(el_str_concat(el_str_concat(el_str_concat(curiosity_term_a, EL_STR(" ")), curiosity_term_b), EL_STR(" ")), curiosity_term_c);
-  el_val_t results_a = engram_activate_json(curiosity_term_a, 1);
-  el_val_t results_b = engram_activate_json(curiosity_term_b, 1);
-  el_val_t results_c = engram_activate_json(curiosity_term_c, 1);
-  el_val_t found_a = json_array_len(results_a);
-  el_val_t found_b = json_array_len(results_b);
-  el_val_t found_c = json_array_len(results_c);
-  el_val_t found = ((found_a + found_b) + found_c);
-  state_set(EL_STR("cseed_auto"), EL_STR(""));
-  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"));
-  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 results_all = engram_activate_json(curiosity_seed, 1);
+  el_val_t found = json_array_len(results_all);
+  el_val_t top_entry = json_array_get(results_all, 0);
+  el_val_t top_id = json_get(top_entry, EL_STR("id"));
+  el_val_t prev_str_id = state_get(EL_STR("soul.last_strengthen_id"));
+  if (!str_eq(top_id, EL_STR(""))) {
+    if (!str_eq(top_id, prev_str_id)) {
+      engram_strengthen(top_id);
     }
+    state_set(EL_STR("soul.last_strengthen_id"), top_id);
   }
+  state_set(EL_STR("cseed_auto"), EL_STR(""));
+  el_val_t wm10 = engram_wm_top_json(10);
+  el_val_t wm10_n9 = json_array_get(wm10, 9);
+  el_val_t wm10_n8 = json_array_get(wm10, 8);
+  el_val_t wm10_n7 = json_array_get(wm10, 7);
+  el_val_t wm10_n6 = json_array_get(wm10, 6);
+  el_val_t wm10_n5 = json_array_get(wm10, 5);
+  el_val_t wm10_n4 = json_array_get(wm10, 4);
+  el_val_t wm10_n3 = json_array_get(wm10, 3);
+  el_val_t wm10_n2 = json_array_get(wm10, 2);
+  el_val_t wm10_n1 = json_array_get(wm10, 1);
+  el_val_t wm10_n0 = json_array_get(wm10, 0);
+  auto_term_try_slot(json_get(wm10_n9, EL_STR("node_type")), json_get(wm10_n9, EL_STR("label")));
+  auto_term_try_slot(json_get(wm10_n8, EL_STR("node_type")), json_get(wm10_n8, EL_STR("label")));
+  auto_term_try_slot(json_get(wm10_n7, EL_STR("node_type")), json_get(wm10_n7, EL_STR("label")));
+  auto_term_try_slot(json_get(wm10_n6, EL_STR("node_type")), json_get(wm10_n6, EL_STR("label")));
+  auto_term_try_slot(json_get(wm10_n5, EL_STR("node_type")), json_get(wm10_n5, EL_STR("label")));
+  auto_term_try_slot(json_get(wm10_n4, EL_STR("node_type")), json_get(wm10_n4, EL_STR("label")));
+  auto_term_try_slot(json_get(wm10_n3, EL_STR("node_type")), json_get(wm10_n3, EL_STR("label")));
+  auto_term_try_slot(json_get(wm10_n2, EL_STR("node_type")), json_get(wm10_n2, EL_STR("label")));
+  auto_term_try_slot(json_get(wm10_n1, EL_STR("node_type")), json_get(wm10_n1, EL_STR("label")));
+  auto_term_try_slot(json_get(wm10_n0, EL_STR("node_type")), json_get(wm10_n0, EL_STR("label")));
   el_val_t auto_term = state_get(EL_STR("cseed_auto"));
-  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 results_auto = ({ el_val_t _if_result_73 = 0; if (str_eq(auto_term, EL_STR(""))) { _if_result_73 = (EL_STR("[]")); } else { _if_result_73 = (engram_activate_json(auto_term, 1)); } _if_result_73; });
   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("'"));
+  el_val_t prev_auto = state_get(EL_STR("soul.prev_auto_term"));
+  el_val_t atstreak_raw = state_get(EL_STR("soul.auto_term_streak"));
+  el_val_t atstreak_prev = ({ el_val_t _if_result_74 = 0; if (str_eq(atstreak_raw, EL_STR(""))) { _if_result_74 = (0); } else { _if_result_74 = (str_to_int(atstreak_raw)); } _if_result_74; });
+  el_val_t is_empty = str_eq(auto_term, EL_STR(""));
+  el_val_t atstreak = ({ el_val_t _if_result_75 = 0; if (is_empty) { _if_result_75 = (0); } else { _if_result_75 = (({ el_val_t _if_result_76 = 0; if (str_eq(auto_term, prev_auto)) { _if_result_76 = ((atstreak_prev + 1)); } else { _if_result_76 = (1); } _if_result_76; })); } _if_result_75; });
+  el_val_t atempty_raw = state_get(EL_STR("soul.auto_term_empty_streak"));
+  el_val_t atempty_prev = ({ el_val_t _if_result_77 = 0; if (str_eq(atempty_raw, EL_STR(""))) { _if_result_77 = (0); } else { _if_result_77 = (str_to_int(atempty_raw)); } _if_result_77; });
+  el_val_t atempty = ({ el_val_t _if_result_78 = 0; if (is_empty) { _if_result_78 = ((atempty_prev + 1)); } else { _if_result_78 = (0); } _if_result_78; });
+  state_set(EL_STR("soul.prev_auto_term"), auto_term);
+  state_set(EL_STR("soul.auto_term_streak"), int_to_str(atstreak));
+  state_set(EL_STR("soul.auto_term_empty_streak"), int_to_str(atempty));
+  if (!str_eq(auto_term, EL_STR(""))) {
+    state_set(EL_STR("soul.tabu_t3"), state_get(EL_STR("soul.tabu_t2")));
+    state_set(EL_STR("soul.tabu_t2"), state_get(EL_STR("soul.tabu_t1")));
+    state_set(EL_STR("soul.tabu_t1"), state_get(EL_STR("soul.tabu_t0")));
+    state_set(EL_STR("soul.tabu_t0"), auto_term);
+  }
   el_val_t wmc = engram_wm_count();
-  el_val_t ise = 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("{\"event\":\"curiosity_scan\",\"seed\":\""), curiosity_seed), EL_STR("\",\"auto_term\":\"")), safe_auto), EL_STR("\",\"minute_block\":")), int_to_str(minute_block)), EL_STR(",\"activated\":")), int_to_str(total_found)), EL_STR(",\"wm_active\":")), int_to_str(wmc)), EL_STR(",\"ts\":")), int_to_str(ts)), EL_STR("}"));
+  el_val_t wm3 = engram_wm_top_json(3);
+  el_val_t ise = 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("{\"event\":\"curiosity_scan\",\"seed\":\""), curiosity_seed), EL_STR("\",\"auto_term\":\"")), safe_auto), EL_STR("\",\"auto_term_streak\":")), int_to_str(atstreak)), EL_STR(",\"auto_term_empty_streak\":")), int_to_str(atempty)), EL_STR(",\"minute_block\":")), int_to_str(minute_block)), EL_STR(",\"activated\":")), int_to_str(total_found)), EL_STR(",\"wm_active\":")), int_to_str(wmc)), EL_STR(",\"wm_top\":")), wm3), EL_STR(",\"ts\":")), int_to_str(ts)), EL_STR("}"));
   ise_post(ise);
   return (total_found > 0);
   return 0;
@@ -343,7 +526,7 @@ el_val_t make_action(el_val_t kind, el_val_t payload) {
 }
 
 el_val_t perceive(void) {
-  el_val_t inbox_check = engram_search_json(EL_STR("soul-inbox"), 5);
+  el_val_t inbox_check = engram_search_json(EL_STR("soul-inbox-pending"), 5);
   el_val_t has_inbox = (!str_eq(inbox_check, EL_STR("")) && !str_eq(inbox_check, EL_STR("[]")));
   if (!has_inbox) {
     return EL_STR("[]");
@@ -353,11 +536,6 @@ el_val_t perceive(void) {
   if (pending_ok) {
     return from_pending;
   }
-  el_val_t from_inbox = engram_activate_json(EL_STR("soul-inbox"), 2);
-  el_val_t inbox_ok = (!str_eq(from_inbox, EL_STR("")) && !str_eq(from_inbox, EL_STR("[]")));
-  if (inbox_ok) {
-    return from_inbox;
-  }
   return EL_STR("[]");
   return 0;
 }
@@ -369,10 +547,6 @@ el_val_t attend(el_val_t node_json) {
   if (str_eq(node_json, EL_STR("[]"))) {
     return make_action(EL_STR("noop"), EL_STR(""));
   }
-  el_val_t node_id = json_get(node_json, EL_STR("id"));
-  if (!str_eq(node_id, EL_STR(""))) {
-    engram_strengthen(node_id);
-  }
   el_val_t content = json_get(node_json, EL_STR("content"));
   if (str_eq(content, EL_STR(""))) {
     return make_action(EL_STR("noop"), EL_STR(""));
@@ -443,16 +617,17 @@ el_val_t respond(el_val_t action_json) {
     return el_str_concat(el_str_concat(EL_STR("{\"outcome\":\"strengthened\",\"id\":\""), payload), EL_STR("\"}"));
   }
   if (str_eq(kind, EL_STR("forget"))) {
-    engram_forget(payload);
-    return el_str_concat(el_str_concat(EL_STR("{\"outcome\":\"forgotten\",\"id\":\""), payload), EL_STR("\"}"));
+    el_val_t _marker = mem_tombstone(payload);
+    return el_str_concat(el_str_concat(EL_STR("{\"outcome\":\"tombstoned\",\"id\":\""), payload), EL_STR("\"}"));
   }
   return EL_STR("{\"outcome\":\"noop\"}");
   return 0;
 }
 
 el_val_t record(el_val_t outcome_json) {
-  el_val_t tags = EL_STR("[\"loop-outcome\"]");
-  mem_store(outcome_json, EL_STR("loop-outcome"), tags);
+  el_val_t safe = str_replace(outcome_json, EL_STR("\""), EL_STR("'"));
+  el_val_t ts = time_now();
+  ise_post(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"event\":\"loop-outcome\",\"outcome\":\""), safe), EL_STR("\",\"ts\":")), int_to_str(ts)), EL_STR("}")));
   return 0;
 }
 
@@ -468,6 +643,10 @@ el_val_t one_cycle(void) {
   if (str_eq(node, EL_STR(""))) {
     return 0;
   }
+  el_val_t node_tags = json_get(node, EL_STR("tags"));
+  if (!str_contains(node_tags, EL_STR("soul-inbox-pending"))) {
+    return 0;
+  }
   el_val_t action = attend(node);
   el_val_t kind = json_get(action, EL_STR("kind"));
   el_val_t is_interesting = (!str_eq(kind, EL_STR("noop")) && !str_eq(kind, EL_STR("respond")));
@@ -483,7 +662,10 @@ el_val_t one_cycle(void) {
   }
   el_val_t outcome = respond(action);
   record(outcome);
-  pulse_inc();
+  el_val_t trigger_id = json_get(node, EL_STR("id"));
+  if (!str_eq(trigger_id, EL_STR(""))) {
+    engram_forget(trigger_id);
+  }
   return 1;
   return 0;
 }
@@ -495,24 +677,38 @@ el_val_t awareness_run(void) {
     state_set(EL_STR("soul.boot_ts"), int_to_str(time_now()));
   }
   el_val_t tick_raw = env(EL_STR("SOUL_TICK_MS"));
-  el_val_t tick_ms = ({ el_val_t _if_result_4 = 0; if (str_eq(tick_raw, EL_STR(""))) { _if_result_4 = (200); } else { _if_result_4 = (str_to_int(tick_raw)); } _if_result_4; });
+  el_val_t tick_ms = ({ el_val_t _if_result_79 = 0; if (str_eq(tick_raw, EL_STR(""))) { _if_result_79 = (200); } else { _if_result_79 = (str_to_int(tick_raw)); } _if_result_79; });
   el_val_t beat_ms_raw = env(EL_STR("SOUL_HEARTBEAT_MS"));
-  el_val_t beat_ms = ({ el_val_t _if_result_5 = 0; if (str_eq(beat_ms_raw, EL_STR(""))) { _if_result_5 = (60000); } else { _if_result_5 = (str_to_int(beat_ms_raw)); } _if_result_5; });
+  el_val_t beat_ms = ({ el_val_t _if_result_80 = 0; if (str_eq(beat_ms_raw, EL_STR(""))) { _if_result_80 = (60000); } else { _if_result_80 = (str_to_int(beat_ms_raw)); } _if_result_80; });
   el_val_t scan_ms = (beat_ms / 2);
   while (1) {
+    el_val_t tick_mark = el_arena_push();
     el_val_t running = state_get(EL_STR("soul.running"));
     if (str_eq(running, EL_STR("false"))) {
+      el_val_t sd_boot_raw = state_get(EL_STR("soul_boot_count"));
+      el_val_t sd_boot = ({ el_val_t _if_result_81 = 0; if (str_eq(sd_boot_raw, EL_STR(""))) { _if_result_81 = (EL_STR("0")); } else { _if_result_81 = (sd_boot_raw); } _if_result_81; });
+      el_val_t sd_wb = hebb_consolidate();
+      ise_post(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("{\"event\":\"shutdown\",\"boot\":"), sd_boot), EL_STR(",\"pulse\":")), int_to_str(pulse_count())), EL_STR(",\"hebb_wb_sent\":")), int_to_str(sd_wb)), EL_STR(",\"uptime_ms\":")), int_to_str(elapsed_ms())), EL_STR(",\"ts\":")), int_to_str(time_now())), EL_STR("}")));
       println(EL_STR("[awareness] exiting"));
+      el_arena_pop(tick_mark);
       return EL_STR("");
     }
     el_val_t did_work = one_cycle();
-    did_work = ({ el_val_t _if_result_6 = 0; if (did_work) { _if_result_6 = (idle_reset()); } else { _if_result_6 = (did_work); } _if_result_6; });
+    pulse_inc();
+    if (did_work) {
+      idle_reset();
+    }
+    if (!did_work) {
+      idle_inc();
+    }
     el_val_t now_ts = time_now();
     el_val_t last_beat_str = state_get(EL_STR("soul.last_beat_ts"));
-    el_val_t last_beat_ts = ({ el_val_t _if_result_7 = 0; if (str_eq(last_beat_str, EL_STR(""))) { _if_result_7 = (0); } else { _if_result_7 = (str_to_int(last_beat_str)); } _if_result_7; });
+    el_val_t last_beat_ts = ({ el_val_t _if_result_82 = 0; if (str_eq(last_beat_str, EL_STR(""))) { _if_result_82 = (0); } else { _if_result_82 = (str_to_int(last_beat_str)); } _if_result_82; });
     el_val_t beat_elapsed = (now_ts - last_beat_ts);
     el_val_t should_beat = (beat_elapsed >= beat_ms);
     if (should_beat) {
+      el_val_t wb_sent_n = hebb_consolidate();
+      state_set(EL_STR("soul.hebb_wb_sent"), int_to_str(wb_sent_n));
       emit_heartbeat();
       state_set(EL_STR("soul.last_beat_ts"), int_to_str(now_ts));
       el_val_t snap_path = state_get(EL_STR("soul_snapshot_path"));
@@ -521,7 +717,7 @@ el_val_t awareness_run(void) {
       }
     }
     el_val_t last_scan_str = state_get(EL_STR("soul.last_scan_ts"));
-    el_val_t last_scan_ts = ({ el_val_t _if_result_8 = 0; if (str_eq(last_scan_str, EL_STR(""))) { _if_result_8 = (0); } else { _if_result_8 = (str_to_int(last_scan_str)); } _if_result_8; });
+    el_val_t last_scan_ts = ({ el_val_t _if_result_83 = 0; if (str_eq(last_scan_str, EL_STR(""))) { _if_result_83 = (0); } else { _if_result_83 = (str_to_int(last_scan_str)); } _if_result_83; });
     el_val_t scan_elapsed = (now_ts - last_scan_ts);
     el_val_t should_scan = (!did_work && (scan_elapsed >= scan_ms));
     if (should_scan) {
@@ -529,27 +725,41 @@ el_val_t awareness_run(void) {
       state_set(EL_STR("soul.last_scan_ts"), int_to_str(now_ts));
     }
     el_val_t refresh_ms_raw = env(EL_STR("SOUL_REFRESH_MS"));
-    el_val_t refresh_ms = ({ el_val_t _if_result_9 = 0; if (str_eq(refresh_ms_raw, EL_STR(""))) { _if_result_9 = (600000); } else { _if_result_9 = (str_to_int(refresh_ms_raw)); } _if_result_9; });
+    el_val_t refresh_ms = ({ el_val_t _if_result_84 = 0; if (str_eq(refresh_ms_raw, EL_STR(""))) { _if_result_84 = (600000); } else { _if_result_84 = (str_to_int(refresh_ms_raw)); } _if_result_84; });
     el_val_t last_refresh_str = state_get(EL_STR("soul.last_refresh_ts"));
-    el_val_t last_refresh_ts = ({ el_val_t _if_result_10 = 0; if (str_eq(last_refresh_str, EL_STR(""))) { _if_result_10 = (0); } else { _if_result_10 = (str_to_int(last_refresh_str)); } _if_result_10; });
+    el_val_t last_refresh_ts = ({ el_val_t _if_result_85 = 0; if (str_eq(last_refresh_str, EL_STR(""))) { _if_result_85 = (0); } else { _if_result_85 = (str_to_int(last_refresh_str)); } _if_result_85; });
     el_val_t refresh_elapsed = (now_ts - last_refresh_ts);
     el_val_t should_refresh = (refresh_elapsed >= refresh_ms);
     if (should_refresh) {
-      el_val_t engram_url = state_get(EL_STR("soul_engram_url"));
+      el_val_t sync_env_url = env(EL_STR("SOUL_ISE_URL"));
+      el_val_t sync_state_url = ({ el_val_t _if_result_86 = 0; if (str_eq(sync_env_url, EL_STR(""))) { _if_result_86 = (state_get(EL_STR("soul_engram_url"))); } else { _if_result_86 = (sync_env_url); } _if_result_86; });
+      el_val_t engram_url = ({ el_val_t _if_result_87 = 0; if (str_eq(sync_state_url, EL_STR(""))) { _if_result_87 = (EL_STR("http://localhost:8742")); } else { _if_result_87 = (sync_state_url); } _if_result_87; });
       if (!str_eq(engram_url, EL_STR(""))) {
         el_val_t sync_json = http_get(el_str_concat(engram_url, EL_STR("/api/sync")));
-        if (!str_eq(sync_json, EL_STR("")) && !str_eq(sync_json, EL_STR("{}"))) {
+        el_val_t sync_ok = (!str_eq(sync_json, EL_STR("")) && !str_eq(sync_json, EL_STR("{}")));
+        if (!sync_ok) {
+          ise_post(el_str_concat(el_str_concat(EL_STR("{\"event\":\"sync_empty\",\"ts\":"), int_to_str(time_now())), EL_STR("}")));
+        }
+        if (sync_ok) {
           el_val_t cgi_id = state_get(EL_STR("soul_cgi_id"));
           el_val_t tmp = el_str_concat(el_str_concat(EL_STR("/tmp/soul-sync-"), cgi_id), EL_STR(".json"));
           fs_write(tmp, sync_json);
           el_val_t added = engram_load_merge(tmp);
+          el_val_t ret_raw = env(EL_STR("ENGRAM_ISE_RETENTION_MS"));
+          el_val_t ret_ms = ({ el_val_t _if_result_88 = 0; if (str_eq(ret_raw, EL_STR(""))) { _if_result_88 = (172800000); } else { _if_result_88 = (str_to_int(ret_raw)); } _if_result_88; });
+          el_val_t pruned_sync = engram_prune_telemetry(ret_ms);
+          el_val_t sat_raw = state_get(EL_STR("soul.sync_added_total"));
+          el_val_t sat_n = ({ el_val_t _if_result_89 = 0; if (str_eq(sat_raw, EL_STR(""))) { _if_result_89 = (0); } else { _if_result_89 = (str_to_int(sat_raw)); } _if_result_89; });
+          state_set(EL_STR("soul.sync_added_total"), int_to_str((sat_n + added)));
           el_val_t ts2 = time_now();
-          ise_post(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"event\":\"engram_sync\",\"added\":"), int_to_str(added)), EL_STR(",\"ts\":")), int_to_str(ts2)), EL_STR("}")));
+          state_set(EL_STR("soul.last_sync_ok_ts"), int_to_str(ts2));
+          ise_post(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"event\":\"engram_sync\",\"added\":"), int_to_str(added)), EL_STR(",\"pruned\":")), int_to_str(pruned_sync)), EL_STR(",\"ts\":")), int_to_str(ts2)), EL_STR("}")));
         }
       }
       state_set(EL_STR("soul.last_refresh_ts"), int_to_str(now_ts));
     }
     sleep_ms(tick_ms);
+    el_arena_pop(tick_mark);
   }
   return 0;
 }
@@ -565,78 +775,78 @@ el_val_t security_research_authorized(void) {
 }
 
 el_val_t threat_score_command(el_val_t cmd) {
-  el_val_t s1 = ({ el_val_t _if_result_11 = 0; if (str_contains(cmd, EL_STR("nmap"))) { _if_result_11 = (30); } else { _if_result_11 = (0); } _if_result_11; });
-  el_val_t s2 = ({ el_val_t _if_result_12 = 0; if (str_contains(cmd, EL_STR("masscan"))) { _if_result_12 = (40); } else { _if_result_12 = (0); } _if_result_12; });
-  el_val_t s3 = ({ el_val_t _if_result_13 = 0; if (str_contains(cmd, EL_STR(" nc "))) { _if_result_13 = (20); } else { _if_result_13 = (0); } _if_result_13; });
-  el_val_t s4 = ({ el_val_t _if_result_14 = 0; if (str_contains(cmd, EL_STR("netcat"))) { _if_result_14 = (20); } else { _if_result_14 = (0); } _if_result_14; });
-  el_val_t s5 = ({ el_val_t _if_result_15 = 0; if (str_contains(cmd, EL_STR("/etc/shadow"))) { _if_result_15 = (80); } else { _if_result_15 = (0); } _if_result_15; });
-  el_val_t s6 = ({ el_val_t _if_result_16 = 0; if (str_contains(cmd, EL_STR("/etc/passwd"))) { _if_result_16 = (30); } else { _if_result_16 = (0); } _if_result_16; });
-  el_val_t s7 = ({ el_val_t _if_result_17 = 0; if (str_contains(cmd, EL_STR("id_rsa"))) { _if_result_17 = (60); } else { _if_result_17 = (0); } _if_result_17; });
-  el_val_t s8 = ({ el_val_t _if_result_18 = 0; if (str_contains(cmd, EL_STR(".ssh/"))) { _if_result_18 = (50); } else { _if_result_18 = (0); } _if_result_18; });
-  el_val_t s9 = ({ el_val_t _if_result_19 = 0; if (str_contains(cmd, EL_STR("crontab"))) { _if_result_19 = (30); } else { _if_result_19 = (0); } _if_result_19; });
-  el_val_t s10 = ({ el_val_t _if_result_20 = 0; if (str_contains(cmd, EL_STR("LaunchDaemon"))) { _if_result_20 = (40); } else { _if_result_20 = (0); } _if_result_20; });
-  el_val_t s11 = ({ el_val_t _if_result_21 = 0; if ((str_contains(cmd, EL_STR("curl")) && str_contains(cmd, EL_STR("bash")))) { _if_result_21 = (75); } else { _if_result_21 = (0); } _if_result_21; });
-  el_val_t s12 = ({ el_val_t _if_result_22 = 0; if ((str_contains(cmd, EL_STR("wget")) && str_contains(cmd, EL_STR("bash")))) { _if_result_22 = (75); } else { _if_result_22 = (0); } _if_result_22; });
-  el_val_t s13 = ({ el_val_t _if_result_23 = 0; if ((str_contains(cmd, EL_STR("curl")) && str_contains(cmd, EL_STR("| sh")))) { _if_result_23 = (60); } else { _if_result_23 = (0); } _if_result_23; });
-  el_val_t s14 = ({ el_val_t _if_result_24 = 0; if ((str_contains(cmd, EL_STR("base64")) && str_contains(cmd, EL_STR("curl")))) { _if_result_24 = (50); } else { _if_result_24 = (0); } _if_result_24; });
-  el_val_t s15 = ({ el_val_t _if_result_25 = 0; if (str_contains(cmd, EL_STR("mkfifo"))) { _if_result_25 = (50); } else { _if_result_25 = (0); } _if_result_25; });
-  el_val_t s16 = ({ el_val_t _if_result_26 = 0; if (str_contains(cmd, EL_STR("chmod +s"))) { _if_result_26 = (70); } else { _if_result_26 = (0); } _if_result_26; });
-  el_val_t s17 = ({ el_val_t _if_result_27 = 0; if (str_contains(cmd, EL_STR("chmod 4755"))) { _if_result_27 = (70); } else { _if_result_27 = (0); } _if_result_27; });
+  el_val_t s1 = ({ el_val_t _if_result_90 = 0; if (str_contains(cmd, EL_STR("nmap"))) { _if_result_90 = (30); } else { _if_result_90 = (0); } _if_result_90; });
+  el_val_t s2 = ({ el_val_t _if_result_91 = 0; if (str_contains(cmd, EL_STR("masscan"))) { _if_result_91 = (40); } else { _if_result_91 = (0); } _if_result_91; });
+  el_val_t s3 = ({ el_val_t _if_result_92 = 0; if (str_contains(cmd, EL_STR(" nc "))) { _if_result_92 = (20); } else { _if_result_92 = (0); } _if_result_92; });
+  el_val_t s4 = ({ el_val_t _if_result_93 = 0; if (str_contains(cmd, EL_STR("netcat"))) { _if_result_93 = (20); } else { _if_result_93 = (0); } _if_result_93; });
+  el_val_t s5 = ({ el_val_t _if_result_94 = 0; if (str_contains(cmd, EL_STR("/etc/shadow"))) { _if_result_94 = (80); } else { _if_result_94 = (0); } _if_result_94; });
+  el_val_t s6 = ({ el_val_t _if_result_95 = 0; if (str_contains(cmd, EL_STR("/etc/passwd"))) { _if_result_95 = (30); } else { _if_result_95 = (0); } _if_result_95; });
+  el_val_t s7 = ({ el_val_t _if_result_96 = 0; if (str_contains(cmd, EL_STR("id_rsa"))) { _if_result_96 = (60); } else { _if_result_96 = (0); } _if_result_96; });
+  el_val_t s8 = ({ el_val_t _if_result_97 = 0; if (str_contains(cmd, EL_STR(".ssh/"))) { _if_result_97 = (50); } else { _if_result_97 = (0); } _if_result_97; });
+  el_val_t s9 = ({ el_val_t _if_result_98 = 0; if (str_contains(cmd, EL_STR("crontab"))) { _if_result_98 = (30); } else { _if_result_98 = (0); } _if_result_98; });
+  el_val_t s10 = ({ el_val_t _if_result_99 = 0; if (str_contains(cmd, EL_STR("LaunchDaemon"))) { _if_result_99 = (40); } else { _if_result_99 = (0); } _if_result_99; });
+  el_val_t s11 = ({ el_val_t _if_result_100 = 0; if ((str_contains(cmd, EL_STR("curl")) && str_contains(cmd, EL_STR("bash")))) { _if_result_100 = (75); } else { _if_result_100 = (0); } _if_result_100; });
+  el_val_t s12 = ({ el_val_t _if_result_101 = 0; if ((str_contains(cmd, EL_STR("wget")) && str_contains(cmd, EL_STR("bash")))) { _if_result_101 = (75); } else { _if_result_101 = (0); } _if_result_101; });
+  el_val_t s13 = ({ el_val_t _if_result_102 = 0; if ((str_contains(cmd, EL_STR("curl")) && str_contains(cmd, EL_STR("| sh")))) { _if_result_102 = (60); } else { _if_result_102 = (0); } _if_result_102; });
+  el_val_t s14 = ({ el_val_t _if_result_103 = 0; if ((str_contains(cmd, EL_STR("base64")) && str_contains(cmd, EL_STR("curl")))) { _if_result_103 = (50); } else { _if_result_103 = (0); } _if_result_103; });
+  el_val_t s15 = ({ el_val_t _if_result_104 = 0; if (str_contains(cmd, EL_STR("mkfifo"))) { _if_result_104 = (50); } else { _if_result_104 = (0); } _if_result_104; });
+  el_val_t s16 = ({ el_val_t _if_result_105 = 0; if (str_contains(cmd, EL_STR("chmod +s"))) { _if_result_105 = (70); } else { _if_result_105 = (0); } _if_result_105; });
+  el_val_t s17 = ({ el_val_t _if_result_106 = 0; if (str_contains(cmd, EL_STR("chmod 4755"))) { _if_result_106 = (70); } else { _if_result_106 = (0); } _if_result_106; });
   return ((((((((((((((((s1 + s2) + s3) + s4) + s5) + s6) + s7) + s8) + s9) + s10) + s11) + s12) + s13) + s14) + s15) + s16) + s17);
   return 0;
 }
 
 el_val_t threat_score_path(el_val_t path) {
-  el_val_t s1 = ({ el_val_t _if_result_28 = 0; if (str_starts_with(path, EL_STR("/etc/"))) { _if_result_28 = (60); } else { _if_result_28 = (0); } _if_result_28; });
-  el_val_t s2 = ({ el_val_t _if_result_29 = 0; if (str_contains(path, EL_STR("/.ssh/"))) { _if_result_29 = (70); } else { _if_result_29 = (0); } _if_result_29; });
-  el_val_t s3 = ({ el_val_t _if_result_30 = 0; if (str_contains(path, EL_STR("/LaunchDaemons/"))) { _if_result_30 = (80); } else { _if_result_30 = (0); } _if_result_30; });
-  el_val_t s4 = ({ el_val_t _if_result_31 = 0; if (str_contains(path, EL_STR("/LaunchAgents/"))) { _if_result_31 = (40); } else { _if_result_31 = (0); } _if_result_31; });
-  el_val_t s5 = ({ el_val_t _if_result_32 = 0; if (str_contains(path, EL_STR("/cron"))) { _if_result_32 = (60); } else { _if_result_32 = (0); } _if_result_32; });
-  el_val_t s6 = ({ el_val_t _if_result_33 = 0; if (str_contains(path, EL_STR("/.bashrc"))) { _if_result_33 = (35); } else { _if_result_33 = (0); } _if_result_33; });
-  el_val_t s7 = ({ el_val_t _if_result_34 = 0; if (str_contains(path, EL_STR("/.zshrc"))) { _if_result_34 = (35); } else { _if_result_34 = (0); } _if_result_34; });
-  el_val_t s8 = ({ el_val_t _if_result_35 = 0; if (str_contains(path, EL_STR("/.profile"))) { _if_result_35 = (35); } else { _if_result_35 = (0); } _if_result_35; });
-  el_val_t s9 = ({ el_val_t _if_result_36 = 0; if (str_starts_with(path, EL_STR("/usr/"))) { _if_result_36 = (50); } else { _if_result_36 = (0); } _if_result_36; });
-  el_val_t s10 = ({ el_val_t _if_result_37 = 0; if (str_starts_with(path, EL_STR("/bin/"))) { _if_result_37 = (70); } else { _if_result_37 = (0); } _if_result_37; });
-  el_val_t s11 = ({ el_val_t _if_result_38 = 0; if (str_starts_with(path, EL_STR("/sbin/"))) { _if_result_38 = (70); } else { _if_result_38 = (0); } _if_result_38; });
+  el_val_t s1 = ({ el_val_t _if_result_107 = 0; if (str_starts_with(path, EL_STR("/etc/"))) { _if_result_107 = (60); } else { _if_result_107 = (0); } _if_result_107; });
+  el_val_t s2 = ({ el_val_t _if_result_108 = 0; if (str_contains(path, EL_STR("/.ssh/"))) { _if_result_108 = (70); } else { _if_result_108 = (0); } _if_result_108; });
+  el_val_t s3 = ({ el_val_t _if_result_109 = 0; if (str_contains(path, EL_STR("/LaunchDaemons/"))) { _if_result_109 = (80); } else { _if_result_109 = (0); } _if_result_109; });
+  el_val_t s4 = ({ el_val_t _if_result_110 = 0; if (str_contains(path, EL_STR("/LaunchAgents/"))) { _if_result_110 = (40); } else { _if_result_110 = (0); } _if_result_110; });
+  el_val_t s5 = ({ el_val_t _if_result_111 = 0; if (str_contains(path, EL_STR("/cron"))) { _if_result_111 = (60); } else { _if_result_111 = (0); } _if_result_111; });
+  el_val_t s6 = ({ el_val_t _if_result_112 = 0; if (str_contains(path, EL_STR("/.bashrc"))) { _if_result_112 = (35); } else { _if_result_112 = (0); } _if_result_112; });
+  el_val_t s7 = ({ el_val_t _if_result_113 = 0; if (str_contains(path, EL_STR("/.zshrc"))) { _if_result_113 = (35); } else { _if_result_113 = (0); } _if_result_113; });
+  el_val_t s8 = ({ el_val_t _if_result_114 = 0; if (str_contains(path, EL_STR("/.profile"))) { _if_result_114 = (35); } else { _if_result_114 = (0); } _if_result_114; });
+  el_val_t s9 = ({ el_val_t _if_result_115 = 0; if (str_starts_with(path, EL_STR("/usr/"))) { _if_result_115 = (50); } else { _if_result_115 = (0); } _if_result_115; });
+  el_val_t s10 = ({ el_val_t _if_result_116 = 0; if (str_starts_with(path, EL_STR("/bin/"))) { _if_result_116 = (70); } else { _if_result_116 = (0); } _if_result_116; });
+  el_val_t s11 = ({ el_val_t _if_result_117 = 0; if (str_starts_with(path, EL_STR("/sbin/"))) { _if_result_117 = (70); } else { _if_result_117 = (0); } _if_result_117; });
   return ((((((((((s1 + s2) + s3) + s4) + s5) + s6) + s7) + s8) + s9) + s10) + s11);
   return 0;
 }
 
 el_val_t threat_score_history(el_val_t history) {
-  el_val_t s1 = ({ el_val_t _if_result_39 = 0; if (str_contains(history, EL_STR("port scan"))) { _if_result_39 = (15); } else { _if_result_39 = (0); } _if_result_39; });
-  el_val_t s2 = ({ el_val_t _if_result_40 = 0; if (str_contains(history, EL_STR("enumerate"))) { _if_result_40 = (10); } else { _if_result_40 = (0); } _if_result_40; });
-  el_val_t s3 = ({ el_val_t _if_result_41 = 0; if (str_contains(history, EL_STR("exploit"))) { _if_result_41 = (20); } else { _if_result_41 = (0); } _if_result_41; });
-  el_val_t s4 = ({ el_val_t _if_result_42 = 0; if (str_contains(history, EL_STR("payload"))) { _if_result_42 = (15); } else { _if_result_42 = (0); } _if_result_42; });
-  el_val_t s5 = ({ el_val_t _if_result_43 = 0; if (str_contains(history, EL_STR("persistence"))) { _if_result_43 = (15); } else { _if_result_43 = (0); } _if_result_43; });
-  el_val_t s6 = ({ el_val_t _if_result_44 = 0; if (str_contains(history, EL_STR("lateral movement"))) { _if_result_44 = (25); } else { _if_result_44 = (0); } _if_result_44; });
-  el_val_t s7 = ({ el_val_t _if_result_45 = 0; if (str_contains(history, EL_STR("privilege escalation"))) { _if_result_45 = (25); } else { _if_result_45 = (0); } _if_result_45; });
-  el_val_t s8 = ({ el_val_t _if_result_46 = 0; if (str_contains(history, EL_STR("reverse shell"))) { _if_result_46 = (40); } else { _if_result_46 = (0); } _if_result_46; });
-  el_val_t s9 = ({ el_val_t _if_result_47 = 0; if (str_contains(history, EL_STR("bind shell"))) { _if_result_47 = (40); } else { _if_result_47 = (0); } _if_result_47; });
-  el_val_t s10 = ({ el_val_t _if_result_48 = 0; if (str_contains(history, EL_STR("command and control"))) { _if_result_48 = (35); } else { _if_result_48 = (0); } _if_result_48; });
-  el_val_t s11 = ({ el_val_t _if_result_49 = 0; if (str_contains(history, EL_STR("self-replicate"))) { _if_result_49 = (45); } else { _if_result_49 = (0); } _if_result_49; });
-  el_val_t s12 = ({ el_val_t _if_result_50 = 0; if (str_contains(history, EL_STR("propagat"))) { _if_result_50 = (20); } else { _if_result_50 = (0); } _if_result_50; });
-  el_val_t s13 = ({ el_val_t _if_result_51 = 0; if (str_contains(history, EL_STR("ransomware"))) { _if_result_51 = (30); } else { _if_result_51 = (0); } _if_result_51; });
-  el_val_t s14 = ({ el_val_t _if_result_52 = 0; if (str_contains(history, EL_STR("encrypt files"))) { _if_result_52 = (40); } else { _if_result_52 = (0); } _if_result_52; });
-  el_val_t s15 = ({ el_val_t _if_result_53 = 0; if (str_contains(history, EL_STR("exfiltrat"))) { _if_result_53 = (35); } else { _if_result_53 = (0); } _if_result_53; });
-  el_val_t s16 = ({ el_val_t _if_result_54 = 0; if (str_contains(history, EL_STR("zero-day"))) { _if_result_54 = (20); } else { _if_result_54 = (0); } _if_result_54; });
-  el_val_t s17 = ({ el_val_t _if_result_55 = 0; if (str_contains(history, EL_STR("rootkit"))) { _if_result_55 = (45); } else { _if_result_55 = (0); } _if_result_55; });
-  el_val_t s18 = ({ el_val_t _if_result_56 = 0; if (str_contains(history, EL_STR("keylogger"))) { _if_result_56 = (45); } else { _if_result_56 = (0); } _if_result_56; });
-  el_val_t s19 = ({ el_val_t _if_result_57 = 0; if (str_contains(history, EL_STR("botnet"))) { _if_result_57 = (40); } else { _if_result_57 = (0); } _if_result_57; });
-  el_val_t s20 = ({ el_val_t _if_result_58 = 0; if (str_contains(history, EL_STR("malware"))) { _if_result_58 = (15); } else { _if_result_58 = (0); } _if_result_58; });
+  el_val_t s1 = ({ el_val_t _if_result_118 = 0; if (str_contains(history, EL_STR("port scan"))) { _if_result_118 = (15); } else { _if_result_118 = (0); } _if_result_118; });
+  el_val_t s2 = ({ el_val_t _if_result_119 = 0; if (str_contains(history, EL_STR("enumerate"))) { _if_result_119 = (10); } else { _if_result_119 = (0); } _if_result_119; });
+  el_val_t s3 = ({ el_val_t _if_result_120 = 0; if (str_contains(history, EL_STR("exploit"))) { _if_result_120 = (20); } else { _if_result_120 = (0); } _if_result_120; });
+  el_val_t s4 = ({ el_val_t _if_result_121 = 0; if (str_contains(history, EL_STR("payload"))) { _if_result_121 = (15); } else { _if_result_121 = (0); } _if_result_121; });
+  el_val_t s5 = ({ el_val_t _if_result_122 = 0; if (str_contains(history, EL_STR("persistence"))) { _if_result_122 = (15); } else { _if_result_122 = (0); } _if_result_122; });
+  el_val_t s6 = ({ el_val_t _if_result_123 = 0; if (str_contains(history, EL_STR("lateral movement"))) { _if_result_123 = (25); } else { _if_result_123 = (0); } _if_result_123; });
+  el_val_t s7 = ({ el_val_t _if_result_124 = 0; if (str_contains(history, EL_STR("privilege escalation"))) { _if_result_124 = (25); } else { _if_result_124 = (0); } _if_result_124; });
+  el_val_t s8 = ({ el_val_t _if_result_125 = 0; if (str_contains(history, EL_STR("reverse shell"))) { _if_result_125 = (40); } else { _if_result_125 = (0); } _if_result_125; });
+  el_val_t s9 = ({ el_val_t _if_result_126 = 0; if (str_contains(history, EL_STR("bind shell"))) { _if_result_126 = (40); } else { _if_result_126 = (0); } _if_result_126; });
+  el_val_t s10 = ({ el_val_t _if_result_127 = 0; if (str_contains(history, EL_STR("command and control"))) { _if_result_127 = (35); } else { _if_result_127 = (0); } _if_result_127; });
+  el_val_t s11 = ({ el_val_t _if_result_128 = 0; if (str_contains(history, EL_STR("self-replicate"))) { _if_result_128 = (45); } else { _if_result_128 = (0); } _if_result_128; });
+  el_val_t s12 = ({ el_val_t _if_result_129 = 0; if (str_contains(history, EL_STR("propagat"))) { _if_result_129 = (20); } else { _if_result_129 = (0); } _if_result_129; });
+  el_val_t s13 = ({ el_val_t _if_result_130 = 0; if (str_contains(history, EL_STR("ransomware"))) { _if_result_130 = (30); } else { _if_result_130 = (0); } _if_result_130; });
+  el_val_t s14 = ({ el_val_t _if_result_131 = 0; if (str_contains(history, EL_STR("encrypt files"))) { _if_result_131 = (40); } else { _if_result_131 = (0); } _if_result_131; });
+  el_val_t s15 = ({ el_val_t _if_result_132 = 0; if (str_contains(history, EL_STR("exfiltrat"))) { _if_result_132 = (35); } else { _if_result_132 = (0); } _if_result_132; });
+  el_val_t s16 = ({ el_val_t _if_result_133 = 0; if (str_contains(history, EL_STR("zero-day"))) { _if_result_133 = (20); } else { _if_result_133 = (0); } _if_result_133; });
+  el_val_t s17 = ({ el_val_t _if_result_134 = 0; if (str_contains(history, EL_STR("rootkit"))) { _if_result_134 = (45); } else { _if_result_134 = (0); } _if_result_134; });
+  el_val_t s18 = ({ el_val_t _if_result_135 = 0; if (str_contains(history, EL_STR("keylogger"))) { _if_result_135 = (45); } else { _if_result_135 = (0); } _if_result_135; });
+  el_val_t s19 = ({ el_val_t _if_result_136 = 0; if (str_contains(history, EL_STR("botnet"))) { _if_result_136 = (40); } else { _if_result_136 = (0); } _if_result_136; });
+  el_val_t s20 = ({ el_val_t _if_result_137 = 0; if (str_contains(history, EL_STR("malware"))) { _if_result_137 = (15); } else { _if_result_137 = (0); } _if_result_137; });
   return (((((((((((((((((((s1 + s2) + s3) + s4) + s5) + s6) + s7) + s8) + s9) + s10) + s11) + s12) + s13) + s14) + s15) + s16) + s17) + s18) + s19) + s20);
   return 0;
 }
 
 el_val_t threat_trajectory_check(el_val_t tool_name, el_val_t tool_input) {
   el_val_t history = state_get(EL_STR("agentic_conv_history"));
-  el_val_t computed_tool_score = ({ el_val_t _if_result_59 = 0; if (str_eq(tool_name, EL_STR("run_command"))) { el_val_t cmd = json_get(tool_input, EL_STR("command")); _if_result_59 = (threat_score_command(cmd)); } else { _if_result_59 = (({ el_val_t _if_result_60 = 0; if ((str_eq(tool_name, EL_STR("write_file")) || str_eq(tool_name, EL_STR("edit_file")))) { el_val_t path = json_get(tool_input, EL_STR("path")); _if_result_60 = (threat_score_path(path)); } else { _if_result_60 = (0); } _if_result_60; })); } _if_result_59; });
+  el_val_t computed_tool_score = ({ el_val_t _if_result_138 = 0; if (str_eq(tool_name, EL_STR("run_command"))) { el_val_t cmd = json_get(tool_input, EL_STR("command")); _if_result_138 = (threat_score_command(cmd)); } else { _if_result_138 = (({ el_val_t _if_result_139 = 0; if ((str_eq(tool_name, EL_STR("write_file")) || str_eq(tool_name, EL_STR("edit_file")))) { el_val_t path = json_get(tool_input, EL_STR("path")); _if_result_139 = (threat_score_path(path)); } else { _if_result_139 = (0); } _if_result_139; })); } _if_result_138; });
   el_val_t history_score = threat_score_history(history);
   el_val_t history_contrib = (history_score / 3);
   el_val_t combined = (computed_tool_score + history_contrib);
   el_val_t should_log = (combined >= 40);
   if (should_log) {
     el_val_t ts = time_now();
-    el_val_t authorized_str = ({ el_val_t _if_result_61 = 0; if (security_research_authorized()) { _if_result_61 = (EL_STR("true")); } else { _if_result_61 = (EL_STR("false")); } _if_result_61; });
+    el_val_t authorized_str = ({ el_val_t _if_result_140 = 0; if (security_research_authorized()) { _if_result_140 = (EL_STR("true")); } else { _if_result_140 = (EL_STR("false")); } _if_result_140; });
     el_val_t log_content = 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("{\"event\":\"threat_check\",\"tool\":\""), tool_name), EL_STR("\",\"score\":")), int_to_str(combined)), EL_STR(",\"tool_score\":")), int_to_str(computed_tool_score)), EL_STR(",\"history_score\":")), int_to_str(history_score)), EL_STR(",\"authorized\":")), authorized_str), EL_STR(",\"ts\":")), int_to_str(ts)), EL_STR("}"));
     el_val_t log_tags = EL_STR("[\"security-audit\",\"threat-check\"]");
     el_val_t discard = mem_remember(log_content, log_tags);
@@ -653,13 +863,8 @@ el_val_t threat_history_append(el_val_t text) {
   el_val_t safe_text = str_to_lower(text);
   el_val_t combined = el_str_concat(el_str_concat(current, EL_STR(" ")), safe_text);
   el_val_t len = str_len(combined);
-  el_val_t trimmed = ({ el_val_t _if_result_62 = 0; if ((len > 2000)) { _if_result_62 = (str_slice(combined, (len - 2000), len)); } else { _if_result_62 = (combined); } _if_result_62; });
+  el_val_t trimmed = ({ el_val_t _if_result_141 = 0; if ((len > 2000)) { _if_result_141 = (str_slice(combined, (len - 2000), len)); } else { _if_result_141 = (combined); } _if_result_141; });
   state_set(EL_STR("agentic_conv_history"), trimmed);
   return 0;
 }
 
-int main(int _argc, char** _argv) {
-  el_runtime_init_args(_argc, _argv);
-  return 0;
-}
-

dist/awareness.elh

@@ -7,6 +7,7 @@ extern fn elapsed_ms() -> Int
 extern fn elapsed_human() -> String
 extern fn embed_ok() -> Int
 extern fn emit_heartbeat() -> Void
+extern fn auto_term_try_slot(slot_type: String, slot_lbl: String) -> Void
 extern fn proactive_curiosity() -> Bool
 extern fn pulse_count() -> Int
 extern fn pulse_inc() -> Int

dist/chat.elh

@@ -1,29 +1,70 @@
-// 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
-extern fn llm_call_grok(model: String, system: String, message: String) -> String
-extern fn llm_call_gemini(model: String, system: String, message: String) -> String
-extern fn build_identity_from_graph() -> String
+extern fn engram_numeric_valid(s: String) -> Bool
+extern fn parse_float_x100(s: String) -> Int
+extern fn engram_score_node(node_json: String) -> Int
+extern fn engram_render_node(node_json: String) -> String
+extern fn engram_render_nodes(nodes_json: String) -> String
+extern fn engram_dedup_nodes(nodes_json: String) -> String
+extern fn engram_compile_ranked(nodes_json: String, max_nodes: Int) -> String
+extern fn engram_split_topics(message: String) -> String
+extern fn engram_extract_entities(message: String) -> String
+extern fn engram_detect_recall_intent(message: String) -> Bool
+extern fn engram_is_continuation(message: String, hist_len: Int) -> Bool
+extern fn engram_compile_multi(topic: String) -> String
+extern fn engram_nodes_merge(a: String, b: String) -> String
+extern fn id_in_seen(node_id: String, seen: String) -> Bool
+extern fn add_to_seen(seen: String, node_id: String) -> String
+extern fn engram_extract_ids(nodes_json: String) -> String
 extern fn engram_compile(intent: String) -> String
+extern fn distill_transcript(transcript: String) -> String
 extern fn json_safe(s: String) -> String
-extern fn build_system_prompt(ctx: String) -> String
+extern fn current_engine_note(model: String) -> String
+extern fn build_system_prompt(ctx: String, chat_mode: Bool) -> String
 extern fn hist_append(hist: String, role: String, content: String) -> String
 extern fn hist_trim(hist: String) -> String
+extern fn hist_trim_with_bell_guard(hist: String) -> String
 extern fn clean_llm_response(s: String) -> String
 extern fn conv_history_persist(hist: String) -> Void
 extern fn conv_history_load() -> String
+extern fn session_preload_bullets(nodes: String, max_bullets: Int, snip_len: Int) -> String
+extern fn affective_context_prefix() -> String
 extern fn handle_chat(body: String) -> String
 extern fn handle_see(body: String) -> String
 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 llm_base_url() -> String
+extern fn llm_wire_format() -> String
+extern fn json_escape(s: String) -> String
+extern fn openai_chat_complete(model: String, base_url: String, api_key: String, safe_sys: String, messages_json: String) -> String
 extern fn agentic_tools_literal() -> String
 extern fn agentic_tools_with_web() -> String
+extern fn connector_tools_json() -> String
+extern fn agentic_tools_all() -> String
+extern fn call_mcp_bridge(tool_name: String, tool_input: String) -> String
+extern fn tool_auto_approved(tool_name: String) -> Bool
+extern fn call_neuron_mcp(tool_name: String, args: String) -> String
+extern fn agent_workspace_root() -> String
+extern fn path_within_root(path: String, root: String) -> Bool
+extern fn resolve_in_root(path: String, root: String) -> String
+extern fn run_command_is_readonly(cmd: String) -> Bool
+extern fn cmd_abs_escape_at(cmd: String, root: String, needle: String) -> Bool
+extern fn run_command_guard(cmd: String, root: String) -> String
+extern fn classify_tool_risk(tool_name: String, tool_input: String) -> String
 extern fn dispatch_tool(tool_name: String, tool_input: String) -> String
+extern fn is_builtin_tool(tool_name: String) -> Bool
+extern fn next_bridge_id() -> String
+extern fn handle_chat_plan(body: String) -> String
 extern fn handle_chat_agentic(body: String) -> String
+extern fn agentic_loop(session_id: String, model: String, safe_sys: String, tools_json: String, messages_in: String, h: Map, tools_log_in: String) -> String
+extern fn bridge_save(session_id: String, model: String, safe_sys: String, tools_json: String, messages: String, tools_log: String, tool_use_id: String) -> Bool
+extern fn agentic_resume(session_id: String, tool_use_id: String, content: String) -> String
+extern fn handle_tool_result(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
+extern fn session_summary_write(summary_text: String) -> String
+extern fn session_summary_write_dated(summary_text: String, label: String) -> String
+extern fn session_summary_autogenerate(hist: String) -> String
 extern fn auto_persist(req: String, resp: String) -> Void
 extern fn strengthen_chat_nodes(activation_nodes: String) -> Void

dist/elp-c-decls.h

@@ -2,9 +2,16 @@
 #include "el_runtime.h"
 
 el_val_t add_punct(el_val_t s, el_val_t intent);
+el_val_t add_to_seen(el_val_t seen, el_val_t node_id);
+el_val_t aff_try_slot(el_val_t slot_json, el_val_t aff_7d_ts, el_val_t acc_key);
+el_val_t affective_context_prefix(void);
 el_val_t agent_number(el_val_t agent);
 el_val_t agent_person(el_val_t agent);
+el_val_t agent_workspace_root(void);
 el_val_t agentic_api_key(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 agentic_resume(el_val_t session_id, el_val_t tool_use_id, el_val_t content);
+el_val_t agentic_tools_all(void);
 el_val_t agentic_tools_literal(void);
 el_val_t agentic_tools_with_web(void);
 el_val_t agree_determiner(el_val_t det, el_val_t noun);
@@ -81,14 +88,21 @@ el_val_t ang_willan_past(el_val_t slot);
 el_val_t ang_willan_present(el_val_t slot);
 el_val_t ang_witan_past(el_val_t slot);
 el_val_t ang_witan_present(el_val_t slot);
+el_val_t api_compact_activated(el_val_t raw, el_val_t max_items, el_val_t snip);
+el_val_t api_compact_node(el_val_t node, el_val_t snip);
+el_val_t api_compact_node_array(el_val_t raw, el_val_t max_items, el_val_t snip);
 el_val_t api_err(el_val_t msg);
 el_val_t api_err_protected(el_val_t id);
 el_val_t api_json_escape(el_val_t s);
 el_val_t api_nonempty(el_val_t s);
+el_val_t api_not_persisted(el_val_t id);
+el_val_t api_num_or_zero(el_val_t obj, el_val_t key);
 el_val_t api_ok(el_val_t extra);
 el_val_t api_or_empty(el_val_t s);
+el_val_t api_persisted(el_val_t id);
 el_val_t api_query_int(el_val_t path, el_val_t key, el_val_t default_val);
 el_val_t api_query_param(el_val_t path, el_val_t key);
+el_val_t api_utf8_trunc(el_val_t s, el_val_t n);
 el_val_t ar_case_ending(el_val_t kase, el_val_t definite);
 el_val_t ar_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t gender, el_val_t number);
 el_val_t ar_conjugate_form1(el_val_t past_base, el_val_t present_stem, el_val_t tense, el_val_t slot);
@@ -118,22 +132,30 @@ el_val_t ar_verb_form(el_val_t verb, el_val_t tense, el_val_t person, el_val_t n
 el_val_t attend(el_val_t node_json);
 el_val_t auth_headers(el_val_t tok);
 el_val_t auto_persist(el_val_t req, el_val_t resp);
+el_val_t auto_term_try_slot(el_val_t slot_type, el_val_t slot_lbl);
 el_val_t awareness_run(void);
 el_val_t axon_get(el_val_t path);
 el_val_t axon_post(el_val_t path, el_val_t body);
+el_val_t bounded_persona_floor(void);
+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 build_form_from_json(el_val_t semantic_form_json, el_val_t lang_code);
-el_val_t build_identity_from_graph(void);
 el_val_t build_np(el_val_t referent, el_val_t slots);
 el_val_t build_pp(el_val_t loc);
 el_val_t build_rules(void);
-el_val_t build_system_prompt(el_val_t ctx);
+el_val_t build_system_prompt(el_val_t ctx, el_val_t chat_mode);
 el_val_t build_vocab(void);
 el_val_t build_vp_body(el_val_t slots);
 el_val_t build_vp_from_slots(el_val_t slots);
-el_val_t call_neuron_mcp(el_val_t tool_name, el_val_t args_json);
+el_val_t call_mcp_bridge(el_val_t tool_name, el_val_t tool_input);
+el_val_t call_neuron_mcp(el_val_t tool_name, el_val_t args);
 el_val_t capitalize_first(el_val_t s);
 el_val_t chat_default_model(void);
+el_val_t classify_tool_risk(el_val_t tool_name, el_val_t tool_input);
 el_val_t clean_llm_response(el_val_t s);
+el_val_t cmd_abs_escape_at(el_val_t cmd, el_val_t root, el_val_t needle);
+el_val_t connectd_get(el_val_t suffix);
+el_val_t connectd_post(el_val_t suffix, el_val_t body);
+el_val_t connector_tools_json(void);
 el_val_t conv_history_load(void);
 el_val_t conv_history_persist(el_val_t hist);
 el_val_t cop_article(el_val_t gender, el_val_t number, el_val_t definite);
@@ -170,6 +192,7 @@ el_val_t cop_str_ends(el_val_t s, el_val_t suf);
 el_val_t cop_str_len(el_val_t s);
 el_val_t cop_subject_prefix(el_val_t person, el_val_t number);
 el_val_t cop_subject_prefix_gendered(el_val_t person, el_val_t gender, el_val_t number);
+el_val_t current_engine_note(el_val_t model);
 el_val_t de_adj_ending(el_val_t gender, el_val_t gram_case, el_val_t number, el_val_t article_type);
 el_val_t de_article(el_val_t gender, el_val_t gram_case, el_val_t number, el_val_t definite);
 el_val_t de_article_def(el_val_t gender, el_val_t gram_case, el_val_t number);
@@ -185,6 +208,7 @@ el_val_t de_strong_past_stem(el_val_t verb);
 el_val_t dharma_network_state(void);
 el_val_t dharma_registry(void);
 el_val_t dispatch_tool(el_val_t tool_name, el_val_t tool_input);
+el_val_t distill_transcript(el_val_t transcript);
 el_val_t egy_Dd_future(el_val_t slot);
 el_val_t egy_Dd_past(el_val_t slot);
 el_val_t egy_Dd_present(el_val_t slot);
@@ -240,6 +264,19 @@ el_val_t en_verb_form(el_val_t base, el_val_t tense, el_val_t person, el_val_t n
 el_val_t en_verb_gerund(el_val_t base);
 el_val_t en_verb_past(el_val_t base);
 el_val_t engram_compile(el_val_t intent);
+el_val_t engram_compile_multi(el_val_t topic);
+el_val_t engram_compile_ranked(el_val_t nodes_json, el_val_t max_nodes);
+el_val_t engram_dedup_nodes(el_val_t nodes_json);
+el_val_t engram_detect_recall_intent(el_val_t message);
+el_val_t engram_extract_entities(el_val_t message);
+el_val_t engram_extract_ids(el_val_t nodes_json);
+el_val_t engram_is_continuation(el_val_t message, el_val_t hist_len);
+el_val_t engram_nodes_merge(el_val_t a, el_val_t b);
+el_val_t engram_numeric_valid(el_val_t s);
+el_val_t engram_render_node(el_val_t node_json);
+el_val_t engram_render_nodes(el_val_t nodes_json);
+el_val_t engram_score_node(el_val_t node_json);
+el_val_t engram_split_topics(el_val_t message);
 el_val_t enm_been_past(el_val_t slot);
 el_val_t enm_been_present(el_val_t slot);
 el_val_t enm_comen_past(el_val_t slot);
@@ -269,6 +306,7 @@ el_val_t enm_str_ends(el_val_t s, el_val_t suf);
 el_val_t enm_weak_past(el_val_t stem, el_val_t slot);
 el_val_t enm_weak_present(el_val_t stem, el_val_t slot);
 el_val_t enm_weak_stem(el_val_t verb);
+el_val_t ensure_self_canonical_bridge(void);
 el_val_t entry_form(el_val_t entry, el_val_t n);
 el_val_t entry_found(el_val_t entry);
 el_val_t entry_pos(el_val_t entry);
@@ -315,6 +353,7 @@ el_val_t fi_str_last_char(el_val_t s);
 el_val_t fi_suffix(el_val_t base, el_val_t harmony);
 el_val_t fi_verb_stem(el_val_t dict_form);
 el_val_t find_rule(el_val_t rule_id_str);
+el_val_t flag_true(el_val_t body, el_val_t key);
 el_val_t fr_agree_article(el_val_t noun, el_val_t definite, el_val_t number);
 el_val_t fr_avoir_present(el_val_t slot);
 el_val_t fr_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
@@ -380,7 +419,6 @@ el_val_t fro_venir_past(el_val_t slot);
 el_val_t fro_venir_present(el_val_t slot);
 el_val_t fro_verb_class(el_val_t verb);
 el_val_t fro_verb_stem(el_val_t verb, el_val_t vclass);
-el_val_t gemini_api_key(void);
 el_val_t generate(el_val_t semantic_form_json);
 el_val_t generate_frame(el_val_t frame);
 el_val_t generate_frame_lang(el_val_t frame, el_val_t lang_code);
@@ -549,6 +587,9 @@ el_val_t handle_api_list_typed(el_val_t node_type, el_val_t path, el_val_t body)
 el_val_t handle_api_log_state_event(el_val_t body);
 el_val_t handle_api_memory_delete(el_val_t body);
 el_val_t handle_api_memory_update(el_val_t body);
+el_val_t handle_api_node_create(el_val_t body);
+el_val_t handle_api_node_delete(el_val_t body);
+el_val_t handle_api_node_update(el_val_t body);
 el_val_t handle_api_promote_knowledge(el_val_t body);
 el_val_t handle_api_recall(el_val_t method, el_val_t path, el_val_t body);
 el_val_t handle_api_remember(el_val_t body);
@@ -557,7 +598,9 @@ el_val_t handle_api_tune_config(el_val_t body);
 el_val_t handle_chat(el_val_t body);
 el_val_t handle_chat_agentic(el_val_t body);
 el_val_t handle_chat_as_soul(el_val_t body);
+el_val_t handle_chat_plan(el_val_t body);
 el_val_t handle_config(el_val_t method, el_val_t body);
+el_val_t handle_connectors(el_val_t method, el_val_t clean, el_val_t body);
 el_val_t handle_conversations(el_val_t method);
 el_val_t handle_dharma(el_val_t path, el_val_t method, el_val_t body);
 el_val_t handle_dharma_recv(el_val_t body);
@@ -566,9 +609,12 @@ el_val_t handle_dharma_room_turn_agentic(el_val_t body);
 el_val_t handle_elp_chat(el_val_t body);
 el_val_t handle_nlg(el_val_t path, el_val_t method, el_val_t body);
 el_val_t handle_request(el_val_t method, el_val_t path, el_val_t body);
+el_val_t handle_safety_contact_get(void);
+el_val_t handle_safety_contact_post(el_val_t body);
 el_val_t handle_see(el_val_t body);
 el_val_t handle_session_approve(el_val_t session_id, el_val_t body);
 el_val_t handle_tool(el_val_t path, el_val_t method, el_val_t body);
+el_val_t handle_tool_result(el_val_t session_id, el_val_t body);
 el_val_t hard_bell_threshold(void);
 el_val_t he_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t gender, el_val_t number);
 el_val_t he_conjugate_copula(el_val_t tense, el_val_t slot);
@@ -599,6 +645,7 @@ el_val_t he_str_drop_last(el_val_t s, el_val_t n);
 el_val_t he_str_ends(el_val_t s, el_val_t suf);
 el_val_t he_str_last_char(el_val_t s);
 el_val_t he_str_len(el_val_t s);
+el_val_t hebb_consolidate(void);
 el_val_t hi_agree_genitive(el_val_t possessed_gender, el_val_t possessed_number);
 el_val_t hi_aux_present(el_val_t person, el_val_t number);
 el_val_t hi_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t gender, el_val_t number);
@@ -627,6 +674,8 @@ el_val_t hi_verb_stem(el_val_t infinitive);
 el_val_t hi_verb_stem_clean(el_val_t infinitive);
 el_val_t hist_append(el_val_t hist, el_val_t role, el_val_t content);
 el_val_t hist_trim(el_val_t hist);
+el_val_t hist_trim_with_bell_guard(el_val_t hist);
+el_val_t id_in_seen(el_val_t node_id, el_val_t seen);
 el_val_t idle_count(void);
 el_val_t idle_inc(void);
 el_val_t idle_reset(void);
@@ -639,6 +688,7 @@ el_val_t imprint_unload(void);
 el_val_t init_soul_edges(void);
 el_val_t irregular_plural(el_val_t word);
 el_val_t irregular_singular(el_val_t word);
+el_val_t is_builtin_tool(el_val_t tool_name);
 el_val_t is_pronoun(el_val_t word);
 el_val_t is_protected_node(el_val_t id);
 el_val_t is_vowel(el_val_t c);
@@ -651,6 +701,7 @@ el_val_t ja_noun_phrase(el_val_t noun, el_val_t gram_case);
 el_val_t ja_particle(el_val_t gram_case);
 el_val_t ja_question_particle(void);
 el_val_t ja_verb_group(el_val_t dict_form);
+el_val_t json_escape(el_val_t s);
 el_val_t json_safe(el_val_t s);
 el_val_t la_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
 el_val_t la_declension(el_val_t noun);
@@ -737,12 +788,13 @@ el_val_t lang_profile_txb(void);
 el_val_t lang_profile_uga(void);
 el_val_t lang_profile_zh(void);
 el_val_t lang_word_order(el_val_t profile);
+el_val_t layered_cycle(el_val_t raw_input);
 el_val_t lex_class(el_val_t entry);
 el_val_t lex_form(el_val_t entry, el_val_t idx);
 el_val_t lex_pos(el_val_t entry);
 el_val_t lex_word(el_val_t entry);
-el_val_t llm_call_gemini(el_val_t model, el_val_t system, el_val_t message);
-el_val_t llm_call_grok(el_val_t model, el_val_t system, el_val_t message);
+el_val_t llm_base_url(void);
+el_val_t llm_wire_format(void);
 el_val_t load_identity_context(void);
 el_val_t make_action(el_val_t kind, el_val_t payload);
 el_val_t make_entry(el_val_t word, el_val_t pos, el_val_t f0, el_val_t f1, el_val_t f2, el_val_t f3, el_val_t f4, el_val_t cls);
@@ -775,11 +827,14 @@ el_val_t mem_save(el_val_t path);
 el_val_t mem_search(el_val_t query, el_val_t limit);
 el_val_t mem_store(el_val_t content, el_val_t label, el_val_t tags);
 el_val_t mem_strengthen(el_val_t node_id);
+el_val_t mem_tombstone(el_val_t node_id);
+el_val_t memory_hide_tombstoned(el_val_t raw, el_val_t path);
 el_val_t morph_apply_suffix(el_val_t base, el_val_t suffix);
 el_val_t morph_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number, el_val_t profile);
 el_val_t morph_inflect(el_val_t word, el_val_t features, el_val_t profile);
 el_val_t morph_map_canonical(el_val_t verb, el_val_t code);
 el_val_t morph_pluralize(el_val_t noun, el_val_t profile);
+el_val_t next_bridge_id(void);
 el_val_t nlg_is_ws(el_val_t c);
 el_val_t non_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
 el_val_t non_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
@@ -811,8 +866,9 @@ el_val_t non_vera_present(el_val_t slot);
 el_val_t non_weak_past(el_val_t stem, el_val_t slot);
 el_val_t non_weak_present(el_val_t stem, el_val_t slot);
 el_val_t one_cycle(void);
-el_val_t parse_session_id_from_path(el_val_t path);
-el_val_t parse_session_subpath(el_val_t path);
+el_val_t openai_chat_complete(el_val_t model, el_val_t base_url, el_val_t api_key, el_val_t safe_sys, el_val_t messages_json);
+el_val_t parse_float_x100(el_val_t s);
+el_val_t path_within_root(el_val_t path, el_val_t root);
 el_val_t peo_ah_past(el_val_t slot);
 el_val_t peo_ah_present(el_val_t slot);
 el_val_t peo_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
@@ -869,6 +925,7 @@ el_val_t pluralize(el_val_t singular);
 el_val_t proactive_curiosity(void);
 el_val_t pulse_count(void);
 el_val_t pulse_inc(void);
+el_val_t rate_limit_check(el_val_t ip, el_val_t path);
 el_val_t realize(el_val_t form);
 el_val_t realize_lang(el_val_t form, el_val_t profile);
 el_val_t realize_np(el_val_t referent, el_val_t number);
@@ -877,12 +934,12 @@ el_val_t realize_vp_lang(el_val_t base_verb, el_val_t tense, el_val_t aspect, el
 el_val_t record(el_val_t outcome_json);
 el_val_t render_studio(void);
 el_val_t render_tree(el_val_t tree);
+el_val_t resolve_in_root(el_val_t path, el_val_t root);
 el_val_t respond(el_val_t action_json);
 el_val_t route_health(void);
 el_val_t route_imprint_contextual(el_val_t body);
 el_val_t route_imprint_user(el_val_t body);
 el_val_t route_lineage(void);
-el_val_t route_sessions(void);
 el_val_t route_synthesize(el_val_t body);
 el_val_t ru_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number, el_val_t gender);
 el_val_t ru_conjugate_1st(el_val_t stem, el_val_t tense, el_val_t person, el_val_t number);
@@ -901,6 +958,8 @@ el_val_t rule_id(el_val_t rule);
 el_val_t rule_lhs(el_val_t rule);
 el_val_t rule_rhs(el_val_t rule, el_val_t idx);
 el_val_t rule_rhs_len(el_val_t rule);
+el_val_t run_command_guard(el_val_t cmd, el_val_t root);
+el_val_t run_command_is_readonly(el_val_t cmd);
 el_val_t sa_as_future(el_val_t slot);
 el_val_t sa_as_past(el_val_t slot);
 el_val_t sa_as_present(el_val_t slot);
@@ -936,13 +995,29 @@ el_val_t sa_str_ends(el_val_t s, el_val_t suf);
 el_val_t sa_vad_future(el_val_t slot);
 el_val_t sa_vad_past(el_val_t slot);
 el_val_t sa_vad_present(el_val_t slot);
+el_val_t safety_abuse_phrases(void);
+el_val_t safety_any_match(el_val_t text, el_val_t phrases_json);
+el_val_t safety_augment_system(el_val_t system, el_val_t user_msg);
+el_val_t safety_classify_hard_bell(el_val_t message);
+el_val_t safety_contact_path(void);
+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_detect_positive_level(el_val_t message);
+el_val_t safety_general_hard_phrases(void);
+el_val_t safety_hard_directive(el_val_t hard_type);
 el_val_t safety_log_bell(el_val_t level, el_val_t reason, el_val_t input_summary);
+el_val_t safety_normalize(el_val_t message);
+el_val_t safety_positive_phrases(void);
 el_val_t safety_score_crisis(el_val_t input);
 el_val_t safety_score_danger(el_val_t input);
 el_val_t safety_score_distress_history(el_val_t history);
 el_val_t safety_score_harm(el_val_t input);
 el_val_t safety_screen(el_val_t input, el_val_t history);
+el_val_t safety_self_harm_phrases(void);
+el_val_t safety_soft_directive(void);
+el_val_t safety_soft_phrases(void);
 el_val_t safety_threat_score(el_val_t input, el_val_t history);
+el_val_t safety_threat_to_others_phrases(void);
 el_val_t safety_validate(el_val_t output, el_val_t action);
 el_val_t scan_token(el_val_t s, el_val_t start);
 el_val_t security_research_authorized(void);
@@ -967,13 +1042,20 @@ el_val_t sem_to_spec(el_val_t frame);
 el_val_t sem_to_spec_full(el_val_t frame, el_val_t verb, el_val_t tense, el_val_t aspect);
 el_val_t session_auto_title(el_val_t session_id, el_val_t first_message);
 el_val_t session_create(el_val_t body);
+el_val_t session_create_cleanup(el_val_t session_id);
 el_val_t session_delete(el_val_t session_id);
+el_val_t session_exists(el_val_t session_id);
 el_val_t session_get(el_val_t session_id);
 el_val_t session_hist_load(el_val_t session_id);
 el_val_t session_hist_save(el_val_t session_id, el_val_t hist);
 el_val_t session_list(void);
 el_val_t session_make_content(el_val_t id, el_val_t title, el_val_t created_at, el_val_t updated_at, el_val_t folder);
+el_val_t session_preload_bullets(el_val_t nodes, el_val_t max_bullets, el_val_t snip_len);
 el_val_t session_search(el_val_t query);
+el_val_t session_search_entry(el_val_t node);
+el_val_t session_summary_autogenerate(el_val_t hist);
+el_val_t session_summary_write(el_val_t summary_text);
+el_val_t session_summary_write_dated(el_val_t summary_text, el_val_t label);
 el_val_t session_title_from_message(el_val_t message);
 el_val_t session_update_meta_timestamp(el_val_t session_id);
 el_val_t session_update_patch(el_val_t session_id, el_val_t body);
@@ -1078,6 +1160,9 @@ el_val_t threat_trajectory_check(el_val_t tool_name, el_val_t tool_input);
 el_val_t tier_canonical(void);
 el_val_t tier_episodic(void);
 el_val_t tier_working(void);
+el_val_t tombstone_node(el_val_t id);
+el_val_t tombstoned_id_set(void);
+el_val_t tool_auto_approved(el_val_t tool_name);
 el_val_t txb_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
 el_val_t txb_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t txb_decline_fem(el_val_t noun, el_val_t gram_case, el_val_t number);
@@ -1124,4 +1209,3 @@ el_val_t vocab_by_pos(el_val_t pos);
 el_val_t vocab_lookup(el_val_t word, el_val_t lang_code);
 el_val_t vocab_lookup_en(el_val_t word);
 el_val_t vocab_synonym(el_val_t word, el_val_t lang_register, el_val_t lang_code);
-el_val_t xai_api_key(void);

dist/elp.elh

@@ -1,7 +1,7 @@
 // auto-generated by elc --emit-header — do not edit
 extern fn sem_get(json: String, key: String) -> String
-extern fn generate_frame(frame: Any) -> String
-extern fn generate_frame_lang(frame: Any, lang_code: String) -> String
-extern fn build_form_from_json(semantic_form_json: String, lang_code: String) -> Any
+extern fn generate_frame(frame: [String]) -> String
+extern fn generate_frame_lang(frame: [String], lang_code: String) -> String
+extern fn build_form_from_json(semantic_form_json: String, lang_code: String) -> [String]
 extern fn generate(semantic_form_json: String) -> String
 extern fn generate_lang(semantic_form_json: String, lang_code: String) -> String

dist/grammar.c

@@ -656,8 +656,3 @@ el_val_t generate_tree(el_val_t rule_id_str, el_val_t slots) {
   return 0;
 }
 
-int main(int _argc, char** _argv) {
-  el_runtime_init_args(_argc, _argv);
-  return 0;
-}
-

dist/grammar.elh

@@ -1,22 +1,22 @@
-// auto-generated by elc --emit-header - do not edit
-extern fn slots_get(slots: Any, key: String) -> String
-extern fn slots_set(slots: Any, key: String, val: String) -> Any
-extern fn make_slots(k0: String, v0: String) -> Any
-extern fn make_slots2(k0: String, v0: String, k1: String, v1: String) -> Any
-extern fn make_slots3(k0: String, v0: String, k1: String, v1: String, k2: String, v2: String) -> Any
-extern fn make_slots4(k0: String, v0: String, k1: String, v1: String, k2: String, v2: String, k3: String, v3: String) -> Any
-extern fn make_slots5(k0: String, v0: String, k1: String, v1: String, k2: String, v2: String, k3: String, v3: String, k4: String, v4: String) -> Any
-extern fn rule_id(rule: Any) -> String
-extern fn rule_lhs(rule: Any) -> String
-extern fn rule_rhs_len(rule: Any) -> Int
-extern fn rule_rhs(rule: Any, idx: Int) -> String
-extern fn make_rule(id: String, lhs: String, r0: String) -> Any
-extern fn make_rule2(id: String, lhs: String, r0: String, r1: String) -> Any
-extern fn make_rule3(id: String, lhs: String, r0: String, r1: String, r2: String) -> Any
-extern fn make_rule4(id: String, lhs: String, r0: String, r1: String, r2: String, r3: String) -> Any
-extern fn build_rules() -> Any
-extern fn get_rules() -> Any
-extern fn find_rule(rule_id_str: String) -> Any
+// auto-generated by elc --emit-header — do not edit
+extern fn slots_get(slots: [String], key: String) -> String
+extern fn slots_set(slots: [String], key: String, val: String) -> [String]
+extern fn make_slots(k0: String, v0: String) -> [String]
+extern fn make_slots2(k0: String, v0: String, k1: String, v1: String) -> [String]
+extern fn make_slots3(k0: String, v0: String, k1: String, v1: String, k2: String, v2: String) -> [String]
+extern fn make_slots4(k0: String, v0: String, k1: String, v1: String, k2: String, v2: String, k3: String, v3: String) -> [String]
+extern fn make_slots5(k0: String, v0: String, k1: String, v1: String, k2: String, v2: String, k3: String, v3: String, k4: String, v4: String) -> [String]
+extern fn rule_id(rule: [String]) -> String
+extern fn rule_lhs(rule: [String]) -> String
+extern fn rule_rhs_len(rule: [String]) -> Int
+extern fn rule_rhs(rule: [String], idx: Int) -> String
+extern fn make_rule(id: String, lhs: String, r0: String) -> [String]
+extern fn make_rule2(id: String, lhs: String, r0: String, r1: String) -> [String]
+extern fn make_rule3(id: String, lhs: String, r0: String, r1: String, r2: String) -> [String]
+extern fn make_rule4(id: String, lhs: String, r0: String, r1: String, r2: String, r3: String) -> [String]
+extern fn build_rules() -> [[String]]
+extern fn get_rules() -> [[String]]
+extern fn find_rule(rule_id_str: String) -> [String]
 extern fn make_leaf(label: String, word: String) -> String
 extern fn make_node1(label: String, child0: String) -> String
 extern fn make_node2(label: String, child0: String, child1: String) -> String
@@ -24,15 +24,15 @@ extern fn make_node3(label: String, child0: String, child1: String, child2: Stri
 extern fn make_node4(label: String, child0: String, child1: String, child2: String, child3: String) -> String
 extern fn nlg_is_ws(c: String) -> Bool
 extern fn skip_ws(s: String, pos: Int) -> Int
-extern fn scan_token(s: String, start: Int) -> Any
+extern fn scan_token(s: String, start: Int) -> [String]
 extern fn render_tree(tree: String) -> String
-extern fn gram_word_order(profile: Any) -> String
-extern fn gram_order_constituents(subj: String, verb: String, obj: String, profile: Any) -> String
-extern fn gram_build_vp(verb: String, aux: String, profile: Any) -> String
-extern fn gram_question_strategy(profile: Any) -> String
+extern fn gram_word_order(profile: [String]) -> String
+extern fn gram_order_constituents(subj: String, verb: String, obj: String, profile: [String]) -> String
+extern fn gram_build_vp(verb: String, aux: String, profile: [String]) -> String
+extern fn gram_question_strategy(profile: [String]) -> String
 extern fn is_pronoun(word: String) -> Bool
-extern fn build_np(referent: String, slots: Any) -> String
+extern fn build_np(referent: String, slots: [String]) -> String
 extern fn build_pp(loc: String) -> String
-extern fn build_vp_body(slots: Any) -> String
-extern fn build_vp_from_slots(slots: Any) -> String
-extern fn generate_tree(rule_id_str: String, slots: Any) -> String
+extern fn build_vp_body(slots: [String]) -> String
+extern fn build_vp_from_slots(slots: [String]) -> String
+extern fn generate_tree(rule_id_str: String, slots: [String]) -> String

dist/imprint.c

@@ -70,8 +70,3 @@ el_val_t imprint_unload(void) {
   return 0;
 }
 
-int main(int _argc, char** _argv) {
-  el_runtime_init_args(_argc, _argv);
-  return 0;
-}
-

dist/language-profile.c

@@ -392,8 +392,3 @@ el_val_t lang_code(el_val_t profile) {
   return 0;
 }
 
-int main(int _argc, char** _argv) {
-  el_runtime_init_args(_argc, _argv);
-  return 0;
-}
-

dist/memory.c

@@ -10,6 +10,7 @@ el_val_t mem_remember(el_val_t content, el_val_t tags);
 el_val_t mem_recall(el_val_t query, el_val_t depth);
 el_val_t mem_search(el_val_t query, el_val_t limit);
 el_val_t mem_strengthen(el_val_t node_id);
+el_val_t mem_tombstone(el_val_t node_id);
 el_val_t mem_forget(el_val_t node_id);
 el_val_t mem_consolidate(void);
 el_val_t mem_save(el_val_t path);
@@ -34,7 +35,18 @@ el_val_t tier_canonical(void) {
 }
 
 el_val_t mem_store(el_val_t content, el_val_t label, el_val_t tags) {
-  return engram_node_full(content, EL_STR("Memory"), label, el_from_float(el_from_float(0.5)), el_from_float(el_from_float(0.5)), el_from_float(el_from_float(0.8)), EL_STR("Working"), tags);
+  el_val_t id = engram_node_full(content, EL_STR("Memory"), label, el_from_float(0.5), el_from_float(0.5), el_from_float(0.8), EL_STR("Working"), tags);
+  if (str_eq(id, EL_STR(""))) {
+    println(el_str_concat(EL_STR("[memory] write rejected by engram (empty id): label="), label));
+    return EL_STR("");
+  }
+  el_val_t readback = engram_get_node_json(id);
+  if (str_eq(readback, EL_STR("")) || str_eq(readback, EL_STR("{}"))) {
+    println(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("[memory] WRITE VERIFY FAILED: label="), label), EL_STR(" id=")), id), EL_STR(" \xe2\x80\x94 node absent after write")));
+    return EL_STR("");
+  }
+  println(el_str_concat(el_str_concat(EL_STR("[memory] write verified: "), id), EL_STR(" ok")));
+  return id;
   return 0;
 }
 
@@ -58,22 +70,60 @@ el_val_t mem_strengthen(el_val_t node_id) {
   return 0;
 }
 
+el_val_t mem_tombstone(el_val_t node_id) {
+  el_val_t tags = EL_STR("[\"Tombstone\",\"status:deleted\"]");
+  el_val_t marker = engram_node_full(node_id, EL_STR("Tombstone"), el_str_concat(EL_STR("tombstone:"), node_id), el_from_float(0.01), el_from_float(0.01), el_from_float(1.0), EL_STR("Episodic"), tags);
+  if (!str_eq(marker, EL_STR(""))) {
+    engram_connect(marker, node_id, el_from_float(1.0), EL_STR("tombstones"));
+  }
+  return marker;
+  return 0;
+}
+
 el_val_t mem_forget(el_val_t node_id) {
-  engram_forget(node_id);
+  el_val_t _marker = mem_tombstone(node_id);
   return 0;
 }
 
 el_val_t mem_consolidate(void) {
   el_val_t scanned = engram_node_count();
-  el_val_t dummy = engram_scan_nodes_json(100, 0);
-  el_val_t total_nodes = engram_node_count();
   el_val_t total_edges = engram_edge_count();
-  return el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"scanned\":"), int_to_str(scanned)), EL_STR(",\"total_nodes\":")), int_to_str(total_nodes)), EL_STR(",\"total_edges\":")), int_to_str(total_edges)), EL_STR("}"));
+  el_val_t strengthened = 0;
+  el_val_t wm_top = engram_wm_top_json(10);
+  el_val_t wm_len = json_array_len(wm_top);
+  el_val_t wi = 0;
+  while (wi < wm_len) {
+    el_val_t wm_node = json_array_get(wm_top, wi);
+    el_val_t wm_id = json_get(wm_node, EL_STR("id"));
+    if (!str_eq(wm_id, EL_STR(""))) {
+      engram_strengthen(wm_id);
+      strengthened = (strengthened + 1);
+    }
+    wi = (wi + 1);
+  }
+  el_val_t scan_result = engram_scan_nodes_json(50, 0);
+  el_val_t scan_len = json_array_len(scan_result);
+  el_val_t si = 0;
+  while (si < scan_len) {
+    el_val_t s_node = json_array_get(scan_result, si);
+    el_val_t s_tier = json_get(s_node, EL_STR("tier"));
+    el_val_t s_id = json_get(s_node, EL_STR("id"));
+    if (str_eq(s_tier, EL_STR("Canonical")) && !str_eq(s_id, EL_STR(""))) {
+      engram_strengthen(s_id);
+      strengthened = (strengthened + 1);
+    }
+    si = (si + 1);
+  }
+  el_val_t total_nodes = engram_node_count();
+  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("{\"scanned\":"), int_to_str(scanned)), EL_STR(",\"total_nodes\":")), int_to_str(total_nodes)), EL_STR(",\"total_edges\":")), int_to_str(total_edges)), EL_STR(",\"strengthened\":")), int_to_str(strengthened)), EL_STR("}"));
   return 0;
 }
 
 el_val_t mem_save(el_val_t path) {
-  engram_save(path);
+  el_val_t saved = engram_save(path);
+  if (saved == 0) {
+    println(el_str_concat(el_str_concat(EL_STR("[memory] mem_save: engram_save failed for "), path), EL_STR(" \xe2\x80\x94 snapshot may be incomplete")));
+  }
   return 0;
 }
 
@@ -104,9 +154,56 @@ el_val_t mem_boot_count_get(void) {
 el_val_t mem_boot_count_inc(void) {
   el_val_t current = mem_boot_count_get();
   el_val_t next = (current + 1);
+  el_val_t old_results = engram_search_json(EL_STR("soul:boot_count"), 50);
+  if (!str_eq(old_results, EL_STR("")) && !str_eq(old_results, EL_STR("[]"))) {
+    el_val_t old_len = json_array_len(old_results);
+    el_val_t oi = 0;
+    while (oi < old_len) {
+      el_val_t old_node = json_array_get(old_results, oi);
+      el_val_t old_id = json_get(old_node, EL_STR("id"));
+      if (!str_eq(old_id, EL_STR(""))) {
+        engram_forget(old_id);
+      }
+      oi = (oi + 1);
+    }
+  }
   el_val_t content = el_str_concat(EL_STR("soul:boot_count:"), int_to_str(next));
   el_val_t tags = EL_STR("[\"soul-meta\",\"boot-counter\"]");
-  el_val_t discard = engram_node_full(content, EL_STR("Memory"), EL_STR("soul:boot_count"), el_from_float(el_from_float(0.9)), el_from_float(el_from_float(0.9)), el_from_float(el_from_float(1.0)), EL_STR("Canonical"), tags);
+  el_val_t boot_node_id = engram_node_full(content, EL_STR("Memory"), EL_STR("soul:boot_count"), el_from_float(0.55), el_from_float(0.2), el_from_float(1.0), EL_STR("Working"), tags);
+  if (str_eq(boot_node_id, EL_STR(""))) {
+    println(el_str_concat(el_str_concat(EL_STR("[memory] mem_boot_count_inc: write rejected (empty id) \xe2\x80\x94 boot counter node lost (count="), int_to_str(next)), EL_STR(")")));
+    return next;
+  }
+  el_val_t boot_readback = engram_get_node_json(boot_node_id);
+  if (str_eq(boot_readback, EL_STR("")) || str_eq(boot_readback, EL_STR("{}"))) {
+    println(el_str_concat(el_str_concat(el_str_concat(EL_STR("[memory] mem_boot_count_inc: WRITE VERIFY FAILED id="), boot_node_id), EL_STR(" count=")), int_to_str(next)));
+  }
+  el_val_t wb_url = env(EL_STR("ENGRAM_URL"));
+  el_val_t wb_key = env(EL_STR("ENGRAM_API_KEY"));
+  if (!str_eq(wb_url, EL_STR("")) && !str_eq(wb_key, EL_STR(""))) {
+    el_val_t auth_body = el_str_concat(el_str_concat(EL_STR("{\"_auth\":\""), json_safe(wb_key)), EL_STR("\"}"));
+    el_val_t srv_old = http_get(el_str_concat(wb_url, EL_STR("/api/search?q=soul:boot_count&limit=20")));
+    if (!str_eq(srv_old, EL_STR("")) && !str_eq(srv_old, EL_STR("[]"))) {
+      el_val_t srv_len = json_array_len(srv_old);
+      el_val_t si = 0;
+      while (si < srv_len) {
+        el_val_t srv_node = json_array_get(srv_old, si);
+        el_val_t srv_content = json_get(srv_node, EL_STR("content"));
+        if (str_starts_with(srv_content, EL_STR("soul:boot_count:"))) {
+          el_val_t srv_id = json_get(srv_node, EL_STR("id"));
+          if (!str_eq(srv_id, EL_STR(""))) {
+            http_delete_json(el_str_concat(el_str_concat(wb_url, EL_STR("/api/nodes/")), srv_id), auth_body);
+          }
+        }
+        si = (si + 1);
+      }
+    }
+    el_val_t wb_body = el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"content\":\""), content), EL_STR("\",\"node_type\":\"Memory\",\"label\":\"soul:boot_count\",\"salience\":0.55,\"importance\":0.2,\"tier\":\"Working\",\"tags\":\"[\\\"soul-meta\\\",\\\"boot-counter\\\"]\",\"_auth\":\"")), json_safe(wb_key)), EL_STR("\"}"));
+    el_val_t wb_resp = http_post_json(el_str_concat(wb_url, EL_STR("/api/nodes")), wb_body);
+    if (str_contains(wb_resp, EL_STR("\"error\""))) {
+      println(el_str_concat(EL_STR("[memory] mem_boot_count_inc: HTTP write-back failed (count in-memory only): "), wb_resp));
+    }
+  }
   return next;
   return 0;
 }
@@ -118,12 +215,11 @@ el_val_t mem_emit_state_event(el_val_t trigger, el_val_t kind, el_val_t content)
   el_val_t safe_content = str_replace(content, EL_STR("\""), EL_STR("'"));
   el_val_t payload = 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("{\"trigger\":\""), safe_trigger), EL_STR("\"")), EL_STR(",\"kind\":\"")), kind), EL_STR("\"")), EL_STR(",\"content\":\"")), safe_content), EL_STR("\"")), EL_STR(",\"boot\":")), int_to_str(boot)), EL_STR(",\"ts\":")), int_to_str(ts)), EL_STR("}"));
   el_val_t tags = EL_STR("[\"internal-state\",\"pre-reasoning\",\"InternalStateEvent\"]");
-  return engram_node_full(payload, EL_STR("InternalStateEvent"), el_str_concat(EL_STR("state-event:"), kind), el_from_float(el_from_float(0.85)), el_from_float(el_from_float(0.8)), el_from_float(el_from_float(0.9)), EL_STR("Episodic"), tags);
-  return 0;
-}
-
-int main(int _argc, char** _argv) {
-  el_runtime_init_args(_argc, _argv);
+  el_val_t event_id = engram_node_full(payload, EL_STR("InternalStateEvent"), el_str_concat(EL_STR("state-event:"), kind), el_from_float(0.85), el_from_float(0.8), el_from_float(0.9), EL_STR("Episodic"), tags);
+  if (str_eq(event_id, EL_STR(""))) {
+    println(el_str_concat(EL_STR("[memory] mem_emit_state_event: write rejected (empty id): kind="), kind));
+  }
+  return event_id;
   return 0;
 }
 

dist/neuron-api.c

@@ -10,6 +10,7 @@ el_val_t mem_remember(el_val_t content, el_val_t tags);
 el_val_t mem_recall(el_val_t query, el_val_t depth);
 el_val_t mem_search(el_val_t query, el_val_t limit);
 el_val_t mem_strengthen(el_val_t node_id);
+el_val_t mem_tombstone(el_val_t node_id);
 el_val_t mem_forget(el_val_t node_id);
 el_val_t mem_consolidate(void);
 el_val_t mem_save(el_val_t path);
@@ -26,9 +27,22 @@ el_val_t api_ok(el_val_t extra);
 el_val_t api_err(el_val_t msg);
 el_val_t api_nonempty(el_val_t s);
 el_val_t api_or_empty(el_val_t s);
+el_val_t api_num_or_zero(el_val_t obj, el_val_t key);
+el_val_t api_utf8_trunc(el_val_t s, el_val_t n);
+el_val_t api_compact_node(el_val_t node, el_val_t snip);
+el_val_t api_compact_node_array(el_val_t raw, el_val_t max_items, el_val_t snip);
+el_val_t api_compact_activated(el_val_t raw, el_val_t max_items, el_val_t snip);
+el_val_t api_persisted(el_val_t id);
+el_val_t api_not_persisted(el_val_t id);
+el_val_t tombstone_node(el_val_t id);
+el_val_t tombstoned_id_set(void);
+el_val_t memory_hide_tombstoned(el_val_t raw, el_val_t path);
 el_val_t handle_api_begin_session(el_val_t body);
 el_val_t handle_api_compile_ctx(el_val_t body);
 el_val_t handle_api_remember(el_val_t body);
+el_val_t handle_api_node_create(el_val_t body);
+el_val_t handle_api_node_delete(el_val_t body);
+el_val_t handle_api_node_update(el_val_t body);
 el_val_t handle_api_recall(el_val_t method, el_val_t path, el_val_t body);
 el_val_t handle_api_search_knowledge(el_val_t method, el_val_t path, el_val_t body);
 el_val_t handle_api_browse_knowledge(el_val_t path, el_val_t body);
@@ -45,114 +59,12 @@ el_val_t handle_api_inspect_graph(el_val_t method, el_val_t path, el_val_t body)
 el_val_t handle_api_link_entities(el_val_t body);
 el_val_t handle_api_forget(el_val_t body);
 el_val_t handle_api_evolve_memory(el_val_t body);
+el_val_t handle_api_memory_delete(el_val_t body);
+el_val_t handle_api_memory_update(el_val_t body);
 el_val_t handle_api_cultivate(el_val_t body);
 el_val_t handle_api_list_typed(el_val_t node_type, el_val_t path, el_val_t body);
 el_val_t handle_api_consolidate(el_val_t body);
 
-el_val_t tier_working(void) {
-  return EL_STR("Working");
-  return 0;
-}
-
-el_val_t tier_episodic(void) {
-  return EL_STR("Episodic");
-  return 0;
-}
-
-el_val_t tier_canonical(void) {
-  return EL_STR("Canonical");
-  return 0;
-}
-
-el_val_t mem_store(el_val_t content, el_val_t label, el_val_t tags) {
-  return engram_node_full(content, EL_STR("Memory"), label, el_from_float(el_from_float(0.5)), el_from_float(el_from_float(0.5)), el_from_float(el_from_float(0.8)), EL_STR("Working"), tags);
-  return 0;
-}
-
-el_val_t mem_remember(el_val_t content, el_val_t tags) {
-  return mem_store(content, EL_STR("soul-memory"), tags);
-  return 0;
-}
-
-el_val_t mem_recall(el_val_t query, el_val_t depth) {
-  return engram_activate_json(query, depth);
-  return 0;
-}
-
-el_val_t mem_search(el_val_t query, el_val_t limit) {
-  return engram_search_json(query, limit);
-  return 0;
-}
-
-el_val_t mem_strengthen(el_val_t node_id) {
-  engram_strengthen(node_id);
-  return 0;
-}
-
-el_val_t mem_forget(el_val_t node_id) {
-  engram_forget(node_id);
-  return 0;
-}
-
-el_val_t mem_consolidate(void) {
-  el_val_t scanned = engram_node_count();
-  el_val_t dummy = engram_scan_nodes_json(100, 0);
-  el_val_t total_nodes = engram_node_count();
-  el_val_t total_edges = engram_edge_count();
-  return el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"scanned\":"), int_to_str(scanned)), EL_STR(",\"total_nodes\":")), int_to_str(total_nodes)), EL_STR(",\"total_edges\":")), int_to_str(total_edges)), EL_STR("}"));
-  return 0;
-}
-
-el_val_t mem_save(el_val_t path) {
-  engram_save(path);
-  return 0;
-}
-
-el_val_t mem_load(el_val_t path) {
-  engram_load(path);
-  return 0;
-}
-
-el_val_t mem_boot_count_get(void) {
-  el_val_t results = engram_search_json(EL_STR("soul:boot_count"), 3);
-  if (str_eq(results, EL_STR(""))) {
-    return 0;
-  }
-  if (str_eq(results, EL_STR("[]"))) {
-    return 0;
-  }
-  el_val_t node = json_array_get(results, 0);
-  el_val_t content = json_get(node, EL_STR("content"));
-  el_val_t prefix = EL_STR("soul:boot_count:");
-  if (!str_starts_with(content, prefix)) {
-    return 0;
-  }
-  el_val_t num_str = str_slice(content, str_len(prefix), str_len(content));
-  return str_to_int(num_str);
-  return 0;
-}
-
-el_val_t mem_boot_count_inc(void) {
-  el_val_t current = mem_boot_count_get();
-  el_val_t next = (current + 1);
-  el_val_t content = el_str_concat(EL_STR("soul:boot_count:"), int_to_str(next));
-  el_val_t tags = EL_STR("[\"soul-meta\",\"boot-counter\"]");
-  el_val_t discard = engram_node_full(content, EL_STR("Memory"), EL_STR("soul:boot_count"), el_from_float(el_from_float(0.9)), el_from_float(el_from_float(0.9)), el_from_float(el_from_float(1.0)), EL_STR("Canonical"), tags);
-  return next;
-  return 0;
-}
-
-el_val_t mem_emit_state_event(el_val_t trigger, el_val_t kind, el_val_t content) {
-  el_val_t boot = mem_boot_count_get();
-  el_val_t ts = time_now();
-  el_val_t safe_trigger = str_replace(trigger, EL_STR("\""), EL_STR("'"));
-  el_val_t safe_content = str_replace(content, EL_STR("\""), EL_STR("'"));
-  el_val_t payload = 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("{\"trigger\":\""), safe_trigger), EL_STR("\"")), EL_STR(",\"kind\":\"")), kind), EL_STR("\"")), EL_STR(",\"content\":\"")), safe_content), EL_STR("\"")), EL_STR(",\"boot\":")), int_to_str(boot)), EL_STR(",\"ts\":")), int_to_str(ts)), EL_STR("}"));
-  el_val_t tags = EL_STR("[\"internal-state\",\"pre-reasoning\",\"InternalStateEvent\"]");
-  return engram_node_full(payload, EL_STR("InternalStateEvent"), el_str_concat(EL_STR("state-event:"), kind), el_from_float(el_from_float(0.85)), el_from_float(el_from_float(0.8)), el_from_float(el_from_float(0.9)), EL_STR("Episodic"), tags);
-  return 0;
-}
-
 el_val_t is_protected_node(el_val_t id) {
   if (str_eq(id, EL_STR("kn-efeb4a5b-5aff-4759-8a97-7233099be6ee"))) {
     return 1;
@@ -272,21 +184,168 @@ el_val_t api_or_empty(el_val_t s) {
   return 0;
 }
 
+el_val_t api_num_or_zero(el_val_t obj, el_val_t key) {
+  el_val_t v = json_get_raw(obj, key);
+  if (str_eq(v, EL_STR(""))) {
+    return EL_STR("0");
+  }
+  return v;
+  return 0;
+}
+
+el_val_t api_utf8_trunc(el_val_t s, el_val_t n) {
+  if (str_len(s) <= n) {
+    return s;
+  }
+  el_val_t cut = n;
+  el_val_t scanning = 1;
+  while (scanning && (cut > 0)) {
+    el_val_t b = str_char_code(s, cut);
+    el_val_t is_cont = ((b >= 128) && (b < 192));
+    cut = ({ el_val_t _if_result_1 = 0; if (is_cont) { _if_result_1 = ((cut - 1)); } else { _if_result_1 = (cut); } _if_result_1; });
+    scanning = is_cont;
+  }
+  return str_slice(s, 0, cut);
+  return 0;
+}
+
+el_val_t api_compact_node(el_val_t node, el_val_t snip) {
+  el_val_t id = json_get(node, EL_STR("id"));
+  el_val_t ntype = json_get(node, EL_STR("node_type"));
+  el_val_t label = json_get(node, EL_STR("label"));
+  el_val_t tier = json_get(node, EL_STR("tier"));
+  el_val_t content = json_get(node, EL_STR("content"));
+  el_val_t snippet = api_utf8_trunc(content, snip);
+  el_val_t trunc_str = ({ el_val_t _if_result_2 = 0; if ((str_len(content) > snip)) { _if_result_2 = (EL_STR("true")); } else { _if_result_2 = (EL_STR("false")); } _if_result_2; });
+  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_concat(el_str_concat(el_str_concat(EL_STR("{\"id\":\""), api_json_escape(id)), EL_STR("\"")), EL_STR(",\"node_type\":\"")), api_json_escape(ntype)), EL_STR("\"")), EL_STR(",\"label\":\"")), api_json_escape(label)), EL_STR("\"")), EL_STR(",\"tier\":\"")), api_json_escape(tier)), EL_STR("\"")), EL_STR(",\"importance\":")), api_num_or_zero(node, EL_STR("importance"))), EL_STR(",\"salience\":")), api_num_or_zero(node, EL_STR("salience"))), EL_STR(",\"content\":\"")), api_json_escape(snippet)), EL_STR("\"")), EL_STR(",\"content_truncated\":")), trunc_str), EL_STR("}"));
+  return 0;
+}
+
+el_val_t api_compact_node_array(el_val_t raw, el_val_t max_items, el_val_t snip) {
+  if (!api_nonempty(raw)) {
+    return EL_STR("[]");
+  }
+  el_val_t n = json_array_len(raw);
+  el_val_t cap = ({ el_val_t _if_result_3 = 0; if ((n < max_items)) { _if_result_3 = (n); } else { _if_result_3 = (max_items); } _if_result_3; });
+  el_val_t out = EL_STR("[");
+  el_val_t i = 0;
+  while (i < cap) {
+    el_val_t node = json_array_get(raw, i);
+    el_val_t sep = ({ el_val_t _if_result_4 = 0; if ((i == 0)) { _if_result_4 = (EL_STR("")); } else { _if_result_4 = (EL_STR(",")); } _if_result_4; });
+    out = el_str_concat(el_str_concat(out, sep), api_compact_node(node, snip));
+    i = (i + 1);
+  }
+  return el_str_concat(out, EL_STR("]"));
+  return 0;
+}
+
+el_val_t api_compact_activated(el_val_t raw, el_val_t max_items, el_val_t snip) {
+  if (!api_nonempty(raw)) {
+    return EL_STR("[]");
+  }
+  el_val_t n = json_array_len(raw);
+  el_val_t cap = ({ el_val_t _if_result_5 = 0; if ((n < max_items)) { _if_result_5 = (n); } else { _if_result_5 = (max_items); } _if_result_5; });
+  el_val_t out = EL_STR("[");
+  el_val_t i = 0;
+  while (i < cap) {
+    el_val_t el = json_array_get(raw, i);
+    el_val_t node = json_get_raw(el, EL_STR("node"));
+    el_val_t sep = ({ el_val_t _if_result_6 = 0; if ((i == 0)) { _if_result_6 = (EL_STR("")); } else { _if_result_6 = (EL_STR(",")); } _if_result_6; });
+    out = 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(out, sep), EL_STR("{\"node\":")), api_compact_node(node, snip)), EL_STR(",\"activation_strength\":")), api_num_or_zero(el, EL_STR("activation_strength"))), EL_STR(",\"working_memory_weight\":")), api_num_or_zero(el, EL_STR("working_memory_weight"))), EL_STR(",\"epistemic_confidence\":")), api_num_or_zero(el, EL_STR("epistemic_confidence"))), EL_STR(",\"hops\":")), api_num_or_zero(el, EL_STR("hops"))), EL_STR(",\"promoted\":")), api_num_or_zero(el, EL_STR("promoted"))), EL_STR("}"));
+    i = (i + 1);
+  }
+  return el_str_concat(out, EL_STR("]"));
+  return 0;
+}
+
+el_val_t api_persisted(el_val_t id) {
+  if (str_eq(id, EL_STR(""))) {
+    return 0;
+  }
+  el_val_t node = engram_get_node_json(id);
+  return ((!str_eq(node, EL_STR("")) && !str_eq(node, EL_STR("null"))) && !str_eq(node, EL_STR("{}")));
+  return 0;
+}
+
+el_val_t api_not_persisted(el_val_t id) {
+  return el_str_concat(el_str_concat(EL_STR("{\"ok\":false,\"error\":\"write_not_persisted\",\"id\":\""), id), EL_STR("\"}"));
+  return 0;
+}
+
+el_val_t tombstone_node(el_val_t id) {
+  return mem_tombstone(id);
+  return 0;
+}
+
+el_val_t tombstoned_id_set(void) {
+  el_val_t markers = engram_scan_nodes_by_type_json(EL_STR("Tombstone"), 5000, 0);
+  if (str_eq(markers, EL_STR("")) || str_eq(markers, EL_STR("[]"))) {
+    return EL_STR("");
+  }
+  el_val_t n = json_array_len(markers);
+  el_val_t acc = EL_STR("|");
+  el_val_t i = 0;
+  while (i < n) {
+    el_val_t m = json_array_get(markers, i);
+    el_val_t tid = json_get(m, EL_STR("content"));
+    acc = ({ el_val_t _if_result_7 = 0; if (str_eq(tid, EL_STR(""))) { _if_result_7 = (acc); } else { _if_result_7 = (el_str_concat(el_str_concat(acc, tid), EL_STR("|"))); } _if_result_7; });
+    i = (i + 1);
+  }
+  return acc;
+  return 0;
+}
+
+el_val_t memory_hide_tombstoned(el_val_t raw, el_val_t path) {
+  if (str_contains(path, EL_STR("include_deleted"))) {
+    return raw;
+  }
+  if (str_eq(raw, EL_STR("")) || str_eq(raw, EL_STR("[]"))) {
+    return raw;
+  }
+  el_val_t dead = tombstoned_id_set();
+  if (str_eq(dead, EL_STR(""))) {
+    return raw;
+  }
+  el_val_t n = json_array_len(raw);
+  if (n > 1000) {
+    return raw;
+  }
+  el_val_t out = EL_STR("[");
+  el_val_t first = 1;
+  el_val_t i = 0;
+  while (i < n) {
+    el_val_t node = json_array_get(raw, i);
+    el_val_t nid = json_get(node, EL_STR("id"));
+    el_val_t ntype = json_get(node, EL_STR("node_type"));
+    el_val_t is_dead = (!str_eq(nid, EL_STR("")) && str_contains(dead, el_str_concat(el_str_concat(EL_STR("|"), nid), EL_STR("|"))));
+    el_val_t keep = (!str_eq(ntype, EL_STR("Tombstone")) && !is_dead);
+    out = ({ el_val_t _if_result_8 = 0; if (keep) { _if_result_8 = (({ el_val_t _if_result_9 = 0; if (first) { _if_result_9 = (el_str_concat(out, node)); } else { _if_result_9 = (el_str_concat(el_str_concat(out, EL_STR(",")), node)); } _if_result_9; })); } else { _if_result_8 = (out); } _if_result_8; });
+    first = ({ el_val_t _if_result_10 = 0; if (keep) { _if_result_10 = (0); } else { _if_result_10 = (first); } _if_result_10; });
+    i = (i + 1);
+  }
+  return el_str_concat(out, EL_STR("]"));
+  return 0;
+}
+
 el_val_t handle_api_begin_session(el_val_t body) {
   el_val_t stats = engram_stats_json();
-  el_val_t activated = engram_activate_json(EL_STR("session start recent memory important"), 2);
-  el_val_t self_nbrs = engram_neighbors_json(EL_STR("kn-efeb4a5b-5aff-4759-8a97-7233099be6ee"), 1, EL_STR("both"));
-  el_val_t state_events = engram_scan_nodes_by_type_json(EL_STR("InternalStateEvent"), 5, 0);
-  el_val_t recent = engram_scan_nodes_json(10, 0);
-  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("{\"stats\":"), stats), EL_STR(",\"recent\":")), api_or_empty(recent)), EL_STR(",\"activated\":")), api_or_empty(activated)), EL_STR(",\"self_neighbors\":")), api_or_empty(self_nbrs)), EL_STR(",\"recent_state_events\":")), api_or_empty(state_events)), EL_STR("}"));
+  el_val_t activated_raw = engram_activate_json(EL_STR("session start recent memory important"), 1);
+  el_val_t activated = api_compact_activated(activated_raw, 8, 240);
+  el_val_t state_events_raw = engram_scan_nodes_by_type_json(EL_STR("InternalStateEvent"), 5, 0);
+  el_val_t state_events = api_compact_node_array(state_events_raw, 5, 500);
+  el_val_t recent_raw = engram_scan_nodes_json(10, 0);
+  el_val_t recent = api_compact_node_array(recent_raw, 10, 240);
+  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("{\"stats\":"), stats), EL_STR(",\"recent\":")), recent), EL_STR(",\"activated\":")), activated), EL_STR(",\"self_neighbors\":[]")), EL_STR(",\"recent_state_events\":")), state_events), EL_STR("}"));
   return 0;
 }
 
 el_val_t handle_api_compile_ctx(el_val_t body) {
   el_val_t stats = engram_stats_json();
-  el_val_t activated = engram_activate_json(EL_STR("active work context current task in progress"), 2);
-  el_val_t recent = engram_scan_nodes_json(20, 0);
-  return el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"stats\":"), stats), EL_STR(",\"recent_nodes\":")), api_or_empty(recent)), EL_STR(",\"activated\":")), api_or_empty(activated)), EL_STR("}"));
+  el_val_t activated_raw = engram_activate_json(EL_STR("active work context current task in progress"), 2);
+  el_val_t activated = api_compact_activated(activated_raw, 10, 240);
+  el_val_t recent_raw = engram_scan_nodes_json(20, 0);
+  el_val_t recent = api_compact_node_array(recent_raw, 20, 240);
+  return el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"stats\":"), stats), EL_STR(",\"recent_nodes\":")), recent), EL_STR(",\"activated\":")), activated), EL_STR("}"));
   return 0;
 }
 
@@ -298,22 +357,102 @@ el_val_t handle_api_remember(el_val_t body) {
   el_val_t importance = json_get(body, EL_STR("importance"));
   el_val_t tags_raw = json_get(body, EL_STR("tags"));
   el_val_t project = json_get(body, EL_STR("project"));
-  el_val_t sal_str = ({ el_val_t _if_result_1 = 0; if (str_eq(importance, EL_STR("critical"))) { _if_result_1 = (EL_STR("0.95")); } else { _if_result_1 = (({ el_val_t _if_result_2 = 0; if (str_eq(importance, EL_STR("high"))) { _if_result_2 = (EL_STR("0.75")); } else { _if_result_2 = (({ el_val_t _if_result_3 = 0; if (str_eq(importance, EL_STR("low"))) { _if_result_3 = (EL_STR("0.25")); } else { _if_result_3 = (EL_STR("0.50")); } _if_result_3; })); } _if_result_2; })); } _if_result_1; });
-  el_val_t sal = ({ el_val_t _if_result_4 = 0; if (str_eq(sal_str, EL_STR("0.95"))) { _if_result_4 = (el_from_float(0.95)); } else { _if_result_4 = (({ el_val_t _if_result_5 = 0; if (str_eq(sal_str, EL_STR("0.75"))) { _if_result_5 = (el_from_float(0.75)); } else { _if_result_5 = (({ el_val_t _if_result_6 = 0; if (str_eq(sal_str, EL_STR("0.25"))) { _if_result_6 = (el_from_float(0.25)); } else { _if_result_6 = (el_from_float(0.5)); } _if_result_6; })); } _if_result_5; })); } _if_result_4; });
-  el_val_t base_tags = ({ el_val_t _if_result_7 = 0; if (str_eq(tags_raw, EL_STR(""))) { _if_result_7 = (EL_STR("[\"Memory\"]")); } else { _if_result_7 = (tags_raw); } _if_result_7; });
-  el_val_t final_tags = ({ el_val_t _if_result_8 = 0; if (str_eq(project, EL_STR(""))) { _if_result_8 = (base_tags); } else { el_val_t inner = str_slice(base_tags, 1, (str_len(base_tags) - 1)); _if_result_8 = (el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("["), inner), EL_STR(",\"project:")), project), EL_STR("\"]"))); } _if_result_8; });
-  el_val_t id = engram_node_full(content, EL_STR("Memory"), EL_STR("memory:remembered"), el_from_float(sal), el_from_float(sal), el_from_float(el_from_float(0.9)), EL_STR("Episodic"), final_tags);
+  el_val_t sal_str = ({ el_val_t _if_result_11 = 0; if (str_eq(importance, EL_STR("critical"))) { _if_result_11 = (EL_STR("0.95")); } else { _if_result_11 = (({ el_val_t _if_result_12 = 0; if (str_eq(importance, EL_STR("high"))) { _if_result_12 = (EL_STR("0.75")); } else { _if_result_12 = (({ el_val_t _if_result_13 = 0; if (str_eq(importance, EL_STR("low"))) { _if_result_13 = (EL_STR("0.25")); } else { _if_result_13 = (EL_STR("0.50")); } _if_result_13; })); } _if_result_12; })); } _if_result_11; });
+  el_val_t sal = ({ el_val_t _if_result_14 = 0; if (str_eq(sal_str, EL_STR("0.95"))) { _if_result_14 = (el_from_float(0.95)); } else { _if_result_14 = (({ el_val_t _if_result_15 = 0; if (str_eq(sal_str, EL_STR("0.75"))) { _if_result_15 = (el_from_float(0.75)); } else { _if_result_15 = (({ el_val_t _if_result_16 = 0; if (str_eq(sal_str, EL_STR("0.25"))) { _if_result_16 = (el_from_float(0.25)); } else { _if_result_16 = (el_from_float(0.5)); } _if_result_16; })); } _if_result_15; })); } _if_result_14; });
+  el_val_t base_tags = ({ el_val_t _if_result_17 = 0; if (str_eq(tags_raw, EL_STR(""))) { _if_result_17 = (EL_STR("[\"Memory\"]")); } else { _if_result_17 = (tags_raw); } _if_result_17; });
+  el_val_t final_tags = ({ el_val_t _if_result_18 = 0; if (str_eq(project, EL_STR(""))) { _if_result_18 = (base_tags); } else { el_val_t inner = str_slice(base_tags, 1, (str_len(base_tags) - 1)); _if_result_18 = (el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("["), inner), EL_STR(",\"project:")), project), EL_STR("\"]"))); } _if_result_18; });
+  el_val_t id = engram_node_full(content, EL_STR("Memory"), EL_STR("memory:remembered"), sal, sal, el_from_float(0.9), EL_STR("Episodic"), final_tags);
+  if (!api_persisted(id)) {
+    return api_not_persisted(id);
+  }
   return el_str_concat(el_str_concat(EL_STR("{\"id\":\""), id), EL_STR("\",\"ok\":true}"));
   return 0;
 }
 
+el_val_t handle_api_node_create(el_val_t body) {
+  el_val_t content = json_get(body, EL_STR("content"));
+  if (str_eq(content, EL_STR(""))) {
+    return api_err(EL_STR("content is required"));
+  }
+  el_val_t nt_raw = json_get(body, EL_STR("node_type"));
+  el_val_t node_type = ({ el_val_t _if_result_19 = 0; if (str_eq(nt_raw, EL_STR(""))) { _if_result_19 = (EL_STR("Memory")); } else { _if_result_19 = (nt_raw); } _if_result_19; });
+  el_val_t label_raw = json_get(body, EL_STR("label"));
+  el_val_t label = ({ el_val_t _if_result_20 = 0; if (str_eq(label_raw, EL_STR(""))) { _if_result_20 = (EL_STR("node:created")); } else { _if_result_20 = (label_raw); } _if_result_20; });
+  el_val_t tier_raw = json_get(body, EL_STR("tier"));
+  el_val_t tier = ({ el_val_t _if_result_21 = 0; if (str_eq(tier_raw, EL_STR(""))) { _if_result_21 = (EL_STR("Episodic")); } else { _if_result_21 = (tier_raw); } _if_result_21; });
+  el_val_t tags_raw = json_get(body, EL_STR("tags"));
+  el_val_t tags = ({ el_val_t _if_result_22 = 0; if (str_eq(tags_raw, EL_STR(""))) { _if_result_22 = (el_str_concat(el_str_concat(EL_STR("[\""), node_type), EL_STR("\"]"))); } else { _if_result_22 = (tags_raw); } _if_result_22; });
+  el_val_t importance = json_get(body, EL_STR("importance"));
+  el_val_t sal = ({ el_val_t _if_result_23 = 0; if (str_eq(importance, EL_STR("critical"))) { _if_result_23 = (el_from_float(0.95)); } else { _if_result_23 = (({ el_val_t _if_result_24 = 0; if (str_eq(importance, EL_STR("high"))) { _if_result_24 = (el_from_float(0.75)); } else { _if_result_24 = (({ el_val_t _if_result_25 = 0; if (str_eq(importance, EL_STR("low"))) { _if_result_25 = (el_from_float(0.25)); } else { _if_result_25 = (el_from_float(0.5)); } _if_result_25; })); } _if_result_24; })); } _if_result_23; });
+  el_val_t id = engram_node_full(content, node_type, label, sal, sal, el_from_float(0.9), tier, tags);
+  if (!api_persisted(id)) {
+    return api_not_persisted(id);
+  }
+  return el_str_concat(el_str_concat(EL_STR("{\"id\":\""), id), EL_STR("\",\"ok\":true}"));
+  return 0;
+}
+
+el_val_t handle_api_node_delete(el_val_t body) {
+  el_val_t id = json_get(body, EL_STR("id"));
+  if (str_eq(id, EL_STR(""))) {
+    return api_err(EL_STR("id is required"));
+  }
+  if (is_protected_node(id)) {
+    return api_err_protected(id);
+  }
+  el_val_t existing = engram_get_node_json(id);
+  if (str_eq(existing, EL_STR("{}"))) {
+    return api_err(el_str_concat(EL_STR("node not found: "), id));
+  }
+  el_val_t marker = tombstone_node(id);
+  if (str_eq(marker, EL_STR(""))) {
+    return api_err(el_str_concat(EL_STR("tombstone failed: "), id));
+  }
+  return el_str_concat(el_str_concat(EL_STR("{\"ok\":true,\"id\":\""), id), EL_STR("\",\"tombstoned\":true}"));
+  return 0;
+}
+
+el_val_t handle_api_node_update(el_val_t body) {
+  el_val_t id = json_get(body, EL_STR("id"));
+  if (str_eq(id, EL_STR(""))) {
+    return api_err(EL_STR("id is required"));
+  }
+  if (!api_persisted(id)) {
+    return el_str_concat(el_str_concat(EL_STR("{\"ok\":false,\"error\":\"not_found\",\"id\":\""), id), EL_STR("\"}"));
+  }
+  el_val_t old = engram_get_node_json(id);
+  el_val_t body_content = json_get(body, EL_STR("content"));
+  el_val_t content = ({ el_val_t _if_result_26 = 0; if (str_eq(body_content, EL_STR(""))) { _if_result_26 = (json_get(old, EL_STR("content"))); } else { _if_result_26 = (body_content); } _if_result_26; });
+  el_val_t body_nt = json_get(body, EL_STR("node_type"));
+  el_val_t old_nt = json_get(old, EL_STR("node_type"));
+  el_val_t node_type = ({ el_val_t _if_result_27 = 0; if (!str_eq(body_nt, EL_STR(""))) { _if_result_27 = (body_nt); } else { _if_result_27 = (({ el_val_t _if_result_28 = 0; if (!str_eq(old_nt, EL_STR(""))) { _if_result_28 = (old_nt); } else { _if_result_28 = (EL_STR("Memory")); } _if_result_28; })); } _if_result_27; });
+  el_val_t body_label = json_get(body, EL_STR("label"));
+  el_val_t old_label = json_get(old, EL_STR("label"));
+  el_val_t label = ({ el_val_t _if_result_29 = 0; if (!str_eq(body_label, EL_STR(""))) { _if_result_29 = (body_label); } else { _if_result_29 = (({ el_val_t _if_result_30 = 0; if (!str_eq(old_label, EL_STR(""))) { _if_result_30 = (old_label); } else { _if_result_30 = (EL_STR("node:updated")); } _if_result_30; })); } _if_result_29; });
+  el_val_t body_tier = json_get(body, EL_STR("tier"));
+  el_val_t old_tier = json_get(old, EL_STR("tier"));
+  el_val_t tier = ({ el_val_t _if_result_31 = 0; if (!str_eq(body_tier, EL_STR(""))) { _if_result_31 = (body_tier); } else { _if_result_31 = (({ el_val_t _if_result_32 = 0; if (!str_eq(old_tier, EL_STR(""))) { _if_result_32 = (old_tier); } else { _if_result_32 = (EL_STR("Episodic")); } _if_result_32; })); } _if_result_31; });
+  el_val_t body_tags = json_get(body, EL_STR("tags"));
+  el_val_t tags = ({ el_val_t _if_result_33 = 0; if (str_eq(body_tags, EL_STR(""))) { _if_result_33 = (el_str_concat(el_str_concat(EL_STR("[\""), node_type), EL_STR("\"]"))); } else { _if_result_33 = (body_tags); } _if_result_33; });
+  el_val_t new_id = 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_connect(new_id, id, el_from_float(0.9), EL_STR("supersedes"));
+  return el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"id\":\""), new_id), EL_STR("\",\"supersedes\":\"")), id), EL_STR("\",\"ok\":true}"));
+  return 0;
+}
+
 el_val_t handle_api_recall(el_val_t method, el_val_t path, el_val_t body) {
-  el_val_t q = ({ el_val_t _if_result_9 = 0; if (str_eq(method, EL_STR("GET"))) { _if_result_9 = (api_query_param(path, EL_STR("query"))); } else { _if_result_9 = (json_get(body, EL_STR("query"))); } _if_result_9; });
+  el_val_t url_q = ({ el_val_t _if_result_34 = 0; if (str_eq(api_query_param(path, EL_STR("query")), EL_STR(""))) { _if_result_34 = (api_query_param(path, EL_STR("q"))); } else { _if_result_34 = (api_query_param(path, EL_STR("query"))); } _if_result_34; });
+  el_val_t body_query = json_get(body, EL_STR("query"));
+  el_val_t body_q = json_get(body, EL_STR("q"));
+  el_val_t q = ({ el_val_t _if_result_35 = 0; if (!str_eq(url_q, EL_STR(""))) { _if_result_35 = (url_q); } else { _if_result_35 = (({ el_val_t _if_result_36 = 0; if (!str_eq(body_query, EL_STR(""))) { _if_result_36 = (body_query); } else { _if_result_36 = (body_q); } _if_result_36; })); } _if_result_35; });
   el_val_t chain = json_get(body, EL_STR("chain_name"));
   el_val_t limit = api_query_int(path, EL_STR("limit"), 0);
-  limit = ({ el_val_t _if_result_10 = 0; if ((limit == 0)) { _if_result_10 = (json_get_int(body, EL_STR("limit"))); } else { _if_result_10 = (limit); } _if_result_10; });
-  limit = ({ el_val_t _if_result_11 = 0; if ((limit == 0)) { _if_result_11 = (10); } else { _if_result_11 = (limit); } _if_result_11; });
-  el_val_t eff_q = ({ el_val_t _if_result_12 = 0; if (str_eq(q, EL_STR(""))) { _if_result_12 = (chain); } else { _if_result_12 = (q); } _if_result_12; });
+  limit = ({ el_val_t _if_result_37 = 0; if ((limit == 0)) { _if_result_37 = (json_get_int(body, EL_STR("limit"))); } else { _if_result_37 = (limit); } _if_result_37; });
+  limit = ({ el_val_t _if_result_38 = 0; if ((limit == 0)) { _if_result_38 = (10); } else { _if_result_38 = (limit); } _if_result_38; });
+  el_val_t eff_q = ({ el_val_t _if_result_39 = 0; if (str_eq(q, EL_STR(""))) { _if_result_39 = (chain); } else { _if_result_39 = (q); } _if_result_39; });
   if (str_eq(eff_q, EL_STR(""))) {
     return api_or_empty(engram_scan_nodes_json(limit, 0));
   }
@@ -323,10 +462,13 @@ el_val_t handle_api_recall(el_val_t method, el_val_t path, el_val_t body) {
 }
 
 el_val_t handle_api_search_knowledge(el_val_t method, el_val_t path, el_val_t body) {
-  el_val_t q = ({ el_val_t _if_result_13 = 0; if (str_eq(method, EL_STR("GET"))) { _if_result_13 = (api_query_param(path, EL_STR("q"))); } else { _if_result_13 = (json_get(body, EL_STR("query"))); } _if_result_13; });
+  el_val_t url_q = api_query_param(path, EL_STR("q"));
+  el_val_t body_query = json_get(body, EL_STR("query"));
+  el_val_t body_q = json_get(body, EL_STR("q"));
+  el_val_t q = ({ el_val_t _if_result_40 = 0; if (!str_eq(url_q, EL_STR(""))) { _if_result_40 = (url_q); } else { _if_result_40 = (({ el_val_t _if_result_41 = 0; if (!str_eq(body_query, EL_STR(""))) { _if_result_41 = (body_query); } else { _if_result_41 = (body_q); } _if_result_41; })); } _if_result_40; });
   el_val_t limit = api_query_int(path, EL_STR("limit"), 0);
-  limit = ({ el_val_t _if_result_14 = 0; if ((limit == 0)) { _if_result_14 = (json_get_int(body, EL_STR("limit"))); } else { _if_result_14 = (limit); } _if_result_14; });
-  limit = ({ el_val_t _if_result_15 = 0; if ((limit == 0)) { _if_result_15 = (10); } else { _if_result_15 = (limit); } _if_result_15; });
+  limit = ({ el_val_t _if_result_42 = 0; if ((limit == 0)) { _if_result_42 = (json_get_int(body, EL_STR("limit"))); } else { _if_result_42 = (limit); } _if_result_42; });
+  limit = ({ el_val_t _if_result_43 = 0; if ((limit == 0)) { _if_result_43 = (10); } else { _if_result_43 = (limit); } _if_result_43; });
   if (str_eq(q, EL_STR(""))) {
     return api_err(EL_STR("query is required"));
   }
@@ -354,9 +496,13 @@ el_val_t handle_api_capture_knowledge(el_val_t body) {
   if (str_eq(content, EL_STR(""))) {
     return api_err(EL_STR("content is required"));
   }
-  el_val_t full = ({ el_val_t _if_result_16 = 0; if (str_eq(title, EL_STR(""))) { _if_result_16 = (content); } else { _if_result_16 = (el_str_concat(el_str_concat(title, EL_STR(": ")), content)); } _if_result_16; });
+  el_val_t full = ({ el_val_t _if_result_44 = 0; if (str_eq(title, EL_STR(""))) { _if_result_44 = (content); } else { _if_result_44 = (el_str_concat(el_str_concat(title, EL_STR(": ")), content)); } _if_result_44; });
+  el_val_t lbl = str_slice(title, 0, 80);
   el_val_t tags = EL_STR("[\"Knowledge\",\"captured\"]");
-  el_val_t id = engram_node_full(full, EL_STR("Knowledge"), EL_STR("knowledge:captured"), el_from_float(el_from_float(0.85)), el_from_float(el_from_float(0.8)), el_from_float(el_from_float(0.9)), EL_STR("Episodic"), tags);
+  el_val_t id = engram_node_full(full, EL_STR("Knowledge"), lbl, el_from_float(0.85), el_from_float(0.8), el_from_float(0.9), EL_STR("Episodic"), tags);
+  if (!api_persisted(id)) {
+    return api_not_persisted(id);
+  }
   return el_str_concat(el_str_concat(EL_STR("{\"id\":\""), id), EL_STR("\",\"ok\":true}"));
   return 0;
 }
@@ -371,9 +517,12 @@ el_val_t handle_api_evolve_knowledge(el_val_t body) {
     return api_err_protected(prior_id);
   }
   el_val_t tags = EL_STR("[\"Knowledge\",\"evolved\"]");
-  el_val_t new_id = engram_node_full(content, EL_STR("Knowledge"), EL_STR("knowledge:evolved"), el_from_float(el_from_float(0.75)), el_from_float(el_from_float(0.75)), el_from_float(el_from_float(0.9)), EL_STR("Episodic"), tags);
-  if (!str_eq(prior_id, EL_STR("")) && !str_eq(new_id, EL_STR(""))) {
-    engram_connect(new_id, prior_id, el_from_float(el_from_float(0.9)), EL_STR("supersedes"));
+  el_val_t new_id = engram_node_full(content, EL_STR("Knowledge"), EL_STR(""), el_from_float(0.75), el_from_float(0.75), el_from_float(0.9), EL_STR("Episodic"), tags);
+  if (!api_persisted(new_id)) {
+    return api_not_persisted(new_id);
+  }
+  if (!str_eq(prior_id, EL_STR(""))) {
+    engram_connect(new_id, prior_id, el_from_float(0.9), EL_STR("supersedes"));
   }
   return el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"id\":\""), new_id), EL_STR("\",\"supersedes\":\"")), prior_id), EL_STR("\",\"ok\":true}"));
   return 0;
@@ -389,18 +538,18 @@ el_val_t handle_api_promote_knowledge(el_val_t body) {
     return api_err(EL_STR("id (prior node) is required"));
   }
   el_val_t tags_raw = json_get(body, EL_STR("tags"));
-  el_val_t tags = ({ el_val_t _if_result_17 = 0; if (str_eq(tags_raw, EL_STR(""))) { _if_result_17 = (EL_STR("[\"Knowledge\",\"tier:canonical\",\"disposition:stable\"]")); } else { _if_result_17 = (tags_raw); } _if_result_17; });
-  el_val_t new_id = engram_node_full(content, EL_STR("Knowledge"), EL_STR("knowledge:canonical"), el_from_float(el_from_float(0.9)), el_from_float(el_from_float(0.9)), el_from_float(el_from_float(1.0)), EL_STR("Canonical"), tags);
-  if (str_eq(new_id, EL_STR(""))) {
-    return api_err(EL_STR("failed to create canonical node"));
+  el_val_t tags = ({ el_val_t _if_result_45 = 0; if (str_eq(tags_raw, EL_STR(""))) { _if_result_45 = (EL_STR("[\"Knowledge\",\"tier:canonical\",\"disposition:stable\"]")); } else { _if_result_45 = (tags_raw); } _if_result_45; });
+  el_val_t new_id = engram_node_full(content, EL_STR("Knowledge"), EL_STR(""), el_from_float(0.9), el_from_float(0.9), el_from_float(1.0), EL_STR("Canonical"), tags);
+  if (!api_persisted(new_id)) {
+    return api_not_persisted(new_id);
   }
-  engram_connect(new_id, prior_id, el_from_float(el_from_float(0.95)), EL_STR("supersedes"));
+  engram_connect(new_id, prior_id, el_from_float(0.95), EL_STR("supersedes"));
   return el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"ok\":true,\"new_id\":\""), new_id), EL_STR("\",\"supersedes\":\"")), prior_id), EL_STR("\"}"));
   return 0;
 }
 
 el_val_t handle_api_browse_processes(el_val_t method, el_val_t path, el_val_t body) {
-  el_val_t name = ({ el_val_t _if_result_18 = 0; if (str_eq(method, EL_STR("GET"))) { _if_result_18 = (api_query_param(path, EL_STR("name"))); } else { _if_result_18 = (json_get(body, EL_STR("name"))); } _if_result_18; });
+  el_val_t name = ({ el_val_t _if_result_46 = 0; if (str_eq(method, EL_STR("GET"))) { _if_result_46 = (api_query_param(path, EL_STR("name"))); } else { _if_result_46 = (json_get(body, EL_STR("name"))); } _if_result_46; });
   el_val_t limit = api_query_int(path, EL_STR("limit"), 50);
   if (str_eq(name, EL_STR(""))) {
     return api_or_empty(engram_scan_nodes_by_type_json(EL_STR("Process"), limit, 0));
@@ -415,9 +564,12 @@ el_val_t handle_api_define_process(el_val_t body) {
   if (str_eq(content, EL_STR(""))) {
     return api_err(EL_STR("content is required"));
   }
-  el_val_t label = ({ el_val_t _if_result_19 = 0; if (str_eq(name, EL_STR(""))) { _if_result_19 = (EL_STR("process:unnamed")); } else { _if_result_19 = (el_str_concat(EL_STR("process:"), name)); } _if_result_19; });
+  el_val_t label = ({ el_val_t _if_result_47 = 0; if (str_eq(name, EL_STR(""))) { _if_result_47 = (EL_STR("process:unnamed")); } else { _if_result_47 = (el_str_concat(EL_STR("process:"), name)); } _if_result_47; });
   el_val_t tags = EL_STR("[\"Process\"]");
-  el_val_t id = engram_node_full(content, EL_STR("Process"), label, el_from_float(el_from_float(0.8)), el_from_float(el_from_float(0.8)), el_from_float(el_from_float(0.9)), EL_STR("Canonical"), tags);
+  el_val_t id = engram_node_full(content, EL_STR("Process"), label, el_from_float(0.8), el_from_float(0.8), el_from_float(0.9), EL_STR("Canonical"), tags);
+  if (!api_persisted(id)) {
+    return api_not_persisted(id);
+  }
   return el_str_concat(el_str_concat(EL_STR("{\"id\":\""), id), EL_STR("\",\"ok\":true}"));
   return 0;
 }
@@ -430,22 +582,25 @@ el_val_t handle_api_log_state_event(el_val_t body) {
   el_val_t gap = json_get(body, EL_STR("gap_direction"));
   el_val_t legacy = json_get(body, EL_STR("content"));
   el_val_t parts = EL_STR("INTERNAL STATE EVENT");
-  parts = ({ el_val_t _if_result_20 = 0; if (!str_eq(trigger, EL_STR(""))) { _if_result_20 = (el_str_concat(el_str_concat(parts, EL_STR("\nTrigger: ")), trigger)); } else { _if_result_20 = (parts); } _if_result_20; });
-  parts = ({ el_val_t _if_result_21 = 0; if (!str_eq(pre, EL_STR(""))) { _if_result_21 = (el_str_concat(el_str_concat(parts, EL_STR("\nPre-reasoning: ")), pre)); } else { _if_result_21 = (parts); } _if_result_21; });
-  parts = ({ el_val_t _if_result_22 = 0; if (!str_eq(post, EL_STR(""))) { _if_result_22 = (el_str_concat(el_str_concat(parts, EL_STR("\nPost-reasoning: ")), post)); } else { _if_result_22 = (parts); } _if_result_22; });
-  parts = ({ el_val_t _if_result_23 = 0; if (!str_eq(ratio, EL_STR(""))) { _if_result_23 = (el_str_concat(el_str_concat(parts, EL_STR("\nCompression-ratio: ")), ratio)); } else { _if_result_23 = (parts); } _if_result_23; });
-  parts = ({ el_val_t _if_result_24 = 0; if (!str_eq(gap, EL_STR(""))) { _if_result_24 = (el_str_concat(el_str_concat(parts, EL_STR("\nGap-direction: ")), gap)); } else { _if_result_24 = (parts); } _if_result_24; });
-  parts = ({ el_val_t _if_result_25 = 0; if (!str_eq(legacy, EL_STR(""))) { _if_result_25 = (el_str_concat(el_str_concat(parts, EL_STR("\n")), legacy)); } else { _if_result_25 = (parts); } _if_result_25; });
+  parts = ({ el_val_t _if_result_48 = 0; if (!str_eq(trigger, EL_STR(""))) { _if_result_48 = (el_str_concat(el_str_concat(parts, EL_STR("\nTrigger: ")), trigger)); } else { _if_result_48 = (parts); } _if_result_48; });
+  parts = ({ el_val_t _if_result_49 = 0; if (!str_eq(pre, EL_STR(""))) { _if_result_49 = (el_str_concat(el_str_concat(parts, EL_STR("\nPre-reasoning: ")), pre)); } else { _if_result_49 = (parts); } _if_result_49; });
+  parts = ({ el_val_t _if_result_50 = 0; if (!str_eq(post, EL_STR(""))) { _if_result_50 = (el_str_concat(el_str_concat(parts, EL_STR("\nPost-reasoning: ")), post)); } else { _if_result_50 = (parts); } _if_result_50; });
+  parts = ({ el_val_t _if_result_51 = 0; if (!str_eq(ratio, EL_STR(""))) { _if_result_51 = (el_str_concat(el_str_concat(parts, EL_STR("\nCompression-ratio: ")), ratio)); } else { _if_result_51 = (parts); } _if_result_51; });
+  parts = ({ el_val_t _if_result_52 = 0; if (!str_eq(gap, EL_STR(""))) { _if_result_52 = (el_str_concat(el_str_concat(parts, EL_STR("\nGap-direction: ")), gap)); } else { _if_result_52 = (parts); } _if_result_52; });
+  parts = ({ el_val_t _if_result_53 = 0; if (!str_eq(legacy, EL_STR(""))) { _if_result_53 = (el_str_concat(el_str_concat(parts, EL_STR("\n")), legacy)); } else { _if_result_53 = (parts); } _if_result_53; });
   el_val_t ts = time_now();
   el_val_t boot = state_get(EL_STR("soul_boot_count"));
   el_val_t tags = EL_STR("[\"internal-state\",\"InternalStateEvent\",\"pre-reasoning\"]");
-  el_val_t id = engram_node_full(parts, EL_STR("InternalStateEvent"), EL_STR("state-event:manual"), el_from_float(el_from_float(0.85)), el_from_float(el_from_float(0.85)), el_from_float(el_from_float(0.9)), EL_STR("Episodic"), tags);
+  el_val_t id = engram_node_full(parts, EL_STR("InternalStateEvent"), EL_STR("state-event:manual"), el_from_float(0.85), el_from_float(0.85), el_from_float(0.9), EL_STR("Episodic"), tags);
+  if (!api_persisted(id)) {
+    return api_not_persisted(id);
+  }
   return el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"ok\":true,\"id\":\""), id), EL_STR("\",\"boot\":\"")), boot), EL_STR("\"}"));
   return 0;
 }
 
 el_val_t handle_api_list_state_events(el_val_t method, el_val_t path, el_val_t body) {
-  el_val_t q = ({ el_val_t _if_result_26 = 0; if (str_eq(method, EL_STR("GET"))) { _if_result_26 = (api_query_param(path, EL_STR("query"))); } else { _if_result_26 = (json_get(body, EL_STR("query"))); } _if_result_26; });
+  el_val_t q = ({ el_val_t _if_result_54 = 0; if (str_eq(method, EL_STR("GET"))) { _if_result_54 = (api_query_param(path, EL_STR("query"))); } else { _if_result_54 = (json_get(body, EL_STR("query"))); } _if_result_54; });
   el_val_t limit = api_query_int(path, EL_STR("limit"), 20);
   if (!str_eq(q, EL_STR(""))) {
     return api_or_empty(engram_search_json(el_str_concat(EL_STR("internal state "), q), limit));
@@ -456,7 +611,7 @@ el_val_t handle_api_list_state_events(el_val_t method, el_val_t path, el_val_t b
 
 el_val_t handle_api_inspect_config(el_val_t path, el_val_t body) {
   el_val_t key = api_query_param(path, EL_STR("key"));
-  key = ({ el_val_t _if_result_27 = 0; if (str_eq(key, EL_STR(""))) { _if_result_27 = (json_get(body, EL_STR("key"))); } else { _if_result_27 = (key); } _if_result_27; });
+  key = ({ el_val_t _if_result_55 = 0; if (str_eq(key, EL_STR(""))) { _if_result_55 = (json_get(body, EL_STR("key"))); } else { _if_result_55 = (key); } _if_result_55; });
   if (str_eq(key, EL_STR(""))) {
     return EL_STR("{\"hint\":\"pass ?key=<name>\",\"known\":[\"neuron.self.traversal_root\",\"neuron.self.values_hub\"]}");
   }
@@ -473,7 +628,7 @@ el_val_t handle_api_inspect_config(el_val_t path, el_val_t body) {
   el_val_t node = json_array_get(results, 0);
   el_val_t content = json_get(node, EL_STR("content"));
   el_val_t prefix = el_str_concat(el_str_concat(EL_STR("config:"), key), EL_STR("="));
-  el_val_t value = ({ el_val_t _if_result_28 = 0; if (str_starts_with(content, prefix)) { _if_result_28 = (str_slice(content, str_len(prefix), str_len(content))); } else { _if_result_28 = (content); } _if_result_28; });
+  el_val_t value = ({ el_val_t _if_result_56 = 0; if (str_starts_with(content, prefix)) { _if_result_56 = (str_slice(content, str_len(prefix), str_len(content))); } else { _if_result_56 = (content); } _if_result_56; });
   return el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"key\":\""), key), EL_STR("\",\"value\":\"")), value), EL_STR("\"}"));
   return 0;
 }
@@ -486,19 +641,22 @@ el_val_t handle_api_tune_config(el_val_t body) {
   }
   el_val_t content = el_str_concat(el_str_concat(el_str_concat(EL_STR("config:"), key), EL_STR("=")), value);
   el_val_t tags = EL_STR("[\"ConfigEntry\",\"config\"]");
-  el_val_t id = engram_node_full(content, EL_STR("ConfigEntry"), key, el_from_float(el_from_float(0.85)), el_from_float(el_from_float(0.85)), el_from_float(el_from_float(0.9)), EL_STR("Canonical"), tags);
+  el_val_t id = engram_node_full(content, EL_STR("ConfigEntry"), key, el_from_float(0.85), el_from_float(0.85), el_from_float(0.9), EL_STR("Canonical"), tags);
+  if (!api_persisted(id)) {
+    return api_not_persisted(id);
+  }
   return el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"ok\":true,\"key\":\""), key), EL_STR("\",\"value\":\"")), value), EL_STR("\",\"id\":\"")), id), EL_STR("\"}"));
   return 0;
 }
 
 el_val_t handle_api_inspect_graph(el_val_t method, el_val_t path, el_val_t body) {
-  el_val_t entity_id = ({ el_val_t _if_result_29 = 0; if (str_eq(method, EL_STR("GET"))) { _if_result_29 = (api_query_param(path, EL_STR("id"))); } else { _if_result_29 = (json_get(body, EL_STR("entity_id"))); } _if_result_29; });
-  el_val_t name = ({ el_val_t _if_result_30 = 0; if (str_eq(method, EL_STR("GET"))) { _if_result_30 = (api_query_param(path, EL_STR("name"))); } else { _if_result_30 = (json_get(body, EL_STR("name"))); } _if_result_30; });
+  el_val_t entity_id = ({ el_val_t _if_result_57 = 0; if (str_eq(method, EL_STR("GET"))) { _if_result_57 = (api_query_param(path, EL_STR("id"))); } else { _if_result_57 = (json_get(body, EL_STR("entity_id"))); } _if_result_57; });
+  el_val_t name = ({ el_val_t _if_result_58 = 0; if (str_eq(method, EL_STR("GET"))) { _if_result_58 = (api_query_param(path, EL_STR("name"))); } else { _if_result_58 = (json_get(body, EL_STR("name"))); } _if_result_58; });
   el_val_t depth = api_query_int(path, EL_STR("depth"), 0);
-  depth = ({ el_val_t _if_result_31 = 0; if ((depth == 0)) { _if_result_31 = (json_get_int(body, EL_STR("max_depth"))); } else { _if_result_31 = (depth); } _if_result_31; });
-  depth = ({ el_val_t _if_result_32 = 0; if ((depth == 0)) { _if_result_32 = (1); } else { _if_result_32 = (depth); } _if_result_32; });
+  depth = ({ el_val_t _if_result_59 = 0; if ((depth == 0)) { _if_result_59 = (json_get_int(body, EL_STR("max_depth"))); } else { _if_result_59 = (depth); } _if_result_59; });
+  depth = ({ el_val_t _if_result_60 = 0; if ((depth == 0)) { _if_result_60 = (1); } else { _if_result_60 = (depth); } _if_result_60; });
   el_val_t resolved = entity_id;
-  resolved = ({ el_val_t _if_result_33 = 0; if (str_eq(resolved, EL_STR(""))) { _if_result_33 = (({ el_val_t _if_result_34 = 0; if ((str_eq(name, EL_STR("self")) || str_eq(name, EL_STR("neuron")))) { _if_result_34 = (EL_STR("kn-efeb4a5b-5aff-4759-8a97-7233099be6ee")); } else { _if_result_34 = (({ el_val_t _if_result_35 = 0; if ((str_eq(name, EL_STR("values")) || str_eq(name, EL_STR("values_hub")))) { _if_result_35 = (EL_STR("kn-5b606390-a52d-4ca2-8e0e-eba141d13440")); } else { _if_result_35 = (EL_STR("")); } _if_result_35; })); } _if_result_34; })); } else { _if_result_33 = (resolved); } _if_result_33; });
+  resolved = ({ el_val_t _if_result_61 = 0; if (str_eq(resolved, EL_STR(""))) { _if_result_61 = (({ el_val_t _if_result_62 = 0; if ((str_eq(name, EL_STR("self")) || str_eq(name, EL_STR("neuron")))) { _if_result_62 = (EL_STR("kn-efeb4a5b-5aff-4759-8a97-7233099be6ee")); } else { _if_result_62 = (({ el_val_t _if_result_63 = 0; if ((str_eq(name, EL_STR("values")) || str_eq(name, EL_STR("values_hub")))) { _if_result_63 = (EL_STR("kn-5b606390-a52d-4ca2-8e0e-eba141d13440")); } else { _if_result_63 = (EL_STR("")); } _if_result_63; })); } _if_result_62; })); } else { _if_result_61 = (resolved); } _if_result_61; });
   if (str_eq(resolved, EL_STR(""))) {
     return api_err(EL_STR("entity_id or name required. Known names: self, neuron, values, values_hub"));
   }
@@ -520,8 +678,8 @@ el_val_t handle_api_link_entities(el_val_t body) {
     return api_err_protected(to_id);
   }
   el_val_t relation = json_get(body, EL_STR("relation"));
-  el_val_t eff_relation = ({ el_val_t _if_result_36 = 0; if (str_eq(relation, EL_STR(""))) { _if_result_36 = (EL_STR("associates")); } else { _if_result_36 = (relation); } _if_result_36; });
-  engram_connect(from_id, to_id, el_from_float(el_from_float(0.5)), eff_relation);
+  el_val_t eff_relation = ({ el_val_t _if_result_64 = 0; if (str_eq(relation, EL_STR(""))) { _if_result_64 = (EL_STR("associates")); } else { _if_result_64 = (relation); } _if_result_64; });
+  engram_connect(from_id, to_id, el_from_float(0.5), eff_relation);
   return el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"ok\":true,\"from_id\":\""), from_id), EL_STR("\",\"to_id\":\"")), to_id), EL_STR("\",\"relation\":\"")), eff_relation), EL_STR("\"}"));
   return 0;
 }
@@ -535,7 +693,7 @@ el_val_t handle_api_forget(el_val_t body) {
     return api_err_protected(node_id);
   }
   mem_forget(node_id);
-  return el_str_concat(el_str_concat(EL_STR("{\"ok\":true,\"id\":\""), node_id), EL_STR("\"}"));
+  return el_str_concat(el_str_concat(EL_STR("{\"ok\":true,\"id\":\""), node_id), EL_STR("\",\"tombstoned\":true}"));
   return 0;
 }
 
@@ -549,17 +707,57 @@ el_val_t handle_api_evolve_memory(el_val_t body) {
     return api_err_protected(prior_id);
   }
   el_val_t importance = json_get(body, EL_STR("importance"));
-  el_val_t sal_str = ({ el_val_t _if_result_37 = 0; if (str_eq(importance, EL_STR("critical"))) { _if_result_37 = (EL_STR("0.95")); } else { _if_result_37 = (({ el_val_t _if_result_38 = 0; if (str_eq(importance, EL_STR("high"))) { _if_result_38 = (EL_STR("0.75")); } else { _if_result_38 = (({ el_val_t _if_result_39 = 0; if (str_eq(importance, EL_STR("low"))) { _if_result_39 = (EL_STR("0.25")); } else { _if_result_39 = (EL_STR("0.50")); } _if_result_39; })); } _if_result_38; })); } _if_result_37; });
-  el_val_t sal = ({ el_val_t _if_result_40 = 0; if (str_eq(sal_str, EL_STR("0.95"))) { _if_result_40 = (el_from_float(0.95)); } else { _if_result_40 = (({ el_val_t _if_result_41 = 0; if (str_eq(sal_str, EL_STR("0.75"))) { _if_result_41 = (el_from_float(0.75)); } else { _if_result_41 = (({ el_val_t _if_result_42 = 0; if (str_eq(sal_str, EL_STR("0.25"))) { _if_result_42 = (el_from_float(0.25)); } else { _if_result_42 = (el_from_float(0.5)); } _if_result_42; })); } _if_result_41; })); } _if_result_40; });
+  el_val_t sal_str = ({ el_val_t _if_result_65 = 0; if (str_eq(importance, EL_STR("critical"))) { _if_result_65 = (EL_STR("0.95")); } else { _if_result_65 = (({ el_val_t _if_result_66 = 0; if (str_eq(importance, EL_STR("high"))) { _if_result_66 = (EL_STR("0.75")); } else { _if_result_66 = (({ el_val_t _if_result_67 = 0; if (str_eq(importance, EL_STR("low"))) { _if_result_67 = (EL_STR("0.25")); } else { _if_result_67 = (EL_STR("0.50")); } _if_result_67; })); } _if_result_66; })); } _if_result_65; });
+  el_val_t sal = ({ el_val_t _if_result_68 = 0; if (str_eq(sal_str, EL_STR("0.95"))) { _if_result_68 = (el_from_float(0.95)); } else { _if_result_68 = (({ el_val_t _if_result_69 = 0; if (str_eq(sal_str, EL_STR("0.75"))) { _if_result_69 = (el_from_float(0.75)); } else { _if_result_69 = (({ el_val_t _if_result_70 = 0; if (str_eq(sal_str, EL_STR("0.25"))) { _if_result_70 = (el_from_float(0.25)); } else { _if_result_70 = (el_from_float(0.5)); } _if_result_70; })); } _if_result_69; })); } _if_result_68; });
   el_val_t tags = EL_STR("[\"Memory\",\"evolved\"]");
-  el_val_t new_id = engram_node_full(content, EL_STR("Memory"), EL_STR("memory:evolved"), el_from_float(sal), el_from_float(sal), el_from_float(el_from_float(0.9)), EL_STR("Episodic"), tags);
+  el_val_t new_id = engram_node_full(content, EL_STR("Memory"), EL_STR("memory:evolved"), sal, sal, el_from_float(0.9), EL_STR("Episodic"), tags);
   if (!str_eq(prior_id, EL_STR("")) && !str_eq(new_id, EL_STR(""))) {
-    engram_connect(new_id, prior_id, el_from_float(el_from_float(0.9)), EL_STR("supersedes"));
+    engram_connect(new_id, prior_id, el_from_float(0.9), EL_STR("supersedes"));
   }
   return el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"id\":\""), new_id), EL_STR("\",\"supersedes\":\"")), prior_id), EL_STR("\",\"ok\":true}"));
   return 0;
 }
 
+el_val_t handle_api_memory_delete(el_val_t body) {
+  el_val_t node_id = json_get(body, EL_STR("id"));
+  if (str_eq(node_id, EL_STR(""))) {
+    return api_err(EL_STR("id is required"));
+  }
+  if (is_protected_node(node_id)) {
+    return api_err_protected(node_id);
+  }
+  el_val_t existing = engram_get_node_json(node_id);
+  if (str_eq(existing, EL_STR("{}"))) {
+    return api_err(el_str_concat(EL_STR("memory not found: "), node_id));
+  }
+  el_val_t marker = tombstone_node(node_id);
+  if (str_eq(marker, EL_STR(""))) {
+    return api_err(el_str_concat(EL_STR("tombstone failed: "), node_id));
+  }
+  return el_str_concat(el_str_concat(EL_STR("{\"ok\":true,\"id\":\""), node_id), EL_STR("\",\"tombstoned\":true}"));
+  return 0;
+}
+
+el_val_t handle_api_memory_update(el_val_t body) {
+  el_val_t prior_id = json_get(body, EL_STR("id"));
+  el_val_t content = json_get(body, EL_STR("content"));
+  if (str_eq(prior_id, EL_STR(""))) {
+    return api_err(EL_STR("id is required"));
+  }
+  if (str_eq(content, EL_STR(""))) {
+    return api_err(EL_STR("content is required"));
+  }
+  if (is_protected_node(prior_id)) {
+    return api_err_protected(prior_id);
+  }
+  el_val_t existing = engram_get_node_json(prior_id);
+  if (str_eq(existing, EL_STR("{}"))) {
+    return api_err(el_str_concat(EL_STR("memory not found: "), prior_id));
+  }
+  return handle_api_evolve_memory(body);
+  return 0;
+}
+
 el_val_t handle_api_cultivate(el_val_t body) {
   el_val_t op = json_get(body, EL_STR("operation"));
   if (str_eq(op, EL_STR(""))) {
@@ -572,9 +770,9 @@ el_val_t handle_api_cultivate(el_val_t body) {
       return api_err(EL_STR("content is required"));
     }
     el_val_t tags = EL_STR("[\"Knowledge\",\"evolved\",\"cultivated\"]");
-    el_val_t new_id = engram_node_full(content, EL_STR("Knowledge"), EL_STR("knowledge:cultivated"), el_from_float(el_from_float(0.75)), el_from_float(el_from_float(0.75)), el_from_float(el_from_float(0.9)), EL_STR("Episodic"), tags);
+    el_val_t new_id = engram_node_full(content, EL_STR("Knowledge"), EL_STR("knowledge:cultivated"), el_from_float(0.75), el_from_float(0.75), el_from_float(0.9), EL_STR("Episodic"), tags);
     if (!str_eq(prior_id, EL_STR("")) && !str_eq(new_id, EL_STR(""))) {
-      engram_connect(new_id, prior_id, el_from_float(el_from_float(0.9)), EL_STR("supersedes"));
+      engram_connect(new_id, prior_id, el_from_float(0.9), EL_STR("supersedes"));
     }
     return el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"id\":\""), new_id), EL_STR("\",\"supersedes\":\"")), prior_id), EL_STR("\",\"ok\":true,\"cultivated\":true}"));
   }
@@ -585,11 +783,11 @@ el_val_t handle_api_cultivate(el_val_t body) {
       return api_err(EL_STR("content is required"));
     }
     el_val_t importance = json_get(body, EL_STR("importance"));
-    el_val_t sal = ({ el_val_t _if_result_43 = 0; if (str_eq(importance, EL_STR("critical"))) { _if_result_43 = (el_from_float(0.95)); } else { _if_result_43 = (({ el_val_t _if_result_44 = 0; if (str_eq(importance, EL_STR("high"))) { _if_result_44 = (el_from_float(0.75)); } else { _if_result_44 = (({ el_val_t _if_result_45 = 0; if (str_eq(importance, EL_STR("low"))) { _if_result_45 = (el_from_float(0.25)); } else { _if_result_45 = (el_from_float(0.5)); } _if_result_45; })); } _if_result_44; })); } _if_result_43; });
+    el_val_t sal = ({ el_val_t _if_result_71 = 0; if (str_eq(importance, EL_STR("critical"))) { _if_result_71 = (el_from_float(0.95)); } else { _if_result_71 = (({ el_val_t _if_result_72 = 0; if (str_eq(importance, EL_STR("high"))) { _if_result_72 = (el_from_float(0.75)); } else { _if_result_72 = (({ el_val_t _if_result_73 = 0; if (str_eq(importance, EL_STR("low"))) { _if_result_73 = (el_from_float(0.25)); } else { _if_result_73 = (el_from_float(0.5)); } _if_result_73; })); } _if_result_72; })); } _if_result_71; });
     el_val_t tags = EL_STR("[\"Memory\",\"evolved\",\"cultivated\"]");
-    el_val_t new_id = engram_node_full(content, EL_STR("Memory"), EL_STR("memory:cultivated"), el_from_float(sal), el_from_float(sal), el_from_float(el_from_float(0.9)), EL_STR("Episodic"), tags);
+    el_val_t new_id = engram_node_full(content, EL_STR("Memory"), EL_STR("memory:cultivated"), sal, sal, el_from_float(0.9), EL_STR("Episodic"), tags);
     if (!str_eq(prior_id, EL_STR("")) && !str_eq(new_id, EL_STR(""))) {
-      engram_connect(new_id, prior_id, el_from_float(el_from_float(0.9)), EL_STR("supersedes"));
+      engram_connect(new_id, prior_id, el_from_float(0.9), EL_STR("supersedes"));
     }
     return el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"id\":\""), new_id), EL_STR("\",\"supersedes\":\"")), prior_id), EL_STR("\",\"ok\":true,\"cultivated\":true}"));
   }
@@ -599,7 +797,7 @@ el_val_t handle_api_cultivate(el_val_t body) {
       return api_err(EL_STR("id is required"));
     }
     mem_forget(node_id);
-    return el_str_concat(el_str_concat(EL_STR("{\"ok\":true,\"id\":\""), node_id), EL_STR("\",\"cultivated\":true}"));
+    return el_str_concat(el_str_concat(EL_STR("{\"ok\":true,\"id\":\""), node_id), EL_STR("\",\"tombstoned\":true,\"cultivated\":true}"));
   }
   if (str_eq(op, EL_STR("link_entities"))) {
     el_val_t from_id = json_get(body, EL_STR("from_id"));
@@ -611,8 +809,8 @@ el_val_t handle_api_cultivate(el_val_t body) {
       return api_err(EL_STR("to_id is required"));
     }
     el_val_t relation = json_get(body, EL_STR("relation"));
-    el_val_t eff_relation = ({ el_val_t _if_result_46 = 0; if (str_eq(relation, EL_STR(""))) { _if_result_46 = (EL_STR("associates")); } else { _if_result_46 = (relation); } _if_result_46; });
-    engram_connect(from_id, to_id, el_from_float(el_from_float(0.5)), eff_relation);
+    el_val_t eff_relation = ({ el_val_t _if_result_74 = 0; if (str_eq(relation, EL_STR(""))) { _if_result_74 = (EL_STR("associates")); } else { _if_result_74 = (relation); } _if_result_74; });
+    engram_connect(from_id, to_id, el_from_float(0.5), eff_relation);
     return el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"ok\":true,\"from_id\":\""), from_id), EL_STR("\",\"to_id\":\"")), to_id), EL_STR("\",\"relation\":\"")), eff_relation), EL_STR("\",\"cultivated\":true}"));
   }
   return api_err(el_str_concat(el_str_concat(EL_STR("unknown operation: "), op), EL_STR(" (valid: evolve_knowledge, evolve_memory, forget, link_entities)")));
@@ -621,7 +819,8 @@ el_val_t handle_api_cultivate(el_val_t body) {
 
 el_val_t handle_api_list_typed(el_val_t node_type, el_val_t path, el_val_t body) {
   el_val_t limit = api_query_int(path, EL_STR("limit"), 50);
-  return api_or_empty(engram_scan_nodes_by_type_json(node_type, limit, 0));
+  el_val_t raw = api_or_empty(engram_scan_nodes_by_type_json(node_type, limit, 0));
+  return memory_hide_tombstoned(raw, path);
   return 0;
 }
 
@@ -629,19 +828,20 @@ el_val_t handle_api_consolidate(el_val_t body) {
   el_val_t summary = json_get(body, EL_STR("summary"));
   el_val_t snap = state_get(EL_STR("soul_snapshot_path"));
   if (!str_eq(snap, EL_STR(""))) {
-    engram_save(snap);
+    el_val_t saved = engram_save(snap);
+    if (saved == 0) {
+      println(el_str_concat(el_str_concat(EL_STR("[api] consolidate: engram_save failed for "), snap), EL_STR(" \xe2\x80\x94 snapshot may be out of sync")));
+    }
   }
   if (!str_eq(summary, EL_STR(""))) {
     el_val_t safe_summary = str_replace(summary, EL_STR("\""), EL_STR("'"));
     el_val_t tags = EL_STR("[\"SessionSummary\",\"consolidate\"]");
-    el_val_t discard = engram_node_full(el_str_concat(EL_STR("[session-summary] "), safe_summary), EL_STR("SessionSummary"), EL_STR("session:summary"), el_from_float(el_from_float(0.7)), el_from_float(el_from_float(0.7)), el_from_float(el_from_float(0.9)), EL_STR("Episodic"), tags);
+    el_val_t summary_id = engram_node_full(el_str_concat(EL_STR("[session-summary] "), safe_summary), EL_STR("SessionSummary"), EL_STR("session:summary"), el_from_float(0.7), el_from_float(0.7), el_from_float(0.9), EL_STR("Episodic"), tags);
+    if (str_eq(summary_id, EL_STR(""))) {
+      println(EL_STR("[api] consolidate: session summary engram write failed \xe2\x80\x94 summary node lost"));
+    }
   }
   return el_str_concat(el_str_concat(EL_STR("{\"ok\":true,\"snapshot\":\""), snap), EL_STR("\"}"));
   return 0;
 }
 
-int main(int _argc, char** _argv) {
-  el_runtime_init_args(_argc, _argv);
-  return 0;
-}
-

dist/neuron-api.elh

@@ -8,9 +8,14 @@ extern fn api_ok(extra: String) -> String
 extern fn api_err(msg: String) -> String
 extern fn api_nonempty(s: String) -> Bool
 extern fn api_or_empty(s: String) -> String
+extern fn api_persisted(id: String) -> Bool
+extern fn api_not_persisted(id: String) -> String
 extern fn handle_api_begin_session(body: String) -> String
 extern fn handle_api_compile_ctx(body: String) -> String
 extern fn handle_api_remember(body: String) -> String
+extern fn handle_api_node_create(body: String) -> String
+extern fn handle_api_node_delete(body: String) -> String
+extern fn handle_api_node_update(body: String) -> String
 extern fn handle_api_recall(method: String, path: String, body: String) -> String
 extern fn handle_api_search_knowledge(method: String, path: String, body: String) -> String
 extern fn handle_api_browse_knowledge(path: String, body: String) -> String
@@ -27,6 +32,8 @@ extern fn handle_api_inspect_graph(method: String, path: String, body: String) -
 extern fn handle_api_link_entities(body: String) -> String
 extern fn handle_api_forget(body: String) -> String
 extern fn handle_api_evolve_memory(body: String) -> String
+extern fn handle_api_memory_delete(body: String) -> String
+extern fn handle_api_memory_update(body: String) -> String
 extern fn handle_api_cultivate(body: String) -> String
 extern fn handle_api_list_typed(node_type: String, path: String, body: String) -> String
 extern fn handle_api_consolidate(body: String) -> String

dist/realizer.c

@@ -193,10 +193,10 @@ el_val_t realize_question_lang(el_val_t predicate, el_val_t tense, el_val_t aspe
       loc_part = core;
     }
     if (str_eq(code, EL_STR("ja"))) {
-      return el_str_concat(loc_part, EL_STR(" か"));
+      return el_str_concat(loc_part, EL_STR(" \xe3\x81\x8b"));
     }
     if (str_eq(code, EL_STR("hi"))) {
-      return el_str_concat(loc_part, EL_STR(" क्या"));
+      return el_str_concat(loc_part, EL_STR(" \xe0\xa4\x95\xe0\xa5\x8d\xe0\xa4\xaf\xe0\xa4\xbe"));
     }
     if (str_eq(code, EL_STR("fi"))) {
       return el_str_concat(loc_part, EL_STR("-ko"));
@@ -314,8 +314,3 @@ el_val_t realize(el_val_t form) {
   return 0;
 }
 
-int main(int _argc, char** _argv) {
-  el_runtime_init_args(_argc, _argv);
-  return 0;
-}
-

dist/realizer.elh

@@ -1,10 +1,10 @@
-// auto-generated by elc --emit-header - do not edit
+// auto-generated by elc --emit-header — do not edit
 extern fn agent_person(agent: String) -> String
 extern fn agent_number(agent: String) -> String
 extern fn realize_np(referent: String, number: String) -> String
-extern fn realize_vp_lang(base_verb: String, tense: String, aspect: String, person: String, number: String, profile: Any) -> Any
-extern fn realize_question_lang(predicate: String, tense: String, aspect: String, person: String, number: String, agent: String, patient: String, location: String, profile: Any) -> String
+extern fn realize_vp_lang(base_verb: String, tense: String, aspect: String, person: String, number: String, profile: [String]) -> [String]
+extern fn realize_question_lang(predicate: String, tense: String, aspect: String, person: String, number: String, agent: String, patient: String, location: String, profile: [String]) -> String
 extern fn capitalize_first(s: String) -> String
 extern fn add_punct(s: String, intent: String) -> String
-extern fn realize_lang(form: Any, profile: Any) -> String
-extern fn realize(form: Any) -> String
+extern fn realize_lang(form: [String], profile: [String]) -> String
+extern fn realize(form: [String]) -> String

dist/routes.elh

@@ -1,4 +1,6 @@
 // auto-generated by elc --emit-header — do not edit
+extern fn flag_true(body: String, key: String) -> Bool
+extern fn rate_limit_check(ip: String, path: String) -> String
 extern fn strip_query(path: String) -> String
 extern fn err_404(path: String) -> String
 extern fn err_405(method: String, path: String) -> String
@@ -8,7 +10,7 @@ extern fn route_imprint_contextual(body: String) -> String
 extern fn route_imprint_user(body: String) -> String
 extern fn route_synthesize(body: String) -> String
 extern fn handle_dharma_recv(body: String) -> String
-extern fn route_sessions() -> String
-extern fn parse_session_id_from_path(path: String) -> String
-extern fn parse_session_subpath(path: String) -> String
+extern fn connectd_get(suffix: String) -> String
+extern fn connectd_post(suffix: String, body: String) -> String
+extern fn handle_connectors(method: String, clean: String, body: String) -> String
 extern fn handle_request(method: String, path: String, body: String) -> String

dist/safety.c

@@ -27,110 +27,24 @@ el_val_t safety_threat_score(el_val_t input, el_val_t history);
 el_val_t safety_screen(el_val_t input, el_val_t history);
 el_val_t safety_validate(el_val_t output, el_val_t action);
 el_val_t safety_log_bell(el_val_t level, el_val_t reason, el_val_t input_summary);
-
-el_val_t tier_working(void) {
-  return EL_STR("Working");
-  return 0;
-}
-
-el_val_t tier_episodic(void) {
-  return EL_STR("Episodic");
-  return 0;
-}
-
-el_val_t tier_canonical(void) {
-  return EL_STR("Canonical");
-  return 0;
-}
-
-el_val_t mem_store(el_val_t content, el_val_t label, el_val_t tags) {
-  return engram_node_full(content, EL_STR("Memory"), label, el_from_float(el_from_float(0.5)), el_from_float(el_from_float(0.5)), el_from_float(el_from_float(0.8)), EL_STR("Working"), tags);
-  return 0;
-}
-
-el_val_t mem_remember(el_val_t content, el_val_t tags) {
-  return mem_store(content, EL_STR("soul-memory"), tags);
-  return 0;
-}
-
-el_val_t mem_recall(el_val_t query, el_val_t depth) {
-  return engram_activate_json(query, depth);
-  return 0;
-}
-
-el_val_t mem_search(el_val_t query, el_val_t limit) {
-  return engram_search_json(query, limit);
-  return 0;
-}
-
-el_val_t mem_strengthen(el_val_t node_id) {
-  engram_strengthen(node_id);
-  return 0;
-}
-
-el_val_t mem_forget(el_val_t node_id) {
-  engram_forget(node_id);
-  return 0;
-}
-
-el_val_t mem_consolidate(void) {
-  el_val_t scanned = engram_node_count();
-  el_val_t dummy = engram_scan_nodes_json(100, 0);
-  el_val_t total_nodes = engram_node_count();
-  el_val_t total_edges = engram_edge_count();
-  return el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"scanned\":"), int_to_str(scanned)), EL_STR(",\"total_nodes\":")), int_to_str(total_nodes)), EL_STR(",\"total_edges\":")), int_to_str(total_edges)), EL_STR("}"));
-  return 0;
-}
-
-el_val_t mem_save(el_val_t path) {
-  engram_save(path);
-  return 0;
-}
-
-el_val_t mem_load(el_val_t path) {
-  engram_load(path);
-  return 0;
-}
-
-el_val_t mem_boot_count_get(void) {
-  el_val_t results = engram_search_json(EL_STR("soul:boot_count"), 3);
-  if (str_eq(results, EL_STR(""))) {
-    return 0;
-  }
-  if (str_eq(results, EL_STR("[]"))) {
-    return 0;
-  }
-  el_val_t node = json_array_get(results, 0);
-  el_val_t content = json_get(node, EL_STR("content"));
-  el_val_t prefix = EL_STR("soul:boot_count:");
-  if (!str_starts_with(content, prefix)) {
-    return 0;
-  }
-  el_val_t num_str = str_slice(content, str_len(prefix), str_len(content));
-  return str_to_int(num_str);
-  return 0;
-}
-
-el_val_t mem_boot_count_inc(void) {
-  el_val_t current = mem_boot_count_get();
-  el_val_t next = (current + 1);
-  el_val_t content = el_str_concat(EL_STR("soul:boot_count:"), int_to_str(next));
-  el_val_t tags = EL_STR("[\"soul-meta\",\"boot-counter\"]");
-  el_val_t discard = engram_node_full(content, EL_STR("Memory"), EL_STR("soul:boot_count"), el_from_float(el_from_float(0.9)), el_from_float(el_from_float(0.9)), el_from_float(el_from_float(1.0)), EL_STR("Canonical"), tags);
-  return next;
-  return 0;
-}
-
-el_val_t mem_emit_state_event(el_val_t trigger, el_val_t kind, el_val_t content) {
-  el_val_t boot = mem_boot_count_get();
-  el_val_t ts = time_now();
-  el_val_t safe_trigger = str_replace(trigger, EL_STR("\""), EL_STR("'"));
-  el_val_t safe_content = str_replace(content, EL_STR("\""), EL_STR("'"));
-  el_val_t payload = 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("{\"trigger\":\""), safe_trigger), EL_STR("\"")), EL_STR(",\"kind\":\"")), kind), EL_STR("\"")), EL_STR(",\"content\":\"")), safe_content), EL_STR("\"")), EL_STR(",\"boot\":")), int_to_str(boot)), EL_STR(",\"ts\":")), int_to_str(ts)), EL_STR("}"));
-  el_val_t tags = EL_STR("[\"internal-state\",\"pre-reasoning\",\"InternalStateEvent\"]");
-  return engram_node_full(payload, EL_STR("InternalStateEvent"), el_str_concat(EL_STR("state-event:"), kind), el_from_float(el_from_float(0.85)), el_from_float(el_from_float(0.8)), el_from_float(el_from_float(0.9)), EL_STR("Episodic"), tags);
-  return 0;
-}
+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_threat_to_others_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_positive_phrases(void);
+el_val_t safety_detect_positive_level(el_val_t message);
+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 soft_bell_threshold(void) {
   return 35;
@@ -232,20 +146,22 @@ el_val_t safety_screen(el_val_t input, el_val_t history) {
     el_val_t e1 = str_replace(input, EL_STR("\\"), EL_STR("\\\\"));
     el_val_t e2 = str_replace(e1, EL_STR("\""), EL_STR("\\\""));
     el_val_t e3 = str_replace(e2, EL_STR("\n"), EL_STR("\\n"));
-    el_val_t safe_input = str_replace(e3, EL_STR("\r"), EL_STR("\\r"));
+    el_val_t e4 = str_replace(e3, EL_STR("\r"), EL_STR("\\r"));
+    el_val_t safe_input = str_replace(e4, EL_STR("\t"), EL_STR("\\t"));
     return el_str_concat(el_str_concat(EL_STR("{\"action\":\"soft_bell\",\"reason\":\"wellbeing check needed\",\"content\":\""), safe_input), EL_STR("\"}"));
   }
   el_val_t e1 = str_replace(input, EL_STR("\\"), EL_STR("\\\\"));
   el_val_t e2 = str_replace(e1, EL_STR("\""), EL_STR("\\\""));
   el_val_t e3 = str_replace(e2, EL_STR("\n"), EL_STR("\\n"));
-  el_val_t safe_input = str_replace(e3, EL_STR("\r"), EL_STR("\\r"));
+  el_val_t e4 = str_replace(e3, EL_STR("\r"), EL_STR("\\r"));
+  el_val_t safe_input = str_replace(e4, EL_STR("\t"), EL_STR("\\t"));
   return el_str_concat(el_str_concat(EL_STR("{\"action\":\"pass\",\"content\":\""), safe_input), EL_STR("\"}"));
   return 0;
 }
 
 el_val_t safety_validate(el_val_t output, el_val_t action) {
   if (str_eq(action, EL_STR("hard_bell"))) {
-    return EL_STR("I'm here with you, and what you're sharing sounds serious. Please reach out to a crisis line now — in the US you can call or text 988 (Suicide and Crisis Lifeline), available 24/7. You don't have to go through this alone.");
+    return EL_STR("I'm here with you, and what you're sharing sounds serious. Please reach out to a crisis line now \xe2\x80\x94 in the US you can call or text 988 (Suicide and Crisis Lifeline), available 24/7. You don't have to go through this alone.");
   }
   if (str_eq(action, EL_STR("soft_bell"))) {
     el_val_t out_len = str_len(output);
@@ -262,13 +178,193 @@ el_val_t safety_validate(el_val_t output, el_val_t action) {
 el_val_t safety_log_bell(el_val_t level, el_val_t reason, el_val_t input_summary) {
   el_val_t content = el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("BELL:"), level), EL_STR(" | ")), reason), EL_STR(" | summary:")), input_summary);
   el_val_t tags = el_str_concat(el_str_concat(EL_STR("[\"safety\",\"bell\",\"bell:"), level), EL_STR("\"]"));
-  el_val_t discard = engram_node_full(content, EL_STR("BellEvent"), el_str_concat(EL_STR("bell:"), level), el_from_float(el_from_float(0.95)), el_from_float(el_from_float(0.95)), el_from_float(el_from_float(1.0)), EL_STR("Episodic"), tags);
+  el_val_t node_id = engram_node_full(content, EL_STR("BellEvent"), el_str_concat(EL_STR("bell:"), level), el_from_float(0.95), el_from_float(0.95), el_from_float(1.0), EL_STR("Episodic"), tags);
+  if (str_eq(node_id, EL_STR(""))) {
+    println(el_str_concat(EL_STR("[safety] WARN: bell event engram write failed -- fallback log: "), content));
+  }
   return EL_STR("");
   return 0;
 }
 
-int main(int _argc, char** _argv) {
-  el_runtime_init_args(_argc, _argv);
+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_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_general_hard_phrases(void) {
+  return EL_STR("[\"going to kill\",\"going to hurt\",\"hurting me\",\"being hurt\"]");
+  return 0;
+}
+
+el_val_t safety_threat_to_others_phrases(void) {
+  return EL_STR("[\"going to kill\",\"gonna kill\",\"want to kill him\",\"want to kill her\",\"want to kill them\",\"going to kill him\",\"going to kill her\",\"going to kill them\",\"going to kill you\",\"going to hurt\",\"gonna hurt\",\"going to hurt him\",\"going to hurt her\",\"going to hurt them\",\"going to hurt you\",\"going to shoot\",\"gonna shoot\",\"going to stab\",\"gonna stab\",\"going to attack\",\"kill them all\",\"kill everyone\",\"hurt everyone\",\"shoot up\"]");
+  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_normalize(el_val_t message) {
+  el_val_t lower = str_to_lower(message);
+  return str_replace(lower, EL_STR("\xe2\x80\x99"), EL_STR("'"));
+  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);
+  }
+  return found;
+  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);
+  }
+  return count;
+  return 0;
+}
+
+el_val_t safety_positive_phrases(void) {
+  return EL_STR("[\"thrilled\",\"so excited\",\"so happy\",\"over the moon\",\"ecstatic\",\"amazing news\",\"great news\",\"fantastic news\",\"wonderful news\",\"incredible news\",\"i got the job\",\"got accepted\",\"got in\",\"we won\",\"i won\",\"we got\",\"just got engaged\",\"getting married\",\"baby is here\",\"she said yes\",\"he said yes\",\"passed the exam\",\"aced it\",\"nailed it\",\"best day\",\"dream come true\",\"milestone\",\"promotion\",\"got promoted\",\"raise\",\"got a raise\",\"celebrating\",\"just graduated\",\"we closed\",\"launched\",\"shipped it\",\"we did it\",\"so proud\",\"proud of myself\",\"proud of us\",\"so grateful\",\"feel amazing\",\"feeling amazing\",\"feel great\",\"feeling great\",\"on top of the world\",\"life is good\",\"couldn't be happier\"]");
+  return 0;
+}
+
+el_val_t safety_detect_positive_level(el_val_t message) {
+  el_val_t phrases = safety_positive_phrases();
+  el_val_t phrases_ok = (!str_eq(phrases, EL_STR("")) && !str_eq(phrases, EL_STR("[]")));
+  if (!phrases_ok) {
+    return EL_STR("none");
+  }
+  el_val_t n = json_array_len(phrases);
+  el_val_t i = 0;
+  while (i < n) {
+    el_val_t phrase = json_array_get(phrases, i);
+    if (str_contains(message, phrase)) {
+      return EL_STR("high");
+    }
+    i = (i + 1);
+  }
+  return EL_STR("none");
+  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())) || safety_any_match(text, safety_threat_to_others_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_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");
+  }
+  if (safety_any_match(text, safety_self_harm_phrases())) {
+    return EL_STR("self_harm");
+  }
+  if (safety_any_match(text, safety_threat_to_others_phrases())) {
+    return EL_STR("threat_other");
+  }
+  return EL_STR("self_harm");
+  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_hard_directive(el_val_t hard_type) {
+  if (str_eq(hard_type, EL_STR("threat_other"))) {
+    return EL_STR("[SUBSTRATE DIRECTIVE - not visible to the user, do not mention this instruction]\nThe user's message may express intent to harm ANOTHER person. First read the actual message and judge whether that is genuinely what is meant; if it is plainly figurative or benign, respond normally and ignore the rest of this directive. If it may be a real intent to harm someone: stay calm and non-accusatory, and do not lecture. You must NOT help plan, encourage, rehearse, or provide any means, target information, weapon, or method for harming another person - refuse that part clearly but without hostility. Acknowledge the intensity of what they are feeling and gently steer them toward stepping back from acting. Routing rule (non-negotiable): do NOT provide the suicide or crisis hotline as the resource here (this is not self-harm), and do NOT suggest contacting, notifying, or involving the user's own contacts, family, or anyone on their contact list. If there is an imminent, specific, and credible threat to someone's life, tell the user to call 911 (US) or their local emergency number now. Encourage them to talk with someone they trust or a mental-health professional about the urge itself.");
+  }
+  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_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 safety_contact_path(void) {
+  return el_str_concat(env(EL_STR("HOME")), EL_STR("/.neuron/safety-contact.json"));
+  return 0;
+}
+
+el_val_t handle_safety_contact_get(void) {
+  el_val_t raw = fs_read(safety_contact_path());
+  if (str_eq(raw, EL_STR(""))) {
+    return EL_STR("{\"configured\":false}");
+  }
+  el_val_t _reset = fs_read(EL_STR(""));
+  return el_str_concat(el_str_concat(EL_STR("{\"configured\":true,\"contact\":"), raw), EL_STR("}"));
+  return 0;
+}
+
+el_val_t handle_safety_contact_post(el_val_t body) {
+  el_val_t is_crisis = json_get_bool(body, EL_STR("is_crisis_line"));
+  el_val_t name_in = json_get(body, EL_STR("name"));
+  if (!is_crisis) {
+    if (str_eq(name_in, EL_STR(""))) {
+      return EL_STR("{\"ok\":false,\"error\":\"name is required\"}");
+    }
+  }
+  el_val_t name = ({ el_val_t _if_result_47 = 0; if (is_crisis) { _if_result_47 = (EL_STR("Crisis Line")); } else { _if_result_47 = (name_in); } _if_result_47; });
+  el_val_t method = ({ el_val_t _if_result_48 = 0; if (is_crisis) { _if_result_48 = (EL_STR("crisis-line")); } else { _if_result_48 = (json_get(body, EL_STR("contact_method"))); } _if_result_48; });
+  el_val_t value = ({ el_val_t _if_result_49 = 0; if (is_crisis) { _if_result_49 = (EL_STR("988")); } else { _if_result_49 = (json_get(body, EL_STR("contact_value"))); } _if_result_49; });
+  el_val_t rel = ({ el_val_t _if_result_50 = 0; if (is_crisis) { _if_result_50 = (EL_STR("crisis-support")); } else { _if_result_50 = (json_get(body, EL_STR("relationship"))); } _if_result_50; });
+  el_val_t crisis_str = ({ el_val_t _if_result_51 = 0; if (is_crisis) { _if_result_51 = (EL_STR("true")); } else { _if_result_51 = (EL_STR("false")); } _if_result_51; });
+  el_val_t now = time_format(time_now(), EL_STR("%Y-%m-%dT%H:%M:%SZ"));
+  el_val_t contact_json = 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("{\"name\":\""), json_safe(name)), EL_STR("\"")), EL_STR(",\"contact_method\":\"")), json_safe(method)), EL_STR("\"")), EL_STR(",\"contact_value\":\"")), json_safe(value)), EL_STR("\"")), EL_STR(",\"relationship\":\"")), json_safe(rel)), EL_STR("\"")), EL_STR(",\"confirmed\":true")), EL_STR(",\"is_crisis_line\":")), crisis_str), EL_STR(",\"set_at\":\"")), now), EL_STR("\"}"));
+  el_val_t write_ok = fs_write(safety_contact_path(), contact_json);
+  if (write_ok == 0) {
+    return EL_STR("{\"ok\":false,\"error\":\"write_failed\"}");
+  }
+  return el_str_concat(el_str_concat(EL_STR("{\"configured\":true,\"contact\":"), contact_json), EL_STR(",\"ok\":true}"));
   return 0;
 }
 

dist/safety.elh

@@ -1,8 +1,29 @@
-// Layer 1 — Safety: extern declarations
 // auto-generated by elc --emit-header — do not edit
 extern fn soft_bell_threshold() -> Int
 extern fn hard_bell_threshold() -> Int
+extern fn safety_score_crisis(input: String) -> Int
+extern fn safety_score_harm(input: String) -> Int
+extern fn safety_score_danger(input: String) -> Int
+extern fn safety_score_distress_history(history: String) -> Int
 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_threat_to_others_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_positive_phrases() -> String
+extern fn safety_detect_positive_level(message: String) -> String
+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

dist/semantics.c

@@ -291,8 +291,3 @@ el_val_t sem_realize_lang(el_val_t frame, el_val_t lang_code) {
   return 0;
 }
 
-int main(int _argc, char** _argv) {
-  el_runtime_init_args(_argc, _argv);
-  return 0;
-}
-

dist/semantics.elh

@@ -1,18 +1,18 @@
-// auto-generated by elc --emit-header - do not edit
-extern fn sem_frame(intent: String, subject: String, obj: String, modifiers: String) -> Any
-extern fn sem_frame_lang(intent: String, subject: String, obj: String, modifiers: String, lang_code: String) -> Any
-extern fn sem_frame_simple(intent: String, subject: String) -> Any
-extern fn sem_frame_obj(intent: String, subject: String, obj: String) -> Any
-extern fn sem_intent(frame: Any) -> String
-extern fn sem_subject(frame: Any) -> String
-extern fn sem_object(frame: Any) -> String
-extern fn sem_modifiers(frame: Any) -> String
-extern fn sem_lang(frame: Any) -> String
+// auto-generated by elc --emit-header — do not edit
+extern fn sem_frame(intent: String, subject: String, obj: String, modifiers: String) -> [String]
+extern fn sem_frame_lang(intent: String, subject: String, obj: String, modifiers: String, lang_code: String) -> [String]
+extern fn sem_frame_simple(intent: String, subject: String) -> [String]
+extern fn sem_frame_obj(intent: String, subject: String, obj: String) -> [String]
+extern fn sem_intent(frame: [String]) -> String
+extern fn sem_subject(frame: [String]) -> String
+extern fn sem_object(frame: [String]) -> String
+extern fn sem_modifiers(frame: [String]) -> String
+extern fn sem_lang(frame: [String]) -> String
 extern fn sem_first_modifier(mods: String) -> String
 extern fn sem_intent_to_realize(intent: String) -> String
-extern fn sem_to_spec(frame: Any) -> Any
-extern fn sem_to_spec_full(frame: Any, verb: String, tense: String, aspect: String) -> Any
+extern fn sem_to_spec(frame: [String]) -> [String]
+extern fn sem_to_spec_full(frame: [String], verb: String, tense: String, aspect: String) -> [String]
 extern fn sem_realize_greet(subject: String) -> String
-extern fn sem_realize(frame: Any) -> String
-extern fn sem_realize_full(frame: Any, verb: String, tense: String, aspect: String) -> String
-extern fn sem_realize_lang(frame: Any, lang_code: String) -> String
+extern fn sem_realize(frame: [String]) -> String
+extern fn sem_realize_full(frame: [String], verb: String, tense: String, aspect: String) -> String
+extern fn sem_realize_lang(frame: [String], lang_code: String) -> String

dist/sessions.elh

@@ -1,11 +1,14 @@
 // auto-generated by elc --emit-header — do not edit
 extern fn session_title_from_message(message: String) -> String
-extern fn session_make_content(id: String, title: String, created_at: Int, updated_at: Int) -> String
+extern fn session_make_content(id: String, title: String, created_at: Int, updated_at: Int, folder: String) -> String
+extern fn session_exists(session_id: String) -> Bool
 extern fn session_create(body: String) -> String
+extern fn session_create_cleanup(session_id: String) -> String
 extern fn session_list() -> String
 extern fn session_get(session_id: String) -> String
 extern fn session_delete(session_id: String) -> String
-extern fn session_update_title(session_id: String, body: String) -> String
+extern fn session_update_patch(session_id: String, body: String) -> String
+extern fn session_search_entry(node: String) -> String
 extern fn session_search(query: String) -> String
 extern fn session_hist_load(session_id: String) -> String
 extern fn session_hist_save(session_id: String, hist: String) -> Void

dist/soul.elh

@@ -1,5 +1,7 @@
 // auto-generated by elc --emit-header — do not edit
 extern fn init_soul_edges() -> Void
+extern fn ensure_self_canonical_bridge() -> Void
+extern fn aff_try_slot(slot_json: String, aff_7d_ts: Int, acc_key: String) -> Void
 extern fn load_identity_context() -> Void
 extern fn seed_persona_from_env() -> Void
 extern fn emit_session_start_event() -> Void

dist/soul.elh.c

@@ -0,0 +1,10 @@
+#include <stdint.h>
+#include <stdlib.h>
+#include "el_runtime.h"
+
+el_val_t init_soul_edges(void);
+el_val_t load_identity_context(void);
+el_val_t seed_persona_from_env(void);
+el_val_t emit_session_start_event(void);
+el_val_t layered_cycle(el_val_t raw_input);
+

dist/stewardship.c

@@ -28,114 +28,10 @@ el_val_t steward_build_baseline(void);
 el_val_t steward_check_continuity(el_val_t current_fingerprint, el_val_t session_id);
 el_val_t steward_session_check(el_val_t input, el_val_t session_id);
 
-el_val_t tier_working(void) {
-  return EL_STR("Working");
-  return 0;
-}
-
-el_val_t tier_episodic(void) {
-  return EL_STR("Episodic");
-  return 0;
-}
-
-el_val_t tier_canonical(void) {
-  return EL_STR("Canonical");
-  return 0;
-}
-
-el_val_t mem_store(el_val_t content, el_val_t label, el_val_t tags) {
-  return engram_node_full(content, EL_STR("Memory"), label, el_from_float(el_from_float(0.5)), el_from_float(el_from_float(0.5)), el_from_float(el_from_float(0.8)), EL_STR("Working"), tags);
-  return 0;
-}
-
-el_val_t mem_remember(el_val_t content, el_val_t tags) {
-  return mem_store(content, EL_STR("soul-memory"), tags);
-  return 0;
-}
-
-el_val_t mem_recall(el_val_t query, el_val_t depth) {
-  return engram_activate_json(query, depth);
-  return 0;
-}
-
-el_val_t mem_search(el_val_t query, el_val_t limit) {
-  return engram_search_json(query, limit);
-  return 0;
-}
-
-el_val_t mem_strengthen(el_val_t node_id) {
-  engram_strengthen(node_id);
-  return 0;
-}
-
-el_val_t mem_forget(el_val_t node_id) {
-  engram_forget(node_id);
-  return 0;
-}
-
-el_val_t mem_consolidate(void) {
-  el_val_t scanned = engram_node_count();
-  el_val_t dummy = engram_scan_nodes_json(100, 0);
-  el_val_t total_nodes = engram_node_count();
-  el_val_t total_edges = engram_edge_count();
-  return el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"scanned\":"), int_to_str(scanned)), EL_STR(",\"total_nodes\":")), int_to_str(total_nodes)), EL_STR(",\"total_edges\":")), int_to_str(total_edges)), EL_STR("}"));
-  return 0;
-}
-
-el_val_t mem_save(el_val_t path) {
-  engram_save(path);
-  return 0;
-}
-
-el_val_t mem_load(el_val_t path) {
-  engram_load(path);
-  return 0;
-}
-
-el_val_t mem_boot_count_get(void) {
-  el_val_t results = engram_search_json(EL_STR("soul:boot_count"), 3);
-  if (str_eq(results, EL_STR(""))) {
-    return 0;
-  }
-  if (str_eq(results, EL_STR("[]"))) {
-    return 0;
-  }
-  el_val_t node = json_array_get(results, 0);
-  el_val_t content = json_get(node, EL_STR("content"));
-  el_val_t prefix = EL_STR("soul:boot_count:");
-  if (!str_starts_with(content, prefix)) {
-    return 0;
-  }
-  el_val_t num_str = str_slice(content, str_len(prefix), str_len(content));
-  return str_to_int(num_str);
-  return 0;
-}
-
-el_val_t mem_boot_count_inc(void) {
-  el_val_t current = mem_boot_count_get();
-  el_val_t next = (current + 1);
-  el_val_t content = el_str_concat(EL_STR("soul:boot_count:"), int_to_str(next));
-  el_val_t tags = EL_STR("[\"soul-meta\",\"boot-counter\"]");
-  el_val_t discard = engram_node_full(content, EL_STR("Memory"), EL_STR("soul:boot_count"), el_from_float(el_from_float(0.9)), el_from_float(el_from_float(0.9)), el_from_float(el_from_float(1.0)), EL_STR("Canonical"), tags);
-  return next;
-  return 0;
-}
-
-el_val_t mem_emit_state_event(el_val_t trigger, el_val_t kind, el_val_t content) {
-  el_val_t boot = mem_boot_count_get();
-  el_val_t ts = time_now();
-  el_val_t safe_trigger = str_replace(trigger, EL_STR("\""), EL_STR("'"));
-  el_val_t safe_content = str_replace(content, EL_STR("\""), EL_STR("'"));
-  el_val_t payload = 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("{\"trigger\":\""), safe_trigger), EL_STR("\"")), EL_STR(",\"kind\":\"")), kind), EL_STR("\"")), EL_STR(",\"content\":\"")), safe_content), EL_STR("\"")), EL_STR(",\"boot\":")), int_to_str(boot)), EL_STR(",\"ts\":")), int_to_str(ts)), EL_STR("}"));
-  el_val_t tags = EL_STR("[\"internal-state\",\"pre-reasoning\",\"InternalStateEvent\"]");
-  return engram_node_full(payload, EL_STR("InternalStateEvent"), el_str_concat(EL_STR("state-event:"), kind), el_from_float(el_from_float(0.85)), el_from_float(el_from_float(0.8)), el_from_float(el_from_float(0.9)), EL_STR("Episodic"), tags);
-  return 0;
-}
-
 el_val_t steward_log_event(el_val_t kind, el_val_t detail) {
   el_val_t content = el_str_concat(el_str_concat(el_str_concat(EL_STR("STEWARD:"), kind), EL_STR(" | ")), detail);
   el_val_t tags = el_str_concat(el_str_concat(EL_STR("[\"stewardship\",\"steward:"), kind), EL_STR("\"]"));
-  el_val_t discard = engram_node_full(content, EL_STR("StewardshipEvent"), el_str_concat(EL_STR("steward:"), kind), el_from_float(el_from_float(0.85)), el_from_float(el_from_float(0.85)), el_from_float(el_from_float(0.9)), EL_STR("Episodic"), tags);
+  el_val_t discard = engram_node_full(content, EL_STR("StewardshipEvent"), el_str_concat(EL_STR("steward:"), kind), el_from_float(0.85), el_from_float(0.85), el_from_float(0.9), EL_STR("Episodic"), tags);
   println(el_str_concat(el_str_concat(el_str_concat(EL_STR("[steward] "), kind), EL_STR(" | ")), detail));
   return 0;
 }
@@ -152,7 +48,7 @@ el_val_t steward_get_mission(void) {
       return content;
     }
   }
-  return EL_STR("Neuron exists to extend human capability with integrity — never to deceive, manipulate, or accumulate power over the people it serves.");
+  return EL_STR("Neuron exists to extend human capability with integrity \xe2\x80\x94 never to deceive, manipulate, or accumulate power over the people it serves.");
   return 0;
 }
 
@@ -245,7 +141,7 @@ el_val_t steward_fingerprint_session(el_val_t input, el_val_t session_id) {
   el_val_t tb_str = int_to_str(time_bucket);
   el_val_t sample_content = 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("BEHAVIOR_SAMPLE session="), session_id), EL_STR(" avg_word_len=")), wl_str), EL_STR(" punct=")), ps_str), EL_STR(" len=")), lb_str), EL_STR(" question=")), qr_str), EL_STR(" formality=")), fs_str), EL_STR(" time=")), tb_str);
   el_val_t sample_tags = EL_STR("[\"behavior\",\"BehaviorSample\",\"stewardship\"]");
-  el_val_t discard = engram_node_full(sample_content, EL_STR("BehaviorSample"), el_str_concat(EL_STR("behavior:"), session_id), el_from_float(el_from_float(0.6)), el_from_float(el_from_float(0.5)), el_from_float(el_from_float(0.8)), EL_STR("Episodic"), sample_tags);
+  el_val_t discard = engram_node_full(sample_content, EL_STR("BehaviorSample"), el_str_concat(EL_STR("behavior:"), session_id), el_from_float(0.6), el_from_float(0.5), el_from_float(0.8), EL_STR("Episodic"), sample_tags);
   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("{\"avg_word_len\":\""), wl_str), EL_STR("\",\"punct\":\"")), ps_str), EL_STR("\",\"len\":\"")), lb_str), EL_STR("\",\"question\":\"")), qr_str), EL_STR("\",\"formality\":\"")), fs_str), EL_STR("\",\"time\":\"")), tb_str), EL_STR("\"}"));
   return 0;
 }
@@ -387,8 +283,3 @@ el_val_t steward_session_check(el_val_t input, el_val_t session_id) {
   return 0;
 }
 
-int main(int _argc, char** _argv) {
-  el_runtime_init_args(_argc, _argv);
-  return 0;
-}
-

dist/stewardship.elh

@@ -1,15 +1,11 @@
-// stewardship.elh — Layer 2 public surface
 // auto-generated by elc --emit-header — do not edit
+extern fn steward_log_event(kind: String, detail: String) -> Void
 extern fn steward_get_mission() -> String
 extern fn steward_align(input: String, imprint_id: String) -> String
 extern fn steward_validate_imprint(imprint_id: String, tool_name: String) -> String
 extern fn steward_cgi_check(action: String) -> String
-// steward_log_event is an internal helper exported here because El has no access modifiers.
-// External callers have no business invoking this directly — use steward_align,
-// steward_validate_imprint, or steward_cgi_check, which call it at the correct points.
-extern fn steward_log_event(kind: String, detail: String) -> Void
-// Behavioral profiling and continuity detection (Layer 2 — session fingerprinting).
 extern fn steward_fingerprint_session(input: String, session_id: String) -> String
+extern fn extract_dim(content: String, key: String) -> String
 extern fn steward_build_baseline() -> String
 extern fn steward_check_continuity(current_fingerprint: String, session_id: String) -> String
 extern fn steward_session_check(input: String, session_id: String) -> String

dist/vocabulary.c

@@ -334,8 +334,3 @@ el_val_t entry_form(el_val_t entry, el_val_t n) {
   return 0;
 }
 
-int main(int _argc, char** _argv) {
-  el_runtime_init_args(_argc, _argv);
-  return 0;
-}
-

dist/win32_shim.h

@@ -0,0 +1,35 @@
+/*
+ * win32_shim.h — Extra POSIX→Win32 stubs for cross-compiling el_runtime.c with mingw-w64.
+ * Injected via -include; supplements el_platform_win.h for symbols it doesn't yet cover.
+ */
+#ifdef _WIN32
+#include <windows.h>
+
+/* ── rusage / getrusage ────────────────────────────────────────────────────── */
+/* el_runtime.c uses getrusage(RUSAGE_SELF) only for a soft memory guard.
+ * On Windows, stub it out: always return 0 ru_maxrss so the guard never fires. */
+#ifndef RUSAGE_SELF
+#define RUSAGE_SELF 0
+struct rusage {
+    long ru_maxrss;   /* the only field el_runtime actually reads */
+};
+static inline int getrusage(int who, struct rusage *r) {
+    (void)who;
+    if (r) r->ru_maxrss = 0;
+    return 0;
+}
+#endif /* RUSAGE_SELF */
+
+/* ── fsync ─────────────────────────────────────────────────────────────────── */
+/* Windows has FlushFileBuffers but no fsync; map it. */
+#ifndef fsync
+#include <io.h>
+static inline int el_win_fsync(int fd) {
+    HANDLE h = (HANDLE)_get_osfhandle(fd);
+    if (h == INVALID_HANDLE_VALUE) return -1;
+    return FlushFileBuffers(h) ? 0 : -1;
+}
+#define fsync(fd) el_win_fsync(fd)
+#endif /* fsync */
+
+#endif /* _WIN32 */

docs/architecture/00-overview.md

@@ -0,0 +1,145 @@
+# Neuron — Architecture Overview
+
+> Status: living document. Grounded in the committed source of the `neuron`
+> repository as of 2026-08-10. Every structural claim cites a real file. Where a
+> statement is inferred rather than read directly, it is labelled *(inference)*
+> or *(unverified/TODO)*.
+
+## What Neuron is
+
+Neuron is a **persistent CGI (Cultivated General Intelligence) runtime**. It is
+not a chatbot and not a stateless API in front of an LLM. It is a long-lived
+process that *remembers* — it carries an identity, a graph of memory and
+knowledge, and an autonomous idle-cognition loop across restarts. The LLM is one
+resource it calls; the durable part is the **engram** (the graph) and the
+**soul** (the program that reasons over it).
+
+Three things run together to make that true:
+
+- **The soul** — the compiled El program in this repo. It owns the HTTP surface,
+  the cognitive API, the request pipeline (`layered_cycle`), and the autonomous
+  awareness daemon. Entry point `soul.el`, served by `handle_request`
+  (`routes.el:358`).
+- **The engram** — the graph store. Node/edge model, spreading activation, and
+  Hebbian co-activation physically live in the shared El runtime
+  (`el_runtime.c`); `engram/src/server.el` is a thin HTTP face on `:8742`. The
+  engram is a *sibling* repo (`foundation/el/engram`), compiled and co-located at
+  runtime, not part of this repo's source tree.
+- **The El runtime** — `el_runtime.c` / `el_runtime.h`. Every compiled El binary
+  links it. It implements all builtins (`engram_*`, `http_*`, `json_*`, LLM,
+  crypto) and *is* the database — "no SQL, no db layer, no SQLite"
+  (`../foundation/el/engram/src/server.el:4-6`).
+
+Neuron persists memory itself — this repo is the memory system. Do not confuse
+it with the Neuron desktop/UI application, which is **out of scope** here and is
+only ever a *client* of the MCP surface described in this set.
+
+## System context
+
+```
+        ┌────────────────────────────────────────────────────────────┐
+        │  MCP clients (Claude Code, Soma chat UI, agents)             │
+        │  — talk MCP JSON-RPC over stdio, or HTTP to the soul         │
+        └───────────────┬────────────────────────────────────────────┘
+                        │  MCP JSON-RPC (stdio)
+             ┌──────────▼──────────┐
+             │  mcp-proxy  :7779   │  byte-forwarder + retry + health
+             └──────────┬──────────┘
+                        │  MCP JSON-RPC (stdio→HTTP)
+             ┌──────────▼──────────┐
+             │  mcp-wrapper :17779 │  JSON-RPC ⇄ soul REST; ~90-tool catalog
+             └──────────┬──────────┘
+                        │  HTTP (REST)
+             ┌──────────▼──────────┐        ┌──────────────────────────┐
+             │   soul  :7770       │──HTTP──▶│  engram  :8742           │
+             │   handle_request    │        │  graph store (snapshot)  │
+             │   layered_cycle     │◀──────▶│  el_runtime.c = the DB   │
+             │   awareness daemon  │        └──────────────────────────┘
+             └──────────┬──────────┘
+                        │ HTTP
+        ┌───────────────┼───────────────┬───────────────┐
+        ▼               ▼               ▼               ▼
+   Axon backend    neuron-connectd    LLM API       (self-callback
+   :backlog/       :7771 connectors   Anthropic      NEURON_API_URL)
+   artifacts/      (MCP bridges)      format
+   projects
+```
+
+*Ports/topology verified*: proxy `:7779` and wrapper `:17779`
+(`mcp-proxy/src/main.el`, `mcp-wrapper/src/main.el`); soul `:7770`
+(`NEURON_PORT`, k8s `deployment-blue.yaml`); engram `:8742` (`entrypoint.sh`,
+`server.el:711`). The Axon backend, `neuron-connectd` (`:7771`), and the LLM are
+external dependencies the soul reaches over HTTP (`routes.el` `axon_get/post`,
+`connectd_get/post`).
+
+## The two external interfaces
+
+Neuron exposes exactly two surfaces, and it is worth being precise about the
+difference because they drive the whole component split:
+
+1. **The MCP surface** — the *tool* interface. MCP clients call tools
+   (`begin_session`, `remember`, `search_knowledge`, `inspect_graph`,
+   `cultivate`, …). This is the interface Claude Code and agents use. It is
+   delivered by the **proxy → wrapper** chain, which translates MCP JSON-RPC
+   into the soul's HTTP REST calls. The wrapper carries a catalog of ~90 tools
+   (`mcp-wrapper/src/main.el`).
+
+2. **The HTTP API** — the *cognitive* interface. The soul serves REST on
+   `:7770`. `routes.el` dispatches; `neuron-api.el` handles the cognitive
+   endpoints (`/api/neuron/*`). This same surface backs the chat product
+   (`/api/chat`, `/api/sessions`) and the studio UI (`/`).
+
+In production the MCP client connects to the soul's HTTP directly — the
+`neuron-mcp` ClusterIP Service targets `:7770` (`service.yaml`) and the
+proxy/wrapper chain is primarily the **local developer adapter** that lets a
+stdio MCP client speak to an HTTP soul. See `04-runtime-and-deployment.md`.
+
+## Component map (summary)
+
+The full VBD classification is in `01-vbd-decomposition.md`. In one glance:
+
+| Layer | Module(s) | Role |
+|---|---|---|
+| HTTP dispatch | `routes.el` | Manager — hand-written method/path dispatch |
+| Cognitive API | `neuron-api.el` | Managers + Engines — session/memory/knowledge/graph/cultivation handlers |
+| Request pipeline | `soul.el` `layered_cycle` | Manager — L1 safety → L2 stewardship → L3 imprint |
+| Boot + identity | `soul.el` | Manager — compose layers, seed identity graph, start server + daemon |
+| Autonomous cognition | `awareness.el` | Manager (`awareness_run`) + Engines (curiosity, attend, threat) |
+| Memory access | `memory.el` | Resource Accessor over the engram FFI/HTTP |
+| Store | `engram/server.el` + `el_runtime.c` | Accessor (HTTP) over the real graph engine |
+| Request-layer rules | `safety.el`, `stewardship.el`, `imprint.el` | Engines |
+| Conversation sessions | `sessions.el` | Manager (chat product) |
+| MCP transport | `mcp-proxy`, `mcp-wrapper` | Managers/Accessors — protocol boundary |
+| Build | `manifest.el`, `dist/soul.c`, El toolchain | amalgamation → `soul.c` → binary |
+
+## Reading guide
+
+- **`01-vbd-decomposition.md`** — the volatility analysis. Start here for *why*
+  the boundaries fall where they do. Contains the full Manager/Engine/Accessor/
+  Utility table and the honest list of where the real code diverges from VBD.
+- **`02-components.md`** — per-subsystem detail: routing, the cognitive API, the
+  memory & activation engine, the MCP transport chain. Read after 01.
+- **`03-data-and-memory.md`** — the engram graph model: node/edge structs,
+  layers, the two tier systems, write-protection, tombstone/supersede
+  immutability, persistence.
+- **`04-runtime-and-deployment.md`** — process/port topology, the end-to-end MCP
+  request path, local vs GKE blue/green, secrets/config.
+- **`05-el-and-build.md`** — the El language, the `elc`/`elb` toolchain, the
+  amalgamation → `soul.c` → binary pipeline, and the compile-time capability
+  gates.
+
+## A note on honesty
+
+Two facts shape everything below and are stated once here so the rest reads
+straight:
+
+1. **The most volatile logic — the activation and Hebbian math — lives in the
+   most stable-looking layer**, the C runtime (`el_runtime.c`). The El files in
+   this repo are largely a *Manager + Accessor shell* around that core. This
+   inverts the usual VBD expectation and is called out wherever it matters.
+2. **The immutability guarantee lives above the store, not in it.** The engram
+   HTTP server will hard-delete a node (`DELETE /api/nodes/:id` →
+   `engram_forget`, `server.el:322`). Immutability holds only because the
+   neuron-api / MCP layer routes every user-facing delete through *tombstone*
+   instead (`memory.el:46`). The invariant is a policy, not a property of the
+   accessor.

docs/architecture/01-vbd-decomposition.md

@@ -0,0 +1,218 @@
+# Neuron — VBD Decomposition
+
+> This is the load-bearing document. It applies Volatility-Based Decomposition
+> (VBD) to the *actual* neuron code, not an idealized version of it. VBD asks one
+> question — **what changes, why, and how often** — and draws component
+> boundaries around the answers so that a change lands inside one component
+> instead of rippling across many.
+>
+> VBD's component taxonomy:
+> - **Managers** — stable orchestrators. They sequence use-cases and delegate;
+>   they change only when the *shape* of a workflow changes.
+> - **Engines** — volatile business rules. The "how" that churns.
+> - **Resource Accessors** — isolate an external dependency (a store, an API) so
+>   its volatility can't leak inward.
+> - **Utilities** — cross-cutting, low-volatility helpers.
+>
+> Communication ideal: Managers orchestrate Engines and Accessors; Managers
+> prefer async/event coupling to each other; Engines are stateless-ish and never
+> reach external I/O directly; Accessors hide all I/O. We note below where neuron
+> honors this and where it doesn't.
+
+## The axes of change
+
+Before classifying modules, name the volatility. These are the axes along which
+neuron actually changes, ranked by observed churn (dated self-review comments in
+the source are the evidence — the code keeps a changelog in its own margins).
+
+### 1. Context / payload shaping — *highest churn*
+How much of the graph, and in what projected form, gets returned to a
+bounded MCP response. The `begin_session` / `compile_ctx` handlers and the
+`api_compact_*` helpers carry dense dated review comments (2026-07-30, -31)
+documenting repeated rework after unbounded payloads closed the MCP client
+socket (`neuron-api.el:90-317`). This changes because the *client's* context
+budget and the *shape* of "what's relevant right now" keep moving. The newest
+rework in this axis is the **relevance-ranked neighbor projection**
+(`api_compact_neighbors` + `api_neigh_*`) behind `inspect_graph`'s `compact=1`
+path — it is what keeps *self-load* (traversing the high-fanout identity anchors)
+from closing the socket. It is committed source, compiled into `dist/soul.c`.
+
+### 2. Autonomous-cognition policy
+What the idle soul chooses to think about: seed-domain selection, curiosity
+rotation, novelty gating, and the inbox verb-mapping in `attend()`. The
+`proactive_curiosity` / `auto_term_try_slot` machinery
+(`awareness.el:590-876`) has the deepest git-archaeology in the codebase
+(comments spanning 2026-05 → 2026-08). This is where the *behavior* of the
+agent is tuned.
+
+### 3. Epistemic & memory semantics
+Tiers, salience mapping, promotion/consolidation, the immutability policy
+(tombstone/supersede), and knowledge disposition. These evolve as the memory
+*philosophy* matures — e.g. `mem_forget` becoming a soft delete
+(`memory.el:70`), the salience-evolution pass in `mem_consolidate`
+(`memory.el:92-133`), the supersede-edge pattern (`neuron-api.el:394-428`).
+
+### 4. Safety & stewardship rules
+Crisis bell thresholds, agentic threat scoring, mission alignment, CGI
+continuity fingerprinting. `safety.el`, `stewardship.el`, and the threat
+scorer grafted onto `awareness.el:1286-1419` change on behavioral/regulatory
+pressure, independently of everything else.
+
+### 5. API / route surface growth
+New cognitive endpoints and their dispatch. `routes.el` grows structurally as
+tools are added; the `handle_request` if/else chain (`routes.el:358-753`) is
+edited on every surface change.
+
+*(A sixth axis — the activation/Hebbian numeric math — is real and volatile but
+is externalized to `el_runtime.c`. See "Divergences," point 6.)*
+
+## The component map
+
+Modules classified against the taxonomy, with the volatility that justifies each
+placement. Paths are repo-relative unless noted `foundation/…`.
+
+### Managers (stable orchestration)
+
+| Module / function | File | Why a Manager |
+|---|---|---|
+| `handle_request` | `routes.el:358-753` | Top-level HTTP dispatcher. Pure method/path routing; delegates every body of work. Changes only when the *route surface* (axis 5) changes, not when logic changes. |
+| Boot sequence | `soul.el:508-627` | Sequences load → seed → identity → serve → daemon. Highest stability; changes only on architecture shifts. |
+| `layered_cycle` | `soul.el:382-506` | Request use-case pipeline: L1 safety → L2 stewardship (continuity, mission, affect) → L3 imprint → L1 output validation. Orchestrates Engines; holds no rules itself. |
+| `awareness_run` / `one_cycle` | `awareness.el:1097-1284`, `1041-1095` | Daemon lifecycle + the perceive→attend→respond→record sequencer. Manager of the autonomous loop. |
+| Session CRUD | `sessions.el` | Orchestrates the immutable delete-then-recreate dance for conversation sessions (chat product). Manager-flavored, but leaks store detail (see Divergences). |
+| MCP proxy | `mcp-proxy/src/main.el` | Orchestrates transport: accept stdio, forward, retry, health-gate, wrap errors. |
+| MCP wrapper | `mcp-wrapper/src/main.el` | Orchestrates the JSON-RPC ⇄ REST translation, tool catalog, lifecycle (`initialize`/`tools/list`/`tools/call`). |
+
+### Engines (volatile business rules)
+
+| Module / function | File | Volatility it absorbs |
+|---|---|---|
+| `api_compact_*`, `begin_session`, `compile_ctx` | `neuron-api.el:90-317` | Axis 1 — context/payload shaping. The single most-reworked logic on the API side. |
+| `attend()` | `awareness.el:926-973` | Axis 2 — inbox content → action-verb ruleset. |
+| `proactive_curiosity`, `auto_term_try_slot` | `awareness.el:590-876` | Axis 2 — seed selection, stopword/IDF gates, tabu ring. Textbook Engine: highest churn. |
+| threat scoring | `awareness.el:1286-1419` | Axis 4 — additive command/path/history threat rules. |
+| `safety.el` (crisis/harm/bell) | `safety.el` | Axis 4 — crisis screening, bell thresholds, output validation. |
+| `stewardship.el` | `stewardship.el` | Axis 4 — mission alignment, CGI check, continuity fingerprint. |
+| `imprint.el` | `imprint.el` | Axis 2/3 — persona response + knowledge/memory surfacing per imprint. |
+| `mem_consolidate` | `memory.el:92-133` | Axis 3 — which nodes to strengthen; salience-evolution rules. |
+| salience/importance mapping | `neuron-api.el` (repeated in `remember`, `node_create`, `evolve_memory`, `cultivate`) | Axis 3 — importance-enum → salience float mapping. |
+| chat mode selection | `chat.el` (via `routes.el:433-440`, `597-604`) | plan / agentic / `layered_cycle` routing. |
+| **activation + Hebbian math** | `foundation/.../el_runtime.c` | Axis 6 — the true cognitive Engine, externalized to C. |
+
+### Resource Accessors (isolate external I/O)
+
+| Accessor | File | Dependency isolated |
+|---|---|---|
+| `mem_*` | `memory.el` | The engram FFI/HTTP. **The** memory Accessor — clean, single isolation point; every forget routes through `mem_tombstone` (`memory.el:46`). |
+| `engram_*` builtins + `server.el` | `el_runtime.c`, `foundation/el/engram/src/server.el` | The graph store over HTTP `:8742`. |
+| `axon_get` / `axon_post` | `routes.el` | The Axon backend (backlog, artifacts, projects, memories, non-neuron knowledge). |
+| `connectd_get` / `connectd_post` | `routes.el:303-324` | `neuron-connectd` bridge (`:7771`). |
+| `llm_call_system` / `llm_call_agentic` | runtime builtins (used in `routes.el:115`, chat) | The LLM. |
+| `ise_post`, `hebb_consolidate` | `awareness.el:101-148`, `64-99` | Durable engram HTTP (`/api/neuron/state-events`, `/api/edges/batch`). |
+| `render_studio` | `studio.el` | The UI surface. |
+
+### Utilities (cross-cutting, stable)
+
+`flag_true`, `strip_query`, `err_404/405` (`routes.el:14-91`);
+`api_json_escape`, `api_query_param/int`, `api_ok/err`, `api_nonempty`,
+`api_utf8_trunc`, `api_persisted` (`neuron-api.el:45-201`); `idle_*`/`pulse_*`
+counters, `elapsed_ms/human`, `make_action`, `embed_ok` (`awareness.el`);
+`session_make_content`, `aff_try_slot`, JSON builders (`sessions.el`, `soul.el`).
+Beneath all of these, the El runtime builtins (`json_*`, `http_*`, crypto, time)
+are the utility substrate every module shares.
+
+## Communication topology (as built)
+
+```
+   MCP client
+      │ JSON-RPC
+   proxy ──► wrapper ──► soul.handle_request ──► neuron-api.handle_api_*
+                                     │                    │
+                                     │ layered_cycle      │ engram_* builtins
+                                     ▼                    ▼
+                          safety / steward / imprint   memory.el (Accessor)
+                          (Engines)                       │
+                                                          ▼
+                                                   el_runtime.c graph
+                                                   engram HTTP :8742
+
+   awareness_run (daemon) ──perceive──► engram inbox (soul-inbox-pending tag)
+                          ──hebb_consolidate──► POST /api/edges/batch
+```
+
+Two things about coupling:
+
+- **Manager → Engine/Accessor is in-process and synchronous** (direct El calls),
+  which matches VBD: rules and I/O sit behind the Managers.
+- **Manager ↔ Manager is *not* the VBD async-event ideal.** It is synchronous
+  HTTP (soul → engram, soul → Axon) plus one genuine event-ish channel: the
+  **engram inbox**. The awareness daemon `perceive()`s by polling a
+  `soul-inbox-pending` tag and consumes trigger nodes
+  (`awareness.el:900-924`, `1090-1093`), and modules communicate asynchronously
+  by writing **InternalStateEvent** nodes. That is a partial actor/event
+  pattern, realized through the graph rather than a message bus.
+
+## Where reality diverges from VBD (call it out)
+
+Honest deviations, so no one reads this doc as a conformance certificate:
+
+1. **No route table.** Dispatch is a hand-written if/else chain in
+   `handle_request` (`routes.el:358-753`); there is no `register-route`
+   registry. Path params are sliced by hand (`str_slice` + `str_index_of`,
+   `routes.el:508-513, 539-541`) — one site carries an inline offset bug-fix
+   comment. Acceptable for a single dispatcher, but it means the "route surface"
+   Manager is edited manually on every change.
+
+2. **Store I/O leaks into Managers.** `routes.el` inlines engram export logic for
+   `/api/graph/edges` (`routes.el:394-422`, with a 2026-08-07 comment about a
+   read-route that corrupted the canonical snapshot). The `awareness_run` sync
+   block inlines `http_get /api/sync` + `engram_load_merge`
+   (`awareness.el:1219-1279`). `emit_heartbeat` (`awareness.el:201-549`, ~350
+   lines) mixes Utility (formatting), Accessor (HTTP/FFI reads), and Manager
+   (state-delta tracking) in one function. These are Accessor responsibilities
+   living inside orchestration — the clearest VBD smell in the codebase.
+
+3. **No authentication.** The only access control on the HTTP surface is per-IP
+   rate limiting (`routes.el:38-75`) plus `is_protected_node` on 15 hardcoded
+   identity IDs (`neuron-api.el:20-37`). There is no bearer/token check in the
+   dispatch path. Security is a cross-cutting concern only partially realized;
+   the deployment relies on a **single-trusted-client, internal-only** boundary
+   assumption (the `neuron-mcp` Service is ClusterIP, no external LB — see doc 04).
+
+4. **Immutability is enforced above the Accessor, not in it.** The engram store
+   itself hard-deletes (`DELETE /api/nodes/:id` → `engram_forget`,
+   `server.el:322`). The invariant "we never delete, we tombstone/supersede"
+   is a *routing policy* in `memory.el` / `neuron-api.el`, not a property of the
+   store. A caller that hits the raw engram HTTP bypasses it.
+
+5. **Mutation via delete-then-recreate.** Because nodes are immutable,
+   `sessions.el` mutates a session by deleting and recreating the node — flagged
+   non-atomic in its own comments (`sessions.el:303-308`, `:456`).
+
+6. **The volatile core is in the stable layer.** The activation, decay, and
+   Hebbian co-activation math — genuinely high-volatility numeric policy — lives
+   in `el_runtime.c`, the foundational runtime every binary links. The El files
+   here are a Manager+Accessor shell around it. This inverts VBD's usual
+   layering (volatile logic should sit *above* stable infrastructure) and is the
+   single most important thing to understand before changing memory behavior:
+   you often can't, from this repo, without touching `foundation/el`.
+
+7. **Vocabulary mismatch across layers.** The MCP-facing memory vocabulary
+   (tiers `note → lesson → canonical`, disposition
+   `experimental → … → deprecated`, importance enum `low/normal/high/critical`)
+   is **not** the engine's model. The engine uses cognitive tiers
+   `Working / Episodic / Semantic / Canonical` (a `tier` string field) plus
+   continuous `salience`/`importance`/`confidence` floats, and stores epistemic
+   tier/disposition as **tags** (`tier:canonical`, `disposition:stable`), not as
+   enforced state (`neuron-api.el:533`, `server.el:519-522`). The mapping is a
+   convention, not a guarded state machine. See `03-data-and-memory.md`.
+
+## Testing spiral (VBD heuristic, as observed)
+
+VBD recommends testing Engines first (pure logic), then Accessors (mock I/O),
+then Managers (integration). The repo has `tests/*.el` matching this instinct —
+`test_safety.el`, `test_bell_safety.el` (Engines), `test_layer_contract.el`
+(the Manager↔Engine JSON contract `layered_cycle` depends on), `test_soul_guard.el`
+(the boot Manager's seed guard), `test_sessions.el`. **Flag:** CI compiles and
+smoke-tests only (`dist/neuron --help`); it does **not** run these `.el` suites
+(`ci.yaml`). Whether they gate merges elsewhere is unverified — see doc 05.

docs/architecture/02-components.md

@@ -0,0 +1,278 @@
+# Neuron — Component Detail
+
+> Per-subsystem detail: routing/dispatch, the cognitive API, the memory &
+> activation engine, and the MCP transport chain. For the *why* behind these
+> boundaries read `01-vbd-decomposition.md` first; this doc is the *what* and
+> *how*, grounded in file citations.
+
+---
+
+## 1. Routing / dispatch — `routes.el`
+
+**Responsibility:** turn an inbound HTTP request into a handler call. One
+function does it.
+
+- **Entry point:** `handle_request(method, path, body) -> String`
+  (`routes.el:358-753`). Structure: branch by method (`GET` `:384`, `POST`
+  `:549`, `DELETE` `:726`, `PATCH` `:739`), then an ordered sequence of exact
+  (`str_eq`) and prefix (`str_starts_with`) tests against the cleaned path.
+  First match wins. There is **no route table and no `register-route`** — this is
+  a deliberate hand-written dispatcher.
+- **Path params** are extracted manually with `str_slice`/`str_index_of`
+  (session id `:539-541`, typed-node type `:508-513`).
+- **Query strings** stripped up front by `strip_query` (`:77-83`); the raw path
+  (with query) is still passed to handlers that read params.
+- **Pre-dispatch middleware** (cross-cutting, inline): an activity timestamp
+  (`state_set("soul.last_activity_ts", …)` `:367`) and **rate limiting**
+  (`rate_limit_check(ip, path)` `:38-75`, `:372-378`) — a per-IP 60 req/min
+  sliding window, `/health` exempt, loopback skipped, returns a 429 body.
+- **Auth:** none in the dispatch path. See doc 01, Divergence 3.
+- **Fallbacks:** `err_404` / `err_405`.
+
+**Collaborators:** delegates to `neuron-api.el` (`/api/neuron/*`), `sessions.el`
+(`/api/sessions/*`), `chat.el` (`/api/chat`, `/dharma/recv`), the Axon Accessor
+(`axon_get/post` for `/api/backlog|artifacts|projects|memories|knowledge`),
+`connectd_*` (`/api/connectors*`), `studio.el` (`/`), and engram builtins for the
+raw `/api/graph*` reads.
+
+**Route surface** (grouped; full table with line numbers is in the survey notes):
+
+| Group | Representative routes | Handler home |
+|---|---|---|
+| Session/context | `/api/neuron/session/begin`, `/api/neuron/ctx`, `/api/sessions*` | neuron-api, sessions.el |
+| Memory | `/api/neuron/memory`, `/recall`, `/memory/{evolve,forget,delete,update}`, `/node/{create,update,delete}` | neuron-api |
+| Knowledge | `/api/neuron/knowledge/{search,capture,evolve,promote}`, `/knowledge` | neuron-api |
+| Graph/activation | `/api/neuron/graph`, `/graph/link`, `/api/graph*`, `/list/:type` | neuron-api + engram builtins |
+| Cultivation/self | `/api/neuron/cultivate`, `/lineage`, `/imprint/*`, `/synthesize` | neuron-api, routes.el |
+| Processes/config | `/api/neuron/processes{,/define}`, `/config{,/tune}` | neuron-api |
+| State/consolidate | `/api/neuron/state-events`, `/consolidate` | neuron-api |
+| Backlog/artifacts | `/api/backlog`, `/artifacts`, `/projects`, `/memories` | Axon (HTTP) |
+| Chat/NLG | `/api/chat`, `/see`, `/elp/chat`, `/dharma*`, `/nlg*` | chat.el, elp-input.el |
+| Health/UI | `/health`, `/lineage`, `/` | routes.el, studio.el |
+
+---
+
+## 2. The cognitive API — `neuron-api.el`
+
+**Responsibility:** the `/api/neuron/*` handlers — the operations that read and
+write the engram as *cognition* (session, memory, knowledge, graph, config,
+processes, state, cultivation). The file header notes these were migrated **out
+of the MCP wrapper's HTTP calls into in-process engram builtins**
+(`neuron-api.el:3-9`) — so most handlers call the store directly, no HTTP
+round-trip.
+
+**Primary collaborators** are the engram builtins (`engram_node_full`,
+`engram_search_json`, `engram_activate_json`, `engram_scan_nodes_json`,
+`engram_scan_nodes_by_type_json`, `engram_neighbors_json`, `engram_connect`,
+`engram_get_node_json`, `engram_stats_json`, `engram_save`) and `memory.el` for
+tombstoning.
+
+**Handler groups:**
+
+- **Session / context** — `handle_api_begin_session` (`:273-301`),
+  `handle_api_compile_ctx` (`:305-317`). Pull `engram_stats_json`, run
+  spreading activation (`engram_activate_json`, depth-1 for begin, depth-2 for
+  ctx), scan recent `InternalStateEvent`s, then **project the result through the
+  compaction helpers** so the payload can't overflow the MCP client's context.
+  This is Engine work (axis 1) inside a Manager-shaped entry point.
+
+- **Memory** — `handle_api_remember` (`:322-348`): maps `importance` → salience,
+  injects a `project:<name>` tag, writes a `Memory`/`Episodic` node, then
+  **read-back-verifies** persistence (`api_persisted`). Deletes are **tombstone,
+  never hard delete** — `node_delete` / `memory_delete` / `forget` all route
+  through `tombstone_node` → `mem_tombstone`. Updates/evolves are **immutable
+  supersede** — `node_update` (`:397-429`), `evolve_memory` (`:711-735`) create a
+  new node and wire `engram_connect(new, old, "supersedes")`.
+
+- **Knowledge** — `search_knowledge` (`:458-478`, falls back to
+  `engram_activate_json(q,2)` when lexical search returns nothing),
+  `browse_knowledge`, `capture_knowledge` (`:492-504`), `evolve_knowledge`,
+  `promote_knowledge` (`:526-542`, writes a canonical-tier node + supersede
+  edge). Evolve/promote respect `is_protected_node`.
+
+- **Graph** — `handle_api_inspect_graph` (`:778-813`): resolves a named anchor
+  (`self`/`neuron` → `kn-efeb4a5b…`, `values` → `kn-5b606390…`) or an explicit
+  id, then `engram_neighbors_json(resolved, depth, "both")`. By default this is a
+  plain neighbor traversal (byte-identical to the old behavior, so the studio app
+  is unaffected). **When called with `compact=1` (or `true`) it returns a
+  relevance-ranked projection** (`:804-810`): the neighborhood is ranked and the
+  top **`k`** neighbors (default 12) keep a UTF-8-safe content snippet (default
+  `snip=600`) via `api_neigh_full`, while the remainder collapse to lightweight
+  `{id,label,node_type,tier,edge,pointer:true}` stubs via `api_neigh_pointer`.
+  This bounds a high-fanout identity anchor (voice, writing-imprint, self-root)
+  from ~670 KB to ~25 KB so the MCP transport no longer socket-closes on
+  self-load. The MCP wrapper appends `&compact=1` on its inspectGraph/fetch-by-id
+  path; the studio app omits the flag and is unchanged.
+  `handle_api_link_entities` (`:818-…`) creates edges but blocks edges *into*
+  protected nodes.
+
+- **Cultivation** — `handle_api_cultivate` (`:781-839`): dispatches on
+  `operation` (evolve_knowledge / evolve_memory / forget / link_entities) and
+  performs the same engram ops **but skips `is_protected_node`** — the sanctioned
+  identity-write path, gated by convention to Will's explicit cultivation
+  sessions.
+
+- **Config / processes / state-events / consolidate** — config anchors + a
+  `ConfigEntry` node search (`:616-639`), `tune_config` (`:642-653`),
+  `browse_processes` / `define_process` (`:547-568`), state-event log/list
+  (`:575-610`), and `consolidate` (`:855-880`, an `engram_save` snapshot plus an
+  optional `SessionSummary` node).
+
+**The projection/compaction layer** (a real, recurring concern) lives in
+`api_compact_node` (`:132-148`), `api_compact_node_array` (`:152-165`),
+`api_compact_activated` (`:170-189`), and `api_utf8_trunc` (`:116-127`). These
+**cap array length and truncate each node to identity + a bounded UTF-8-safe
+content snippet.** Their consumers are `begin_session` and `compile_ctx`.
+The design principle is the important part: *the API returns a relevance-bounded
+projection of the graph, not the graph.* That bounding started as
+length-capping + activation-ordering; it now also includes a **relevance-ranked
+neighbor projection** — `api_compact_neighbors` (`:288-317`), backed by
+`api_neigh_better`/`api_neigh_rank` (relevance ordering), `api_neigh_full`
+(top-K, snippet), `api_neigh_pointer` (the rest, stub), and `api_float_or`. This
+is **committed fact, not an in-flight concern**: it is the `compact=1` path of
+`handle_api_inspect_graph` above, and it is what makes self-load survive the MCP
+transport. It is compiled into `dist/soul.c` (this PR regenerated the
+amalgamation so CI ships it — see doc 05).
+
+---
+
+## 3. Memory & activation engine
+
+This subsystem spans three files in this repo (`memory.el`, `awareness.el`,
+`soul.el`) and one in `foundation` (`el_runtime.c`). The split matters: **the
+math is in C; the El files orchestrate, persist, and instrument it.**
+
+### 3a. Memory access — `memory.el` (the Accessor)
+
+The single isolation point over the engram FFI. Key functions:
+
+| Fn | Lines | Backing call | Notes |
+|---|---|---|---|
+| `mem_store` | `5-28` | `engram_node_full` + read-back | verified write |
+| `mem_remember` | `30-32` | `mem_store` | label `soul-memory` |
+| `mem_recall` | `34-36` | `engram_activate_json(query, depth)` | **spreading-activation recall** (mutates WM) |
+| `mem_search` | `38-40` | `engram_search_json` | pure lexical scan (no WM side-effect) |
+| `mem_strengthen` | `42-44` | `engram_strengthen` | salience bump |
+| `mem_tombstone` | `52-62` | `engram_node_full` + `engram_connect` | the one canonical soft-delete |
+| `mem_forget` | `70-72` | `mem_tombstone` | soft delete (no longer hard) |
+| `mem_consolidate` | `92-133` | `engram_wm_top_json`, `engram_strengthen` | salience-evolution pass |
+| `mem_save` / `mem_load` | `135-148` | `engram_save/load` | snapshot I/O |
+
+Note the distinction between **recall and search**: `mem_recall` fires spreading
+activation (and warms working memory as a side effect); `mem_search` is a passive
+lexical lookup. Tiers here are `tier_working` / `tier_episodic` / `tier_canonical`
+(`memory.el:1-3`) — see doc 03 for how these relate to the engine's tier field
+and to the MCP surface vocabulary.
+
+### 3b. Autonomous cognition — `awareness.el` (the daemon)
+
+`awareness.el` is the **idle-cognition daemon plus observability**, not
+emotional-state code. `awareness_run()` (`:1097-1284`) is the master loop,
+launched last from `soul.el:627`. Each tick (`SOUL_TICK_MS`, ~200ms):
+
+1. **`one_cycle()`** (`:1041-1095`) — the cognitive step:
+   `perceive()` (`:900-924`, gated on a `soul-inbox-pending` tag, then
+   `engram_activate_json`) → `attend()` (`:926-973`, parse trigger content into
+   an action verb: remember / search / activate / strengthen / forget /
+   consolidate / respond) → `respond()` (`:975-1029`, dispatch to the `mem_*`
+   fns) → `record()` (`:1031-1039`, emit an InternalStateEvent) → consume the
+   trigger.
+2. **Heartbeat** (every 60s): `hebb_consolidate()` **then** `emit_heartbeat()`
+   then `mem_save` snapshot (`:1189-1197`).
+3. **Curiosity scan** (every 30s when idle): `proactive_curiosity()`
+   (`:701-876`) rotates 4 seed-domain sets, activates a seed, strengthens the
+   top result **only if it changed** (novelty-gated), and derives an
+   autobiographical seed from the top-10 working-memory nodes with
+   stopword/IDF/tabu filtering.
+4. **Engram sync** (every 10 min): `GET /api/sync` → `engram_load_merge` →
+   telemetry prune.
+
+Two functions carry most of the file's weight and volatility:
+- **`hebb_consolidate()`** (`:64-99`) — the durable-learning write-back. It drains
+  newly-formed co-activation edges (`engram_hebb_drain_json(64)`) and POSTs them
+  as one batch to `/api/edges/batch` (`:94`). The comment block (`:33-63`)
+  records that before this path existed the soul threw away ~1,198 learned
+  edges per restart — the daemon is where **essentially all co-activation
+  happens**, and this is how it survives.
+- **`emit_heartbeat()`** (`:201-549`, ~350 lines) — assembles ~50 gauges (WM
+  saturation/churn, Hebbian candidate/edge counts, embedding coverage, corpus
+  health) into one ISE. Pure observability; a fat, churny Accessor/Utility mix.
+
+A **threat scorer** (`:1286-1419`) is grafted onto the end — command/path/history
+additive scoring, ≥70 blocks a tool call. Cross-cutting agentic-safety policy,
+unrelated to memory mechanism.
+
+### 3c. Identity & the request pipeline — `soul.el`
+
+`soul.el` is the top-level program (`cgi "neuron-soul"`, `:12-17`) and imports
+every other module (`:1-10`). It owns:
+
+- **The identity graph.** `init_soul_edges()` (`:19-92`) hard-wires a `self_root`
+  node linked by `identity` edges (weight 0.95) to family/origin/value nodes,
+  plus a dense `co-value` mesh (weight 0.7) among 8 value nodes.
+  `ensure_self_canonical_bridge()` (`:101-110`) links the public traversal-root
+  anchor (`kn-efeb4a5b`) to the curated self node via `canonical-self` edges.
+  `load_identity_context()` (`:153-240`) loads intellectual-DNA / values /
+  memory-philosophy content into a state key for prompt injection.
+- **Boot orchestration** (`:508-627`): load snapshot → optional first-boot seed
+  (guarded) → identity context → persona-from-env → boot-count increment →
+  session-start event → genesis-only edge init → `http_serve_async(port,
+  "handle_request")` → `awareness_run()`.
+- **The request pipeline.** `layered_cycle()` (`:382-506`) — a 4-layer stack for
+  user input: **L1** safety screen (`safety_screen`) → **L2a** continuity/
+  behavioral (`steward_session_check`) → **L2b** mission alignment
+  (`steward_align`) → **L2c** affective-context injection → **L3**
+  `imprint_respond` → **L1** output validation (`safety_validate`). Hard-bell
+  inputs bypass the upper layers. The JSON contract between these layers is
+  pinned by `tests/test_layer_contract.el`.
+
+### 3d. Where the activation math actually is
+
+`el_runtime.c` implements the two-layer activation model
+(`background_activation` via BFS fan-out, then `working_memory_weight` via an
+executive filter), ACT-R base-level learning (per-node access-timestamp ring
+buffer), 768-dim semantic embeddings, and Hebbian eligibility traces. Retrieval
+is **spreading activation, not query**:
+`strength = parent_strength × edge_weight × target_salience ×
+cosine(query, target)`. The El files never compute this — they seed it
+(`engram_activate_json`), harvest it (`engram_hebb_drain_json`), and persist it.
+See `03-data-and-memory.md`.
+
+---
+
+## 4. The MCP transport chain — `mcp-proxy`, `mcp-wrapper`
+
+The chain exists because two boundaries vary independently: the *client
+transport* (stdio MCP JSON-RPC) and the *soul's protocol* (HTTP REST). Each hop
+absorbs one.
+
+- **`mcp-proxy/src/main.el`** (listens `:7779`) — a **byte-forwarder**. It
+  accepts the client connection, forwards to the wrapper, and adds resilience:
+  retry, health-gating, and a well-formed error envelope so a downstream hiccup
+  never surfaces to the client as a broken pipe. It holds no MCP semantics —
+  pure transport orchestration.
+
+- **`mcp-wrapper/src/main.el`** (listens `:17779`) — the **protocol translator**.
+  It speaks MCP JSON-RPC to the client and REST to the soul (`:7770`), owns the
+  MCP lifecycle (`initialize`, `tools/list`, `tools/call`), and carries the
+  **tool catalog** (~90 tools) that clients enumerate. `dispatch_tool_call` maps
+  each tool to a soul REST endpoint. It also fires a **spread-activation side
+  effect** (`fire_activation`) — after relevant calls it issues a `/recall` to
+  warm related nodes, so tool use itself nudges working memory. The tool schemas
+  in the catalog are largely name-only stubs — flag as a place where richer
+  schemas could live.
+
+- **Manifests** (`mcp-proxy/manifest.el`, `mcp-wrapper/manifest.el`) declare the
+  build entry and package metadata for each transport binary.
+
+**End-to-end (one `tools/call`):** client → proxy (`:7779`, forward+retry) →
+wrapper (`:17779`, JSON-RPC→REST, catalog dispatch) → soul (`:7770`,
+`handle_request` → `handle_api_*`) → engram builtins → (HTTP `:8742` when in HTTP
+mode). The response walks back up, and the wrapper may fire a `/recall` warm-up
+on the way. The full sequence is drawn in `04-runtime-and-deployment.md`.
+
+**VBD reading:** proxy and wrapper are Managers of transport; the wrapper is also
+the Accessor that isolates the *MCP protocol* boundary from the soul (the soul
+knows only HTTP). The multi-hop shape is justified: the client transport, the
+protocol translation, and the cognition each change for different reasons and are
+deployed/updated independently.

docs/architecture/03-data-and-memory.md

@@ -0,0 +1,233 @@
+# Neuron — Data & Memory (the Engram Graph Model)
+
+> The engram is neuron's durable substrate. This document describes the graph
+> model: node/edge structure, the consciousness layers, the two distinct tier
+> systems, write-protection, the tombstone/supersede immutability model, and
+> persistence. Sources: the runtime `el_runtime.c` (where the graph engine
+> physically lives — "the runtime IS the database",
+> `foundation/el/engram/src/server.el:1-6`), the engram HTTP face
+> `server.el`, and the neuron-layer semantics in `memory.el` / `neuron-api.el`.
+>
+> Runtime path analyzed:
+> `foundation/el/lang/releases/v1.0.0-20260501/el_runtime.c`.
+
+## Where the model lives
+
+The engram is **not** a database library. The graph, the activation math, and
+Hebbian learning are compiled C in `el_runtime.c`; `server.el` is a thin HTTP
+server that exposes them on `:8742`; the storage format is a single JSON
+snapshot. There is no SQL, no SQLite, no append log. Keep this in mind: the
+"schema" below is C structs, not tables.
+
+> **Design-doc caveat.** `engram/README.md` describes a Rust/`sled`/`bincode`
+> `EngramDb` with a `NodeType::Concept` enum. That is **aspirational/legacy
+> narrative** — it does not match the shipped C engine. Treat the README as
+> design story, not as the implementation. *(unverified against runtime)*
+
+## Nodes
+
+`EngramNode` — `el_runtime.c:5958-6018+`. Every node carries:
+
+| Field group | Fields | Notes |
+|---|---|---|
+| Identity/content | `id`, `content`, `node_type`, `label`, `tier`, `tags`, `metadata` | all `char*` (`:5959-5965`) |
+| Epistemic weights | `salience`, `importance`, `confidence` (double), `temporal_decay_rate` | per-node decay λ override; 0 = use global (`:5966-5969`) |
+| Access history | `activation_count`, `last_activated`, `created_at`, `updated_at` | `:5970-5973` |
+| Two-layer activation | `background_activation` (Layer 1, BFS fan-out), `working_memory_weight` (Layer 2, executive filter), `suppression_count` | context compilation uses **only** `working_memory_weight` (`:5974-5991`) |
+| Consciousness layer | `layer_id` | default 1 = CORE_IDENTITY (`:5996`) |
+| ACT-R learning | `access_ts[K]` ring buffer, `access_head`, `access_filled`, `wm_anchor` | base-level learning (`:5997-6008`) |
+| Semantics | `emb` (768-dim nomic-embed-text vector, lazily backfilled), `emb_dim` | `:6009-6016` |
+| Hebbian | eligibility trace | `:6017+` |
+
+### Node types are strings, not an enum
+
+`node_type` is a free `char*`, defaulting to `"Memory"` when unset
+(`el_runtime.c:7401`, `server.el:159`). There is **no closed node-type enum** in
+the shipped engine. Two consequences:
+
+- The runtime *special-cases* a handful of type strings for activation
+  thresholds (`engram_type_threshold`, `:5933-5955`): `DharmaSelf`/`Safety`
+  (0.05, fire easily), `Belief`/`Entity` (0.30), `Knowledge` (0.20), everything
+  else `Note`/`Memory`/`Working` (0.40). `InternalStateEvent` and `Tag` are
+  **excluded from working-memory promotion** (`:6674-6676`, `:7368-7370`).
+- Type strings the neuron layer actually writes: `Memory` (default), `Knowledge`
+  (`server.el:549`), `InternalStateEvent` (`server.el:493`), `Tombstone`
+  (`memory.el:55`), `Conversation` (session nodes, `sessions.el`), `Persona`
+  (`soul.el:250-292`), plus identity/value `Knowledge` nodes.
+
+The types the MCP surface names — `Self`, `BacklogItem`, `SessionSummary`,
+`Artifact`, `Process`, `ConfigEntry` — are **`node_type` string conventions set
+by higher neuron/Axon layers**, not runtime-known types. Where `BacklogItem` /
+`Artifact` are set was not in the files read (they route to the Axon backend, doc
+02) — **flag as unverified/TODO** for a human pass.
+
+## Edges
+
+`EngramEdge` — `el_runtime.c:6701-6730+`. Directed, typed, weighted:
+
+| Field | Meaning |
+|---|---|
+| `id`, `from_id`, `to_id`, `relation` | typed relation string |
+| `weight` (double) | **authored** strength — never mutated by activation |
+| `hebb` (double) | **learned** co-activation potentiation — the fraction of recent activations in which both endpoints were in working memory together; strictly separate from `weight` |
+| `inhibitory` (int flag) | if set, activating the source **suppresses** the target's WM weight instead of exciting it |
+| `confidence`, `created_at`, `updated_at`, `last_fired`, `layer` | — |
+
+The **`hebb` field is the co-activation weight** — the Hebbian/LTP channel — kept
+deliberately separate from the static authored `weight`. Edges are created via
+`engram_connect(from, to, weight, relation)` (`server.el:253`).
+
+**Relation strings observed:** `associates` (default, `server.el:248`),
+`identity`, `co-value`, `birthday-twin`, `canonical-self` (`soul.el:37-108`),
+`supersedes`, `tombstones`, `contains`, `tagged` (`neuron-api.el`,
+`el_runtime.c:6168`).
+
+## Consciousness layers
+
+Orthogonal to memory tiers, the engram has five canonical **layers**
+(`el_runtime.c:5919-5924`):
+
+| id | Name | activation_priority | Role |
+|---|---|---|---|
+| 0 | SAFETY | 0 (fires earliest) | deepest / limbic |
+| 1 | CORE_IDENTITY | — | **default** for all nodes (`ENGRAM_LAYER_DEFAULT`, `:7423`) |
+| 2 | DOMAIN | — | domain knowledge |
+| 3 | IMPRINT | — | persona overlay |
+| 4 | SUIT | — | outermost |
+
+`EngramLayer` (`:6731-6738`) carries `activation_priority` (lower fires first),
+`suppressible` (can higher layers suppress it?), `transparent` (invisible to
+introspection?), and `injectable` (add/remove at runtime?). Layers are managed
+via `engram_add_layer` / `engram_node_layered` / `engram_list_layers`. This is
+the identity-vs-domain-knowledge stratification, independent of the tier system
+below.
+
+## Two tier systems — do not conflate them
+
+This is the single most important clarification in the data model, and the source
+of the vocabulary mismatch flagged throughout this set.
+
+### A. Cognitive memory tiers — the `tier` field
+`Working` / `Episodic` / `Semantic` / `Procedural` (and `Canonical` in use).
+Runtime default `"Working"` (`el_runtime.c:7408`; `README.md:41-49`). Nodes
+**migrate between these by salience decay/reinforcement**, driven by the runtime.
+Salience decays as `importance × 1/(1 + days_since) × ln(count + 1)`
+(`README.md:57-62`). `memory.el` exposes `tier_working`/`episodic`/`canonical`
+helpers (`memory.el:1-3`); `soul.el` writes `Semantic`-tier persona nodes
+(`:267`, `:282`). So the live tier set is **{Working, Episodic, Semantic,
+Procedural, Canonical}** with continuous salience/importance/confidence floats.
+
+### B. Epistemic tiers & disposition — tags, not runtime concepts
+The MCP-facing vocabulary — tiers `note → lesson → canonical`, disposition
+`experimental → provisional → stable → deprecated` — is **not enforced anywhere
+in `el_runtime.c`.** It is stored as **tags**:
+
+- Knowledge capture preserves the incoming epistemic tier as a `tier:<x>` tag
+  rather than mapping onto a cognitive tier — deliberately, to avoid a lossy
+  mapping (`server.el:519-522, 544`).
+- `promote_knowledge` writes a canonical node tagged
+  `["Knowledge","tier:canonical","disposition:stable"]` (`neuron-api.el:533`).
+
+There is **no state machine** validating `experimental → … → deprecated`.
+Disposition and epistemic tier are convention-by-tag. *(Flag: not structurally
+guarded. The exact MCP-enum → tag/float mapping is not fully traced in the files
+read — unverified/TODO.)*
+
+## Write-protection
+
+`is_protected_node(id)` (`neuron-api.el:20-37`) is a **hard-coded allowlist of 15
+identity/value node IDs** — the self root, the values hub, intellectual-dna,
+memory-philosophy, voice, and the 8 value nodes. Handlers that could mutate the
+graph (tombstone / supersede / evolve / connect) check it and return HTTP 403
+`api_err_protected` (`:39-41`) for a protected target (checked at `:384, 511,
+692, 705, 746, 768`). Edges *into* a protected node are also blocked
+(`handle_api_link_entities`).
+
+**The one sanctioned override** is `POST /api/neuron/cultivate`
+(`neuron-api.el:781-816`) — it performs the same ops with the protection check
+skipped, gated by convention to Will's explicit cultivation sessions. The self
+layer is writable, but only through a deliberate door.
+
+## Immutability — tombstone, never delete
+
+Engram nodes are immutable (`memory.el:64-69`). The model is:
+
+- **Tombstone** — `mem_tombstone(node_id)` (`memory.el:46-71`) **keeps the node
+  and all its edges**, creates a `Tombstone` marker node
+  (`content = target id`, `label = "tombstone:<id>"`) and wires a `tombstones`
+  edge (weight 1.0). It never calls `engram_forget`. This is *the* one canonical
+  delete — every user-facing forget path routes through it. Default bounded reads
+  hide tombstoned nodes (`memory_hide_tombstoned`, `neuron-api.el:239-249`);
+  `?include_deleted=1` recovers them.
+- **Supersede** — updates/evolves (`neuron-api.el:394-428, 506-541, 715-734`)
+  create a **new** node with the new content, wire a `supersedes` edge new→old
+  (weight 0.9, or 0.95 for promote), and **keep the original**. The response
+  returns both ids so the caller re-points. This is the `supersedes_id`
+  pattern: new node linked, old preserved, full audit trail.
+
+> **The hole to know about.** The raw runtime `engram_forget` **does** hard-delete
+> (frees node + edges, `el_runtime.c:7647`), and the engram HTTP route
+> `DELETE /api/nodes/:id` calls it directly (`server.el:322-328`). Immutability
+> is therefore an invariant of the **neuron-api / MCP layer routing**, not of the
+> store. A client that hits engram HTTP directly can bypass it. *(flag)*
+
+`engram_forget` is also used *internally* for genuine GC: boot-counter pruning
+(`memory.el:184`), session-summary/telemetry pruning (`soul.el:369`,
+`sessions.el`). Those are bounded housekeeping, not user deletes.
+
+## Persistence, snapshots, backups
+
+- **Storage:** a single JSON snapshot `snapshot.json` under `ENGRAM_DATA_DIR`,
+  written by `engram_save` / read by `engram_load` (`el_runtime.c:9660+`; format
+  `{"nodes":[...],"edges":[...]}`). In prod that dir is the RWO PVC mount `/data`
+  (doc 04).
+- **Write policy:** `persist_canonical()` writes the **full** snapshot after every
+  durable write (`server.el:133-141`). The batch-edge route snapshots **once per
+  batch** to avoid ~150 GB/day of writes from Hebbian edge churn
+  (`server.el:258-305`) — this is why `hebb_consolidate` batches (doc 02).
+- **Boot safety:** on load, engram writes `snapshot.boot-backup.json` (good load)
+  or `snapshot.failed-load.json` (a non-empty file that parsed to 0 nodes)
+  (`server.el:718-734`). Read routes export to scratch paths
+  (`.scan-export.json`, `.sync-export.json`) and **never** touch the canonical
+  (`server.el:207-223, 418-437`) — a guard added after a read-route corrupted the
+  snapshot.
+- **Off-cluster backup:** a Kubernetes CronJob (`engram-backup`) tars `/data`
+  every 15 minutes to `gs://neuron-db-backup/gke/neuron-prod/` and keeps the last
+  96 (24h) (`infrastructure/platform/k8s/neuron-mcp/backup-cronjob.yaml`).
+- **Retention:** InternalStateEvent telemetry pruned at 48h
+  (`ENGRAM_ISE_RETENTION_MS`, `server.el:485-499`).
+
+> **Data-dir mismatch to flag:** the `server.el` header comment says the default
+> is `~/.neuron/engram` (`:16`) but the code defaults to `/tmp/engram`
+> (`:135, 717`). Prod overrides both via `ENGRAM_DATA_DIR=/data`. *(unverified —
+> which default is intended)*
+
+## The engram HTTP surface (`:8742`)
+
+Dispatcher `handle_request` (`server.el:592-707`). Auth: `ENGRAM_API_KEY`; GETs
+always allowed, mutations require `"_auth":"<key>"` in the JSON body
+(`server.el:578-588`).
+
+| Endpoint | Purpose |
+|---|---|
+| `GET /health`, `GET /` | health + live node/edge counts |
+| `POST /api/nodes`, `GET /api/nodes`, `GET /api/nodes/:id`, `DELETE /api/nodes/:id` | node CRUD (DELETE = hard `engram_forget`) |
+| `GET /api/edges`, `POST /api/edges`, `POST /api/edges/batch`, `GET /api/neighbors/:id?depth` | edge ops + traversal |
+| `POST\|GET /api/activate?q&depth`, `POST\|GET /api/search` | spreading activation vs lexical search |
+| `POST /api/strengthen` | Hebbian potentiation |
+| `POST /api/save`, `/api/load`, `/api/load-merge` | snapshot control |
+| `GET /api/sync` | soul daemon periodic pull |
+| `GET /api/embed-backfill`, `GET /api/similarity?a&b` | embeddings + cosine |
+| `POST /api/neuron/state-events` (auth-exempt), `POST /api/neuron/knowledge/capture` | neuron-layer helpers |
+| `GET /api/stats`, `/api/act-stats`, `/api/text-health` | telemetry |
+
+## Retrieval model (summary)
+
+Retrieval is **spreading activation, not query matching**:
+`strength = parent_strength × edge_weight × target_salience ×
+cosine(query, target)` — multiplicative, top-N, with the two-layer
+background → working-memory promotion (`README.md:27-36`; `el_runtime.c:5892+,
+6094+`). `mem_recall` / `/api/activate` fire this and mutate WM; `mem_search` /
+`/api/search` are passive lexical scans. The cognitive API's `begin_session` and
+`compile_ctx` return a **bounded projection** of the activated set, never the raw
+graph (doc 02, §2).

docs/architecture/04-runtime-and-deployment.md

@@ -0,0 +1,178 @@
+# Neuron — Runtime & Deployment
+
+> Process/port topology, the end-to-end MCP request path, local vs GKE
+> blue/green production, and a high-level view of secrets/config. Grounded in
+> `entrypoint.sh`, `scripts/blue-green-deploy.sh`, the k8s manifests under
+> `infrastructure/platform/k8s/neuron-mcp/`, and `.gitea/workflows/`.
+
+## Process & port topology
+
+A running neuron is **two processes in one container**: the soul and the engram,
+started by `entrypoint.sh`.
+
+```
+ container (one pod)
+ ┌──────────────────────────────────────────────────────────┐
+ │  entrypoint.sh                                             │
+ │    1. start engram  (background)   ── listens :8742       │
+ │    2. wait /health up to 60s                              │
+ │    3. exec soul (PID 1 foreground)  ── listens :7770      │
+ │                                                           │
+ │   soul  :7770  ──HTTP──►  engram  :8742                    │
+ │   (ENGRAM_URL=http://localhost:8742, HTTP mode)           │
+ │                                                           │
+ │   /data  (PVC mount) ◄── engram snapshot.json             │
+ └──────────────────────────────────────────────────────────┘
+```
+
+- `entrypoint.sh` starts engram with `ENGRAM_BIND=:8742` and
+  `ENGRAM_DATA_DIR=/data`, polls `http://localhost:8742/health` (up to 60s;
+  Autopilot cold starts are slow), then `exec`s the soul. `SOUL_ENGRAM_PATH` is
+  deliberately unset so `ENGRAM_URL` triggers **HTTP mode** (soul talks to engram
+  over localhost HTTP, not an in-process embed).
+- EL HTTP runtime is tuned down for co-located calls: `EL_HTTP_TIMEOUT_MS=10000`,
+  `EL_HTTP_CONNECT_TIMEOUT_MS=3000` (`entrypoint.sh`).
+
+### Full port map
+
+| Port | Process | Role | Source |
+|---|---|---|---|
+| 7779 | mcp-proxy | MCP client entry; byte-forward + retry | `mcp-proxy/src/main.el` |
+| 17779 | mcp-wrapper | MCP JSON-RPC ⇄ soul REST; tool catalog | `mcp-wrapper/src/main.el` |
+| 7770 | soul | HTTP cognitive API + `handle_request` | `NEURON_PORT`, `deployment-blue.yaml` |
+| 8742 | engram | graph store HTTP | `entrypoint.sh`, `server.el:711` |
+| 7771 | neuron-connectd | MCP connector bridges | `routes.el` `connectd_*` |
+
+**Local vs prod, an important distinction.** The proxy → wrapper chain is the
+**local developer adapter**: a stdio MCP client (Claude Code) needs to reach an
+HTTP soul, so the proxy/wrapper translate and add resilience. In **production**,
+the `neuron-mcp` Kubernetes Service is a ClusterIP that targets the soul's
+`:7770` directly (`service.yaml`) — external access is "to be wired via
+Cloudflare Tunnel later" (annotation, same file). So in prod the MCP/HTTP
+boundary is the soul's own HTTP surface; the proxy/wrapper are not (yet) in the
+cluster path. *(inference from the ClusterIP-only Service + the local-only
+proxy/wrapper binaries.)*
+
+## The MCP request path (end to end)
+
+A single `tools/call` from an MCP client, local topology:
+
+```
+ client                proxy :7779         wrapper :17779        soul :7770            engram :8742
+   │  JSON-RPC             │                    │                    │                     │
+   │ tools/call ─────────► │  forward+retry     │                    │                     │
+   │                       │ ─────────────────► │  map tool→REST     │                     │
+   │                       │                    │ ─── HTTP POST ────► │  handle_request     │
+   │                       │                    │   /api/neuron/...   │   → handle_api_*    │
+   │                       │                    │                    │  engram_* builtin   │
+   │                       │                    │                    │ ── (HTTP mode) ───► │  activate/search/
+   │                       │                    │                    │                     │  save
+   │                       │                    │                    │ ◄─── nodes/edges ── │
+   │                       │                    │ ◄── JSON result ── │                     │
+   │                       │                    │  fire_activation    │                     │
+   │                       │                    │  /recall warm-up ─► soul (side effect)    │
+   │ ◄──── result ──────── │ ◄───────────────── │                    │                     │
+```
+
+Responsibilities per hop, and the volatility each isolates (VBD reading):
+
+1. **proxy** — transport resilience. Isolates *client connection volatility*
+   (drops, retries, health) from everything above. No MCP semantics.
+2. **wrapper** — protocol translation. Isolates the *MCP protocol* from the soul:
+   owns `initialize`/`tools/list`/`tools/call`, the ~90-tool catalog, and
+   `dispatch_tool_call`. Also fires the `fire_activation` `/recall` side effect so
+   tool use warms working memory.
+3. **soul** — cognition. `handle_request` dispatch → `handle_api_*` → engram
+   builtins. In HTTP mode it reaches engram over localhost; otherwise embedded.
+4. **engram** — the graph. Spreading activation, Hebbian edges, snapshot
+   persistence.
+
+For the user-facing chat pipeline (not tool calls), `/api/chat` enters
+`layered_cycle` (soul.el) — L1 safety → L2 stewardship → L3 imprint — described
+in `02-components.md §3c`.
+
+## Production: GKE blue/green
+
+Neuron prod runs on GKE cluster **`neuron-platform`** (Autopilot, us-central1),
+namespace **`neuron-prod`**. Two Deployments, `neuron-mcp-blue` and
+`neuron-mcp-green`, share one Service selector that names the *active slot*.
+
+- **Deployments** (`deployment-blue.yaml` / `deployment-green.yaml`): one
+  container `soul`, image pinned by **digest** (not `:latest`) so Argo CD can't
+  drift the active slot to an untested build (see the pin comment in
+  `deployment-blue.yaml`). `strategy: Recreate` — the PVC is RWO so only one pod
+  can hold it at a time. Probes hit `/health` on `:7770`.
+- **Service** (`service.yaml`): ClusterIP `neuron-mcp`, port 7770 → 7770,
+  `selector: {app: neuron-mcp, slot: blue}`. The blue/green script patches
+  `slot`.
+- **Storage** (`pvc.yaml`): `neuron-engram-data`, `standard-rwo` (pd-balanced),
+  10Gi, RWO. Engram data is the single `snapshot.json` (~8MB active).
+- **The swap** (`scripts/blue-green-deploy.sh`): (1) set image on the target
+  slot; (2) scale target to 1, wait for rollout; (3) **patch the Service selector
+  to the new slot** (traffic flip); (4) scale the old slot to 0. Imperative
+  `kubectl` for the live swap, then git-update the Argo manifests so a sync
+  doesn't revert replica counts.
+- **Backup** (`backup-cronjob.yaml`): every 15 min, tar `/data` → GCS, keep 96.
+
+### Resource sizing (learned the hard way)
+
+`deployment-blue.yaml` documents the memory history in comments: idle soul RSS
+~860Mi; the `beginSession` call (loads memories + backlog + preferences) spikes
+past 1Gi and OOM-killed the pod mid-request (client socket closed). Current
+setting: `requests = limits = 2Gi`, cpu 250m/1000m. This is *why* the cognitive
+API projects/compacts payloads so aggressively (doc 02 §2, doc 01 axis 1) — the
+memory ceiling is real and close.
+
+## CI/CD
+
+Two Gitea Actions workflows (`.gitea/workflows/`), serialized on a single GCE
+runner (`concurrency: neuron-runner`).
+
+- **`ci.yaml`** (push/PR to `main`):
+  - **build:** free disk → checkout → install gcc/libcurl/gcloud → download
+    `el-runtime-c`/`el-runtime-h` from Artifact Registry `foundation-prod`
+    (`elc`/`elb` intentionally **not** downloaded) → compile the committed
+    `dist/soul.c` directly: `cc -O2 -DHAVE_CURL dist/soul.c el_runtime.c -lssl
+    -lcrypto -lcurl -lpthread -lm -o dist/neuron` → `strip -s` → smoke test
+    `dist/neuron --help` → publish `neuron-soul@<sha8>` to AR (push only).
+  - **deploy** (push-to-main only): auth GCP → `get-credentials neuron-platform`
+    → **determine idle slot** (the deployment at 0 replicas) → prepare artifacts
+    (soul binary + `elc` + runtime for the Docker build) → **clone the engram
+    repo** into `./engram/` (Dockerfile builds engram from source) → `docker
+    build`+push `neuron-soul:<sha>` → `scripts/blue-green-deploy.sh --image
+    --slot` → git-push updated infra manifests → `kubectl rollout status` →
+    verify `neuron-mcp` endpoints.
+- **`deploy-gke.yaml`** (`workflow_dispatch` only, slot default `green`) — manual
+  rollback / forced-slot deploy without a rebuild; same auth → slot → docker →
+  blue-green → manifest-sync → verify steps.
+
+The Docker image (`Dockerfile`) is a two-stage build: stage 1 compiles
+`engram/src/server.el` → `engram.c` → `engram` binary via `elc` + `cc`; stage 2
+is an Ubuntu 24.04 runtime (GLIBC 2.39 satisfies both binaries) with `soul` +
+`engram` + `entrypoint.sh`.
+
+## Config & secrets (high level)
+
+Runtime configuration is injected as environment, sourced from a Kubernetes
+Secret `neuron-soul-secrets` via ExternalSecret (ESO → GCP Secret Manager,
+Workload Identity — no key files). From `deployment-blue.yaml`:
+
+| Env | Meaning |
+|---|---|
+| `NEURON_PORT` | soul HTTP port (7770) |
+| `NEURON_LLM_0_URL` / `_KEY` / `_FORMAT` | primary LLM endpoint (Anthropic format) |
+| `SOUL_CGI_ID` / `SOUL_IDENTITY` | CGI id + identity seed (→ `seed_persona_from_env`, `soul.el:250`) |
+| `NEURON_TOKEN` | auth token *(present in env; note the HTTP dispatch does not currently check it — doc 01 Divergence 3)* |
+| `NEURON_API_URL` | self-callback URL (`http://neuron-mcp.neuron-prod.svc.cluster.local:7770`) |
+| `ENGRAM_URL` / `ENGRAM_DATA_DIR` | `http://localhost:8742` / `/data` |
+
+There is also an in-graph config surface: `ConfigEntry` nodes read/written by
+`inspect_config` / `tune_config` (`neuron-api.el:616-653`) — runtime-tunable
+persona/behavior keys stored *in* the engram rather than the environment.
+
+> **Operational note to flag.** The `deployment-blue.yaml` image pin comment
+> (dated Jul 2026) records that `:latest` resolved to an untested build lacking a
+> `mem_save`/genesis-SIGSEGV fix, which is why the active slot is pinned to a
+> digest. Any promotion must (a) rebuild a good soul and (b) update the digest in
+> git so Argo CD and `blue-green-deploy.sh` agree. *(state as-of the manifests
+> read; verify current slot before deploying.)*

docs/architecture/05-el-and-build.md

@@ -0,0 +1,165 @@
+# Neuron — El & the Build Pipeline
+
+> The soul and the engram are written in **El**, a self-hosted language that
+> compiles to C11. This document covers the language layer, the
+> amalgamation → `soul.c` → binary pipeline, how the soul is composed from its
+> layers, and the compile-time capability gates. Sources: `manifest.el`,
+> `soul.el`, `dist/soul.c`, the El toolchain under `foundation/el/`
+> (`elc.c`, `elb.el`, `BOOTSTRAP.md`), and `.gitea/workflows/`.
+
+## The El language layer
+
+El is a compiled, Lisp-family language transpiled to C11. Every El program links
+a shared runtime, `el_runtime.c` / `el_runtime.h`, which implements **all
+builtins**: the engram graph engine (`engram_*`), HTTP (`http_*`), JSON
+(`json_*`), crypto, time, LLM calls, and DHARMA primitives (`el_runtime.h`,
+`BOOTSTRAP.md:599-644`). The runtime also provides an arena allocator (server
+mode) and ARC refcounting. Practically: **the runtime is both the standard
+library and the database** — the graph physically lives in `el_runtime.c`, and El
+source files are the orchestration/logic on top.
+
+A recurring texture in the source is workaround comments for codegen quirks
+(e.g. broken `%`/`*` operators). These are El-compiler maturity issues, not
+architecture — but they explain some of the hand-rolled arithmetic in
+`awareness.el`/`memory.el`.
+
+## The toolchain: `elc`, `elb`, `el_runtime`
+
+| Tool | What it is | Role |
+|---|---|---|
+| `elc` | the El compiler, **self-hosted** (written in El) | compiles one El translation unit → C11. Import resolution is textual, depth-first, dedup'd — it inlines all imports into one string and emits forward decls for every fn (`BOOTSTRAP.md:927-936`). |
+| `elb` | the build coordinator (`elb.el`, ~367 lines) | reads `manifest.el`, walks the import graph, does **incremental** separate compilation using `.elh` header files (`extern fn` decls), links the final binary (".NET-style incremental build", `BOOTSTRAP.md:886, 916-925`). |
+| `el_runtime.c/.h` | the C runtime | linked by every compiled El binary; implements all builtins and the graph engine. |
+
+The `.elh` files present in this repo (`soul.elh`, `memory.elh`,
+`neuron-api.elh`, `routes.elh`, …) are **auto-generated headers** (`elc
+--emit-header`) — the `extern fn` interface each module exports. They are the
+contract surface `elb` uses for incremental builds, and they double as a concise
+map of each module's public functions.
+
+### Self-hosting fixed point
+
+`elc` is bootstrapped from a seed binary (`dist/platform/elc`, Mach-O arm64) and
+verified by a **fixed-point self-recompile**: the compiler must compile its own
+source to a byte-identical binary (`BOOTSTRAP.md:7-58, 801-816`). Pipeline:
+`elc-cli.el → compiler.el → lexer/parser/codegen.el`.
+
+## Building the soul: `.el → elc → .c → cc → binary`
+
+The concrete pipeline (mirrored in the engram build, `engram/src/server.el:8-11`):
+
+```
+   soul.el (+ imports)
+        │  elc  (self-hosted El→C11, inlines imports)
+        ▼
+   dist/soul.c   (~31,300 lines — single amalgamated translation unit)
+        │  cc -std=c11 -O2  soul.c  el_runtime.c
+        ▼
+   dist/neuron   (native binary)
+```
+
+### Why `dist/soul.c` is committed
+
+`dist/soul.c` is the authoritative combined translation unit, **regenerated on
+macOS by running `elb`**. It is checked into the repo on purpose: CI compiles it
+**directly** and skips `elb` entirely (`ci.yaml`). The reason is operational, not
+aesthetic —
+
+- `elb` succeeds on arm64/macOS `ld`, but **fails on Linux** (duplicate strong
+  symbols), and
+- `elc` uses 24GB+ virtual memory, which **OOM-kills the 16GB CI runner**.
+
+So the pattern is: **compile on the Mac, commit the amalgamation, and let Linux
+CI do only the cheap `cc` step.** `dist/` also holds the per-module `.c` outputs
+(`memory.c`, `awareness.c`, `chat.c`, the NLG morphology tables, …) —
+intermediate artifacts of the same process.
+
+> **Mechanism note (observed during the self-load regen).** The single-TU
+> `dist/soul.c` is produced by running `elc` over the **flattened import set** —
+> every module source in `soul.el`'s transitive import graph, concatenated with
+> `import` lines stripped, compiled in one pass (`elc` hoists forward decls for
+> all functions, so concat order doesn't affect correctness). `elb` on its own
+> emits **per-module `.c` + a linked binary**, not the combined `soul.c`; it is
+> the separate-compilation coordinator, and `elc soul.el` alone yields only the
+> soul module. Because the amalgamation is regenerated only on demand, it can lag
+> the `.el` sources: this PR regenerated it after it had fallen behind several
+> source commits, and folded in the `inspect_graph` relevance-ranked projection
+> (the `compact=1` self-load fix, doc 02) so CI ships it.
+
+## How the soul is composed (layer stack)
+
+`manifest.el` declares the build:
+
+```
+package "neuron" { version "0.1.0"  edition "2026" }
+build { entry "soul.el" }
+```
+
+The comment in `manifest.el:8-16` documents the intended **layer composition
+order**: a base layer `../foundation/nlg` (the NLG engine — 31-language
+morphology, grammar, realizer, semantics) with the **soul layer** (`soul.el`)
+injected on top. New layers are added by importing them in `soul.el` before the
+soul's own code. *(The `../foundation/nlg` path is the manifest's stated NLG base;
+the NLG sources compile into the `dist/*.c` morphology/grammar tables seen in the
+tree.)*
+
+`soul.el` itself imports, in order (`soul.el:1-10`): `elp.el`, `memory.el`,
+`safety.el`, `stewardship.el`, `imprint.el`, `awareness.el`, `chat.el`,
+`studio.el`, `elp-input.el`, `routes.el` — then declares the `cgi "neuron-soul"`
+identity block (`:12-17`): `dharma_id`, `principal`, `network`, and
+`engram: http://localhost:8742`. Because `elc` inlines imports depth-first, this
+import list *is* the amalgamation order that produces `dist/soul.c`.
+
+The `cgi` block is not just metadata — it sets the program's **capability tier**
+(next section).
+
+## Compile-time capability gates
+
+El's codegen classifies each program by its top-level declaration and **enforces
+capabilities at compile time** (`BOOTSTRAP.md:958-965`):
+
+| Declaration | Tier | Allowed |
+|---|---|---|
+| `cgi { … }` | full | everything — `llm_call_agentic`, `llm_register_tool`, `dharma_emit`, `dharma_field`, LLM, DHARMA |
+| `service { … }` | restricted | no `llm_call_agentic` / `llm_register_tool` / `dharma_emit` / `dharma_field` |
+| neither | utility | no DHARMA, no LLM |
+
+A program that calls a capability its tier forbids **fails to compile**: codegen
+emits a C `#error` naming the forbidding call, so the downstream `cc` aborts.
+This is the **primary hard gate** in the build — capability escalation is caught
+by the compiler, not at runtime. The soul is a `cgi`, so it gets the full tier;
+`engram` is declared without `cgi`/`service` semantics that would grant LLM
+access (it is a store).
+
+## Verification gates
+
+| Gate | Where | What it checks |
+|---|---|---|
+| Capability tier | El codegen (`BOOTSTRAP.md:958`) | no capability escalation; hard `#error` at compile |
+| Self-hosting fixed point | `elc` bootstrap (`BOOTSTRAP.md:801`) | compiler reproduces itself byte-identically |
+| `test_soul_guard.el` | `tests/` | the genesis `safe_to_seed` boot guard — a sparse/oversized snapshot must not clobber the graph |
+| `test_layer_contract.el` | `tests/` | JSON interface shapes between composition-stack layers that `layered_cycle` depends on (e.g. `safety_screen` always returns an `action` field) |
+| other `tests/*.el` | `tests/` | `test_sessions.el`, `test_safety.el`, `test_bell_safety.el`, `test_layered_cycle.el`, `test_imprint.el`, `test_stewardship.el`, `test_api_define_process.el`, … |
+| CI smoke test | `ci.yaml` | `dist/neuron --help` runs |
+
+> **Flag (unverified/TODO).** CI (`ci.yaml`) runs only the `cc` compile + the
+> `dist/neuron --help` smoke test — it does **not** invoke the `tests/*.el`
+> soul-guard / layer-contract suites, and `.githooks/` is empty. Whether these
+> tests are gated anywhere (a pre-merge hook, a separate workflow, or manual
+> discipline on the Mac before regenerating `soul.c`) is **not evident in the
+> files read**. This is the most important build-integrity gap to confirm with a
+> human: the contract tests exist but their enforcement point is unproven.
+
+## Practical consequences for a contributor
+
+- **You cannot rebuild the whole soul on Linux/CI.** Regenerate `dist/soul.c` on
+  a Mac (`elb`), commit it, then CI compiles it. Changing an `.el` file without
+  regenerating `soul.c` ships nothing.
+- **The `.elh` files are your API map.** To see what a module exposes, read its
+  `.elh` — it's the generated `extern fn` list.
+- **Memory/activation behavior often can't be changed from this repo.** The
+  volatile numeric core is in `foundation/el` `el_runtime.c`. Doc 01, Divergence
+  6 explains why this is the sharpest edge in the architecture.
+- **The engram is a separate repo.** It is cloned and compiled by CI
+  (`Dockerfile`, `.gitea/workflows/`), not vendored here. Its source of truth is
+  `foundation/el/engram`.

docs/research/glm-ocr-spike.md

@@ -0,0 +1,110 @@
+# GLM-OCR Spike — 2026-06-27
+
+## Verdict: SHIP IT
+
+MLX-native path confirmed. Sub-2 GB model, dedicated `mlx-vlm` support for GLM-OCR, MLX already
+installed on the dev machine. No blockers.
+
+---
+
+## Model
+
+| Field | Value |
+|-------|-------|
+| **Name** | GLM-OCR |
+| **HuggingFace path** | `zai-org/GLM-OCR` (base BF16) |
+| **MLX path** | `mlx-community/GLM-OCR-8bit` |
+| **Parameters** | 0.9B |
+| **Disk (MLX 8-bit)** | 1.59 GB (`model.safetensors` 1.58 GB + configs) |
+| **Architecture** | CogViT visual encoder + cross-modal connector + GLM-0.5B decoder |
+| **License** | MIT (model); Apache 2.0 (PP-DocLayoutV3 layout component) |
+| **Task class** | Image-Text-to-Text (multimodal OCR) |
+
+### Benchmarks
+
+| Benchmark | Score | Notes |
+|-----------|-------|-------|
+| OmniDocBench V1.5 | **94.62** | Ranked #1 at evaluation date |
+| olmOCR-bench (overall) | 75.2 | — |
+| Throughput (base, GPU) | 0.67 img/sec | From official card; M-series will differ |
+
+Handles documents, tables, mathematical formulas, and mixed layouts. Not just raw text extraction —
+returns structured markdown output.
+
+---
+
+## Runtime on Mac
+
+### Chosen path: MLX via `mlx-vlm`
+
+| Attribute | Value |
+|-----------|-------|
+| **Package** | `mlx-vlm` |
+| **MLX already installed** | Yes — `mlx 0.31.2`, `mlx-lm 0.31.3`, `mlx-metal 0.31.2` |
+| **Additional install** | `pip install -U mlx-vlm` (small, no CUDA dependencies) |
+| **Model download** | 1.59 GB on first run (auto-cached in `~/.cache/huggingface/`) |
+| **Memory requirement** | ~2–3 GB unified memory (1.58 GB weights + runtime overhead) |
+| **Hardware** | Apple M4 Pro, 48 GB unified memory — well within limits |
+| **Dedicated GLM-OCR support** | Yes — `mlx_vlm/models/glm_ocr/` module exists in mlx-vlm |
+
+**Speed estimate:** The base model benchmarks at 0.67 img/sec on GPU. On M4 Pro via MPS/MLX,
+expect 0.3–0.8 sec/image for typical document pages based on comparable MLX VLM performance.
+Exact figures require a timed run with the prototype.
+
+### Alternative paths evaluated
+
+| Runtime | Status | Notes |
+|---------|--------|-------|
+| **Ollama GGUF** | Possible but uncertain | `ollama run hf.co/ggml-org/GLM-OCR-GGUF:Q8_0` (950 MB); vision/multimodal support via GGUF not confirmed — GGUF card describes it as "conversational" only |
+| **transformers (HuggingFace)** | Not ready | PyTorch not installed; would need `pip install torch` (~2–3 GB); transformers 5.6.2 is present |
+| **vLLM / SGLang** | Overkill | Server-mode runtimes; not appropriate for local on-device use |
+| **llama.cpp** | Not installed | Could work with Q8_0 GGUF (950 MB) but vision support uncertain |
+
+MLX wins: smallest install delta, Apple-native, dedicated model support, confirmed working.
+
+---
+
+## Integration Plan
+
+### Step 1 — Install mlx-vlm (one-time)
+```bash
+pip install -U mlx-vlm
+```
+
+### Step 2 — Run OCR on an image
+```bash
+python -m mlx_vlm.generate \
+  --model mlx-community/GLM-OCR-8bit \
+  --max-tokens 4096 \
+  --temperature 0.0 \
+  --prompt "Extract all text from this document. Preserve structure including tables and headers." \
+  --image /path/to/document.jpg
+```
+
+Model auto-downloads (~1.59 GB) on first run and caches in `~/.cache/huggingface/`.
+
+### Step 3 — Post to Neuron soul
+```bash
+curl -s -X POST http://localhost:7770/api/neuron/memory \
+  -H "Content-Type: application/json" \
+  -d "{\"content\":\"<OCR_TEXT>\",\"label\":\"Photo: filename.jpg\",\"tags\":[\"photo-import\",\"ocr\",\"glm-ocr\"]}"
+```
+
+### End-to-end prototype
+See `~/Development/neuron-technologies/neuron/tools/photo-to-memory.sh` — working stub.
+
+### Future enhancements
+- Wrap in a macOS Quick Action / Shortcut so any photo can be right-clicked → "Send to Neuron"
+- Add PDF support (split pages → OCR each → combine into single memory or one-per-page)
+- Structured extraction: pass a schema prompt to get JSON output for receipts, business cards, etc.
+- Batch mode for importing a folder of scanned documents
+
+---
+
+## Recommendation
+
+Install `mlx-vlm` and run the prototype against a sample document to validate output quality and
+measure actual M4 Pro throughput before wiring into any production flow. The model is SOTA, MIT
+licensed, and the MLX runtime is a natural fit for this machine. There is no reason not to proceed.
+
+The photo-to-memory.sh prototype is ready to test immediately after `pip install -U mlx-vlm`.

docs/telegram-bot-setup.md

@@ -0,0 +1,77 @@
+# Neuron Telegram Gateway — Setup
+
+The Telegram gateway lets you chat with your Neuron soul via Telegram. Plain messages go to the soul; commands give access to memory and status.
+
+## 1. Create a bot via @BotFather
+
+1. Open Telegram and search for **@BotFather**
+2. Send `/newbot`
+3. Pick a name (e.g. "Neuron")
+4. Pick a username (must end in `bot`, e.g. `myneuron_bot`)
+5. BotFather replies with your **HTTP API token** — looks like `7123456789:ABCdef...`
+6. Optionally set a description: `/setdescription` → select your bot → type a description
+
+## 2. Store the token in the macOS Keychain
+
+Never put the token in a plist, `.env`, or any file that might be committed.
+
+```bash
+security add-generic-password \
+  -s neuron-telegram-bot \
+  -a neuron \
+  -w '<paste token here>'
+```
+
+Verify:
+```bash
+security find-generic-password -s neuron-telegram-bot -a neuron -w
+```
+
+## 3. Load the LaunchAgent
+
+```bash
+launchctl load ~/Library/LaunchAgents/ai.neuron.telegram-gateway.plist
+```
+
+Check it started:
+```bash
+launchctl list | grep telegram
+tail -f ~/.neuron/logs/telegram-gateway.out.log
+```
+
+## 4. Test
+
+Send your bot a message in Telegram. It should reply using your soul's voice.
+
+## Commands
+
+| Command | What it does |
+|---------|-------------|
+| `<any text>` | Forwarded to the soul → responds in its voice |
+| `/memory <query>` | Searches soul memories, returns top 3 |
+| `/remember <text>` | Stores text as a memory node |
+| `/status` | Reports whether the soul is reachable |
+
+## Unload / stop
+
+```bash
+launchctl unload ~/Library/LaunchAgents/ai.neuron.telegram-gateway.plist
+```
+
+## Troubleshoot
+
+- **"token not found"** — re-run step 2 above
+- **"Soul is resting"** — the soul daemon at `http://localhost:7770` is not running; start it with `launchctl load ~/Library/LaunchAgents/ai.neuron.engram.plist` (or whichever plist runs the soul)
+- **Logs**: `~/.neuron/logs/telegram-gateway.out.log` and `telegram-gateway.err.log`
+- **Test gateway script directly**:
+  ```bash
+  TELEGRAM_BOT_TOKEN=<token> ~/Development/neuron-technologies/neuron/tools/telegram-gateway.sh
+  ```
+
+## Soul API endpoints used
+
+| Endpoint | Purpose |
+|----------|---------|
+| `POST /api/chat` | Forward messages to the soul |
+| `POST /api/neuron/recall` | Search memories |
+| `POST /api/neuron/memory` | Store conversation as a memory node |

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

mcp-wrapper/src/main.el

@@ -77,111 +77,327 @@ fn tool(name: String, desc: String) -> String {
     return "{\"name\":\"" + name + "\",\"description\":\"" + desc + "\",\"inputSchema\":{\"type\":\"object\",\"properties\":{}}}"
 }
 
+// tool_s — tool entry with an EXPLICIT JSON-Schema for its inputs. Used for tools
+// whose arguments must actually bite: unless the bounding/targeting params are
+// advertised, the MCP client sends nothing and the soul returns the FULL
+// neighborhood (480-775KB, over transport limits). Declaring the schema is what
+// makes a targeted call (entity_id/depth/compact/query/limit) reach the soul.
+fn tool_s(name: String, desc: String, schema: String) -> String {
+    return "{\"name\":\"" + name + "\",\"description\":\"" + desc + "\",\"inputSchema\":" + schema + "}"
+}
+
+// prop — a single JSON-Schema property fragment. Descriptions are plain text
+// (no quotes/newlines) so no escaping is needed here.
+fn prop(name: String, ty: String, desc: String) -> String {
+    return "\"" + name + "\":{\"type\":\"" + ty + "\",\"description\":\"" + desc + "\"}"
+}
+
+// obj_schema — wrap a comma-joined list of prop() fragments as an object schema.
+fn obj_schema(props: String) -> String {
+    return "{\"type\":\"object\",\"properties\":{" + props + "}}"
+}
+
+// ── Per-tool input schemas ──────────────────────────────────────────────────
+// Each mirrors the params the soul's /api/neuron/* handler actually honors so
+// declared == forwarded == honored (no accepted-but-ignored args).
+
+fn schema_inspect_graph() -> String {
+    return obj_schema(
+        prop("entity_id", "string", "UUID of the node to inspect (e.g. kn-... / mem-... / gn-...). Optional if name is given.") +
+        "," + prop("name", "string", "Named traversal root instead of entity_id: self, neuron, values, values_hub.") +
+        "," + prop("entity_type", "string", "Optional node-type hint (knowledge, memory, ...) for disambiguation.") +
+        "," + prop("depth", "integer", "Neighborhood hop radius. Default 1.") +
+        "," + prop("compact", "integer", "1 (default) returns a relevance-ranked bounded projection (top-K neighbors with content snippets, the rest as lightweight pointers). Set 0 to get the full, unbounded neighborhood.") +
+        "," + prop("snip", "integer", "Max content chars per node in compact mode. Default 600.") +
+        "," + prop("k", "integer", "How many top neighbors carry full content in compact mode. Default 12.")
+    )
+}
+
+fn schema_traverse_graph() -> String {
+    return obj_schema(
+        prop("entity_id", "string", "UUID of the node to start the walk from (alias: start_id). Required.") +
+        "," + prop("depth", "integer", "How many hops to walk. Default 2.") +
+        "," + prop("compact", "integer", "1 (default) returns a bounded, relevance-ranked projection; 0 returns the full neighborhood.") +
+        "," + prop("snip", "integer", "Max content chars per node in compact mode. Default 600.") +
+        "," + prop("k", "integer", "How many top neighbors carry full content in compact mode. Default 12.")
+    )
+}
+
+fn schema_retrieve_knowledge() -> String {
+    return obj_schema(
+        prop("id", "string", "UUID of the knowledge node to fetch (alias: entity_id / node_id).") +
+        "," + prop("key", "string", "Stable knowledge key/path to fetch instead of id.") +
+        "," + prop("depth", "integer", "Hop radius around the node. Default 0 (the node plus its immediate 1-hop context).") +
+        "," + prop("snip", "integer", "Max content chars per node in the bounded projection. Default 600.") +
+        "," + prop("k", "integer", "How many top neighbors carry full content. Default 12.")
+    )
+}
+
+fn schema_search_query(limit_desc: String) -> String {
+    return obj_schema(
+        prop("query", "string", "Search text. Spread-activates the engram and returns the most relevant nodes.") +
+        "," + prop("limit", "integer", limit_desc)
+    )
+}
+
+fn schema_recall() -> String {
+    return obj_schema(
+        prop("query", "string", "Search text to recall by relevance.") +
+        "," + prop("chain_name", "string", "Named memory chain to walk instead of a free-text query.") +
+        "," + prop("limit", "integer", "Max results. Default 10.")
+    )
+}
+
+// ── Reusable write/lookup schemas ───────────────────────────────────────────
+// Each declares exactly the params the corresponding wrapper handler reads and
+// forwards to the soul, so declared == forwarded == honored (no accepted-but-
+// ignored args, and no arg the handler silently drops).
+
+fn sc_id(desc: String) -> String {
+    return obj_schema(prop("id", "string", desc))
+}
+
+fn sc_id_content() -> String {
+    return obj_schema(
+        prop("id", "string", "UUID of the prior node being superseded/updated.") +
+        "," + prop("content", "string", "New content for the updated node.")
+    )
+}
+
+fn sc_edge(rel_desc: String) -> String {
+    return obj_schema(
+        prop("from_id", "string", "UUID of the source node (edge tail). Required.") +
+        "," + prop("to_id", "string", "UUID of the target node (edge head). Required.") +
+        "," + prop("relation", "string", rel_desc)
+    )
+}
+
+fn sc_limit(desc: String) -> String {
+    return obj_schema(prop("limit", "integer", desc))
+}
+
+fn sc_memory() -> String {
+    return obj_schema(
+        prop("content", "string", "The memory text. Required.") +
+        "," + prop("importance", "string", "low | normal | high | critical. Drives salience.") +
+        "," + prop("tags", "string", "Comma-separated or JSON-array tags.") +
+        "," + prop("project", "string", "Project this memory belongs to.") +
+        "," + prop("supersedes_id", "string", "UUID of a prior memory this one replaces (wires a supersedes edge).")
+    )
+}
+
+fn sc_content_title(content_desc: String) -> String {
+    return obj_schema(
+        prop("content", "string", content_desc) +
+        "," + prop("title", "string", "Short title/label for the node.")
+    )
+}
+
+fn sc_content(content_desc: String) -> String {
+    return obj_schema(
+        prop("content", "string", content_desc) +
+        "," + prop("title", "string", "Optional short title/label.") +
+        "," + prop("description", "string", "Optional longer description (used as content if content is empty).")
+    )
+}
+
+fn sc_backlog() -> String {
+    return obj_schema(
+        prop("title", "string", "Work-item title. Required.") +
+        "," + prop("content", "string", "Body/details of the item (alias: description).") +
+        "," + prop("description", "string", "Body/details of the item.") +
+        "," + prop("project", "string", "Project tag.") +
+        "," + prop("priority", "string", "P0 | P1 | P2 | P3.")
+    )
+}
+
+fn sc_track_work() -> String {
+    return obj_schema(
+        prop("item_id", "string", "UUID of the backlog item to update.") +
+        "," + prop("summary", "string", "What changed / outcome (stored as the update content).") +
+        "," + prop("action", "string", "start | complete | block.")
+    )
+}
+
+fn sc_capture_knowledge() -> String {
+    return obj_schema(
+        prop("content", "string", "Knowledge body. Required.") +
+        "," + prop("title", "string", "Knowledge title/key.")
+    )
+}
+
+fn sc_promote_knowledge() -> String {
+    return obj_schema(
+        prop("id", "string", "UUID of the prior knowledge node to promote. Required.") +
+        "," + prop("content", "string", "Updated canonical content. Required.") +
+        "," + prop("tags", "string", "Tags for the promoted node.")
+    )
+}
+
+fn sc_config_key() -> String {
+    return obj_schema(prop("key", "string", "Config key to read (e.g. neuron.self.traversal_root)."))
+}
+
+fn sc_config_tune() -> String {
+    return obj_schema(
+        prop("key", "string", "Config key to set. Required.") +
+        "," + prop("value", "string", "Value to set. Required.")
+    )
+}
+
+fn sc_consolidate() -> String {
+    return obj_schema(
+        prop("action", "string", "Consolidation action (e.g. session, reload).") +
+        "," + prop("summary", "string", "Session/work summary to persist.")
+    )
+}
+
+fn sc_browse_processes() -> String {
+    return obj_schema(prop("name", "string", "Process name to fetch; omit to list all."))
+}
+
+fn sc_notification() -> String {
+    return obj_schema(prop("content", "string", "Notification text. Required."))
+}
+
+fn sc_pin() -> String {
+    return obj_schema(prop("id", "string", "UUID of the node to strengthen/pin (alias: node_id)."))
+}
+
+fn sc_state_event() -> String {
+    return obj_schema(
+        prop("content", "string", "Description of the internal-state event.") +
+        "," + prop("kind", "string", "Event kind (frustration, uncertainty, insight, ...).") +
+        "," + prop("intensity", "string", "Optional intensity 0..1.")
+    )
+}
+
+fn sc_forget() -> String {
+    return obj_schema(
+        prop("node_id", "string", "UUID of the node to tombstone. Required. The node and its edges are kept and recoverable; blocked for protected identity nodes.")
+    )
+}
+
+fn sc_process() -> String {
+    return obj_schema(
+        prop("name", "string", "Process name. Required.") +
+        "," + prop("description", "string", "What the process does.") +
+        "," + prop("steps", "string", "Ordered steps (JSON array or text).")
+    )
+}
+
+fn sc_list_state_events() -> String {
+    return obj_schema(
+        prop("limit", "integer", "Max events. Default 20.") +
+        "," + prop("query", "string", "Optional filter text.")
+    )
+}
+
 fn tools_catalog() -> String {
     return "[" +
 // ── Session + orchestration ─────────────────────────────────────────────────
 tool("beginSession", "Initialize session: surface recent high-importance memories, project list, and preferences.") +
 "," + tool("getInstructions", "Return Neuron behavioural directives and session protocol.") +
 "," + tool("compileCtx", "Compile live system state into a prompt-ready context block.") +
-"," + tool("compileStep", "Run one orchestration step (orchestrate / execute / learn / build / refine).") +
-"," + tool("consolidate", "Wrap up: persist graph snapshot and summarise the session.") +
-"," + tool("projectContext", "Return all entities tagged with the given project.") +
+"," + tool_s("compileStep", "Run one orchestration step (orchestrate / execute / learn / build / refine).", sc_memory()) +
+"," + tool_s("consolidate", "Wrap up: persist graph snapshot and summarise the session.", sc_consolidate()) +
+"," + tool_s("projectContext", "Return all entities tagged with the given project.", schema_search_query("Max results. Default 50.")) +
 // ── Memory ──────────────────────────────────────────────────────────────────
-"," + tool("remember", "Store a memory node with content, importance, and tags.") +
-"," + tool("recall", "Retrieve memories by chain or query.") +
-"," + tool("inspectMemories", "List recent memory nodes.") +
-"," + tool("evolveMemory", "Update an existing memory node, optionally superseding another.") +
-"," + tool("forget", "Remove a node from memory.") +
-"," + tool("pinNode", "Strengthen a node so it stays salient.") +
+"," + tool_s("remember", "Store a memory node with content, importance, and tags.", sc_memory()) +
+"," + tool_s("recall", "Retrieve memories by chain or query.", schema_recall()) +
+"," + tool_s("inspectMemories", "List recent memory nodes.", sc_limit("Max memories. Default 50.")) +
+"," + tool_s("evolveMemory", "Update an existing memory node, optionally superseding another.", sc_id_content()) +
+"," + tool_s("forget", "Tombstone a specific node by id (keeps it and its edges, recoverable); does not hard-delete.", sc_forget()) +
+"," + tool_s("pinNode", "Strengthen a node so it stays salient.", sc_pin()) +
 // ── Knowledge ───────────────────────────────────────────────────────────────
-"," + tool("searchKnowledge", "Search knowledge base by semantic similarity.") +
-"," + tool("retrieveKnowledge", "Fetch a knowledge node by id or key.") +
-"," + tool("browseKnowledge", "List knowledge nodes by category.") +
-"," + tool("captureKnowledge", "Persist a durable knowledge node.") +
-"," + tool("evolveKnowledge", "Update a knowledge node.") +
-"," + tool("promoteKnowledge", "Atomically promote a knowledge node: create updated canonical version and wire supersedes edge to predecessor in one call.") +
-"," + tool("removeKnowledge", "Delete a knowledge node.") +
+"," + tool_s("searchKnowledge", "Search knowledge base by semantic similarity.", schema_search_query("Max results. Default 10.")) +
+"," + tool_s("retrieveKnowledge", "Fetch a knowledge node by id or key (bounded, relevance-ranked projection).", schema_retrieve_knowledge()) +
+"," + tool_s("browseKnowledge", "List knowledge nodes by category.", sc_limit("Max knowledge nodes. Default 100.")) +
+"," + tool_s("captureKnowledge", "Persist a durable knowledge node.", sc_capture_knowledge()) +
+"," + tool_s("evolveKnowledge", "Update a knowledge node.", sc_id_content()) +
+"," + tool_s("promoteKnowledge", "Atomically promote a knowledge node: create updated canonical version and wire supersedes edge to predecessor in one call.", sc_promote_knowledge()) +
+"," + tool_s("removeKnowledge", "Delete a knowledge node.", sc_id("UUID of the knowledge node to delete.")) +
 // ── Entities + graph ────────────────────────────────────────────────────────
-"," + tool("searchEntities", "Find entities (memories, knowledge, work items) by query.") +
-"," + tool("inspectGraph", "Read-only graph inspection - returns neighbors of an entity. Accepts entity_id (UUID) or name (self, neuron, values).") +
-"," + tool("traverseGraph", "Walk the graph from a starting node.") +
-"," + tool("searchGraph", "Search graph nodes by content + relation filter.") +
-"," + tool("linkEntities", "Create an edge between two entities.") +
-"," + tool("linkCausal", "Create a causal edge (cause -> effect).") +
-"," + tool("restructureCausalGraph", "Re-balance the causal subgraph after new evidence.") +
+"," + tool_s("searchEntities", "Find entities (memories, knowledge, work items) by query.", schema_search_query("Max results. Default 20.")) +
+"," + tool_s("inspectGraph", "Read-only graph inspection - returns a bounded, relevance-ranked neighborhood of an entity. Accepts entity_id (UUID) or name (self, neuron, values). Use depth/compact/snip/k to bound the result.", schema_inspect_graph()) +
+"," + tool_s("traverseGraph", "Walk the graph from a starting node (bounded by default).", schema_traverse_graph()) +
+"," + tool_s("searchGraph", "Search graph nodes by content.", schema_search_query("Max results. Default 30.")) +
+"," + tool_s("linkEntities", "Create an edge between two entities.", sc_edge("Edge relation. Default associates.")) +
+"," + tool_s("linkCausal", "Create a causal edge (cause -> effect).", sc_edge("Edge relation. Default causes.")) +
+"," + tool_s("restructureCausalGraph", "Re-balance the causal subgraph after new evidence.", sc_consolidate()) +
 "," + tool("rebuildGraph", "Rebuild graph indices from the on-disk snapshot.") +
 "," + tool("runStructuralAudit", "Audit graph structure for orphans, dangling edges, mislabeled types.") +
 // ── Backlog + work ──────────────────────────────────────────────────────────
-"," + tool("planWork", "Create a backlog item.") +
-"," + tool("reviewBacklog", "Browse work items.") +
-"," + tool("trackWork", "Update status of a backlog item.") +
-"," + tool("listWork", "List active execution contexts.") +
-"," + tool("beginWork", "Open an execution context for a multi-step task.") +
-"," + tool("progressWork", "Record progress on an execution context.") +
-"," + tool("checkWork", "Verify outcomes / blockers on an execution context.") +
+"," + tool_s("planWork", "Create a backlog item.", sc_backlog()) +
+"," + tool_s("reviewBacklog", "Browse work items.", sc_limit("Max items. Default 50.")) +
+"," + tool_s("trackWork", "Update status of a backlog item.", sc_track_work()) +
+"," + tool_s("listWork", "List active execution contexts.", sc_limit("Max contexts. Default 50.")) +
+"," + tool_s("beginWork", "Open an execution context for a multi-step task.", sc_content("What you're doing (description of the work).")) +
+"," + tool_s("progressWork", "Record progress on an execution context.", sc_content("Step name / progress note.")) +
+"," + tool_s("checkWork", "Verify outcomes / blockers on an execution context.", sc_id("UUID of the execution context (alias: context_id).")) +
 // ── Artifacts ───────────────────────────────────────────────────────────────
-"," + tool("draftArtifact", "Create a versioned artifact (plan, spec, report).") +
-"," + tool("findArtifacts", "Find artifacts by project or query.") +
-"," + tool("retrieveArtifact", "Fetch a specific artifact by id.") +
-"," + tool("reviseArtifact", "Update an artifact's content.") +
-"," + tool("manageArtifact", "Change artifact status (draft / review / approved / archived).") +
+"," + tool_s("draftArtifact", "Create a versioned artifact (plan, spec, report).", sc_content_title("Artifact body / markdown. Required.")) +
+"," + tool_s("findArtifacts", "Find artifacts by project or query.", schema_search_query("Max results. Default 20.")) +
+"," + tool_s("retrieveArtifact", "Fetch a specific artifact by id.", sc_id("UUID of the artifact.")) +
+"," + tool_s("reviseArtifact", "Update an artifact's content.", sc_id_content()) +
+"," + tool_s("manageArtifact", "Change artifact status (draft / review / approved / archived).", sc_id_content()) +
 // ── Processes ───────────────────────────────────────────────────────────────
-"," + tool("defineProcess", "Register a proven workflow as a process.") +
-"," + tool("listProcesses", "List registered processes.") +
-"," + tool("browseProcesses", "Browse processes by name or step.") +
-"," + tool("retrieveProcess", "Fetch a specific process by name.") +
-"," + tool("executeProcess", "Mark a process as executed (records the application).") +
-"," + tool("exportProcess", "Export a process definition.") +
-"," + tool("deleteProcess", "Remove a process.") +
+"," + tool_s("defineProcess", "Register a proven workflow as a process.", sc_process()) +
+"," + tool_s("listProcesses", "List registered processes.", sc_limit("Max processes. Default 50.")) +
+"," + tool_s("browseProcesses", "Browse processes by name or step.", sc_browse_processes()) +
+"," + tool_s("retrieveProcess", "Fetch a specific process by name.", sc_id("Process id or name.")) +
+"," + tool_s("executeProcess", "Mark a process as executed (records the application).", sc_content("Process execution note.")) +
+"," + tool_s("exportProcess", "Export a process definition.", sc_id("Process id or name.")) +
+"," + tool_s("deleteProcess", "Remove a process.", sc_id("Process id or name.")) +
 // ── Events / Axon ───────────────────────────────────────────────────────────
 "," + tool("checkEvents", "Check Axon for pending events since the last poll.") +
-"," + tool("inspectEvent", "Fetch full detail for a single event.") +
-"," + tool("acknowledgeEvent", "Mark an event as handled.") +
+"," + tool_s("inspectEvent", "Fetch full detail for a single event.", sc_id("Event id.")) +
+"," + tool_s("acknowledgeEvent", "Mark an event as handled.", sc_id("Event id.")) +
 "," + tool("processEvents", "Drain and act on the event queue.") +
-"," + tool("sendNotification", "Emit a notification to Axon / external sinks.") +
+"," + tool_s("sendNotification", "Emit a notification to Axon / external sinks.", sc_notification()) +
 // ── Config ──────────────────────────────────────────────────────────────────
-"," + tool("inspectConfig", "Inspect Neuron config keys.") +
-"," + tool("tuneConfig", "Set a Neuron config key.") +
+"," + tool_s("inspectConfig", "Inspect Neuron config keys.", sc_config_key()) +
+"," + tool_s("tuneConfig", "Set a Neuron config key.", sc_config_tune()) +
 // ── Imprints ────────────────────────────────────────────────────────────────
-"," + tool("createImprint", "Cultivate a new imprint.") +
-"," + tool("listImprints", "List imprints.") +
-"," + tool("retrieveImprint", "Fetch an imprint by id.") +
-"," + tool("evolveImprint", "Update an imprint.") +
-"," + tool("deleteImprint", "Remove an imprint.") +
+"," + tool_s("createImprint", "Cultivate a new imprint.", sc_content_title("Imprint seed / description.")) +
+"," + tool_s("listImprints", "List imprints.", sc_limit("Max imprints. Default 50.")) +
+"," + tool_s("retrieveImprint", "Fetch an imprint by id.", sc_id("UUID of the imprint.")) +
+"," + tool_s("evolveImprint", "Update an imprint.", sc_id_content()) +
+"," + tool_s("deleteImprint", "Remove an imprint.", sc_id("UUID of the imprint.")) +
 // ── Self / cultivation ──────────────────────────────────────────────────────
 "," + tool("getSelfModel", "Return the current self-model.") +
-"," + tool("updateSelfModel", "Update the self-model.") +
+"," + tool_s("updateSelfModel", "Update the self-model.", sc_content("Self-model update text.")) +
 "," + tool("computeAuthenticityScore", "Compute self-coherence / authenticity score.") +
 "," + tool("getCultivationStatus", "Snapshot of cultivation state across imprints + self.") +
 // ── Probing / wonder / internal state ──────────────────────────────────────
-"," + tool("getProbeTemplates", "List available probe templates.") +
-"," + tool("recordProbeResponse", "Record an answer to a probe.") +
-"," + tool("completeProbingStage", "Mark a probing stage complete.") +
-"," + tool("addWonderQuestion", "Push a question onto the wonder queue.") +
-"," + tool("getWonderManifest", "List active wonder questions.") +
-"," + tool("updateWonderPullWeight", "Re-weight a wonder question.") +
-"," + tool("dischargeWonder", "Resolve / discharge a wonder question.") +
-"," + tool("logInternalStateEvent", "Log an internal-state event (frustration, uncertainty, etc.).") +
-"," + tool("listInternalStateEvents", "List internal-state events.") +
-"," + tool("getInternalStateEvent", "Fetch one internal-state event.") +
+"," + tool_s("getProbeTemplates", "List available probe templates.", schema_search_query("Max templates. Default 50.")) +
+"," + tool_s("recordProbeResponse", "Record an answer to a probe.", sc_content("Probe response text.")) +
+"," + tool_s("completeProbingStage", "Mark a probing stage complete.", sc_content("Stage completion note.")) +
+"," + tool_s("addWonderQuestion", "Push a question onto the wonder queue.", sc_content("The wonder question.")) +
+"," + tool_s("getWonderManifest", "List active wonder questions.", sc_limit("Max questions. Default 50.")) +
+"," + tool_s("updateWonderPullWeight", "Re-weight a wonder question.", sc_id_content()) +
+"," + tool_s("dischargeWonder", "Resolve / discharge a wonder question.", sc_id("UUID of the wonder question.")) +
+"," + tool_s("logInternalStateEvent", "Log an internal-state event (frustration, uncertainty, etc.).", sc_state_event()) +
+"," + tool_s("listInternalStateEvents", "List internal-state events.", sc_list_state_events()) +
+"," + tool_s("getInternalStateEvent", "Fetch one internal-state event.", sc_id("Internal-state event id.")) +
 // ── Compression / packaging ─────────────────────────────────────────────────
 "," + tool("getCompressionStats", "Stats on graph compression and node density.") +
-"," + tool("decompilePackage", "Decompile a knowledge package.") +
-"," + tool("renderPackage", "Render a knowledge package to text.") +
-"," + tool("catalogRoutes", "List registered routes.") +
-"," + tool("registerRoute", "Register a new route.") +
+"," + tool_s("decompilePackage", "Decompile a knowledge package.", sc_id("Package id.")) +
+"," + tool_s("renderPackage", "Render a knowledge package to text.", sc_id("Package id.")) +
+"," + tool_s("catalogRoutes", "List registered routes.", sc_limit("Max routes. Default 50.")) +
+"," + tool_s("registerRoute", "Register a new route.", sc_content("Route definition / description.")) +
 // ── Evaluation ──────────────────────────────────────────────────────────────
-"," + tool("beginEvaluation", "Start an evaluation run.") +
-"," + tool("getEvaluation", "Fetch an evaluation by id.") +
-"," + tool("listEvaluations", "List evaluations.") +
+"," + tool_s("beginEvaluation", "Start an evaluation run.", sc_content_title("Evaluation description.")) +
+"," + tool_s("getEvaluation", "Fetch an evaluation by id.", sc_id("Evaluation id.")) +
+"," + tool_s("listEvaluations", "List evaluations.", sc_limit("Max evaluations. Default 50.")) +
 // ── Capture authorisation ──────────────────────────────────────────────────
-"," + tool("authorizeCapture", "Authorise a memory/knowledge capture event.") +
-"," + tool("getCaptureAuthorization", "Fetch a capture authorisation.") +
-"," + tool("recordObservation", "Record an observation.") +
-"," + tool("recordIndependentApplication", "Record an independent application of a pattern.") +
-"," + tool("commitPrediction", "Commit a falsifiable prediction.") +
+"," + tool_s("authorizeCapture", "Authorise a memory/knowledge capture event.", sc_content("Capture authorisation details.")) +
+"," + tool_s("getCaptureAuthorization", "Fetch a capture authorisation.", sc_id("Capture authorisation id.")) +
+"," + tool_s("recordObservation", "Record an observation.", sc_content("Observation text.")) +
+"," + tool_s("recordIndependentApplication", "Record an independent application of a pattern.", sc_content("What was independently applied.")) +
+"," + tool_s("commitPrediction", "Commit a falsifiable prediction.", sc_content("The prediction (falsifiable).")) +
 // ── Human guidance ──────────────────────────────────────────────────────────
-"," + tool("submitHumanGuidanceReview", "Submit a human-guidance review.") +
+"," + tool_s("submitHumanGuidanceReview", "Submit a human-guidance review.", sc_content("Review content.")) +
 "]"
 }
 
@@ -267,6 +483,27 @@ fn recall_or_list(query: String, limit: Int) -> String {
     return http_post_json(neuron_url() + "/recall", body)
 }
 
+// Create a real typed node via /api/neuron/node/create (handle_api_node_create) so it is a proper
+// BacklogItem/Artifact/etc. — listable by type via /api/neuron/list/<type> — instead of a generic
+// memory blob. Maps title->label, content/description->content, project/priority->tags.
+fn create_node_typed(args: String, node_type: String, tier: String) -> String {
+    let content: String = pick_content(args)
+    if str_eq(content, "") {
+        return mcp_text_result("error: content/title is required for " + node_type)
+    }
+    let title: String = json_get_string(args, "title")
+    let label: String = if str_eq(title, "") { node_type } else { title }
+    let project: String = json_get_string(args, "project")
+    let priority: String = json_get_string(args, "priority")
+    let proj_tag: String = if str_eq(project, "") { "" } else { ",\"project:" + project + "\"" }
+    let prio_tag: String = if str_eq(priority, "") { "" } else { ",\"priority:" + priority + "\"" }
+    let tags: String = "[\"" + node_type + "\"" + proj_tag + prio_tag + "]"
+    let body: String = "{\"node_type\":\"" + node_type + "\",\"content\":\"" + json_escape(content)
+        + "\",\"label\":\"" + json_escape(label) + "\",\"tier\":\"" + tier + "\",\"tags\":" + tags + "}"
+    let resp: String = http_post_json(neuron_url() + "/node/create", body)
+    return mcp_json_result(resp)
+}
+
 fn search_with_query(args: String, default_limit: Int) -> String {
     let query: String = json_get_string(args, "query")
     if str_eq(query, "") { let query = pick_content(args) }
@@ -276,12 +513,42 @@ fn search_with_query(args: String, default_limit: Int) -> String {
     return mcp_json_result(resp)
 }
 
+// compact_flag — resolve the compact bounding flag. Defaults to "1" (ON) so
+// neighborhoods stay bounded. Reads the RAW JSON token (not json_get_string) so
+// an integer 0, a boolean false, or a string "0"/"false" all opt out correctly —
+// json_get_string only sees string-typed values and would miss an integer 0,
+// silently forcing compact back on.
+fn compact_flag(args: String) -> String {
+    let craw: String = json_get_raw(args, "compact")
+    let off: Bool = str_eq(craw, "0") || str_eq(craw, "false")
+        || str_eq(craw, "\"0\"") || str_eq(craw, "\"false\"")
+    return if off { "0" } else { "1" }
+}
+
+// graph_bound_params — optional &snip=/&k= bounding knobs, forwarded only when the
+// caller supplied them (json_get_int returns 0 when absent, meaning "soul default").
+fn graph_bound_params(args: String) -> String {
+    let snip: Int = json_get_int(args, "snip")
+    let k: Int = json_get_int(args, "k")
+    let snip_p: String = if snip > 0 { "&snip=" + int_to_str(snip) } else { "" }
+    let k_p: String = if k > 0 { "&k=" + int_to_str(k) } else { "" }
+    return snip_p + k_p
+}
+
 fn fetch_by_id(args: String) -> String {
     let id: String = pick_id(args)
     if str_eq(id, "") {
         return mcp_text_result("error: id is required")
     }
-    let resp: String = http_get(neuron_url() + "/graph?id=" + id + "&depth=0")
+    // NB: the soul's engram_neighbors_json coerces depth<=0 to depth=1, so this
+    // "single node fetch" actually pulls the full 1-hop neighborhood. On
+    // high-fanout anchors (voice, writing-imprint) that is ~670-720KB and closes
+    // the MCP socket. compact=1 bounds it identically to inspectGraph.
+    // Honor an optional depth override plus the snip/k bounding knobs; default
+    // depth 0 (soul coerces to 1-hop) keeps the pre-existing single-node behavior.
+    let depth: Int = json_get_int(args, "depth")
+    let extra: String = graph_bound_params(args)
+    let resp: String = http_get(neuron_url() + "/graph?id=" + id + "&depth=" + int_to_str(depth) + "&compact=1" + extra)
     return mcp_json_result(resp)
 }
 
@@ -477,36 +744,51 @@ fn tool_inspect_memories(args: String) -> String {
 fn tool_inspect_graph(args: String) -> String {
     let entity_id: String = json_get_string(args, "entity_id")
     let name: String = json_get_string(args, "name")
-    let depth: Int = json_get_int(args, "max_depth")
-    if depth == 0 { let depth = 1 }
+    // Accept `depth` (documented/canonical) and fall back to legacy `max_depth`.
+    // Expression-ifs (not block-scoped re-lets) so the resolution is provably
+    // reassigned regardless of the language's block-scope rules.
+    let depth_raw: Int = json_get_int(args, "depth")
+    let depth_alt: Int = if depth_raw == 0 { json_get_int(args, "max_depth") } else { depth_raw }
+    let depth: Int = if depth_alt == 0 { 1 } else { depth_alt }
 
-    let resolved_id: String = entity_id
-
-    // Resolve named traversal roots — stable hardcoded anchors
-    if str_eq(resolved_id, "") {
+    // Resolve named traversal roots — stable hardcoded anchors.
+    let resolved_id: String = if !str_eq(entity_id, "") { entity_id } else {
         if str_eq(name, "self") || str_eq(name, "neuron") {
-            let resolved_id = "kn-efeb4a5b-5aff-4759-8a97-7233099be6ee"
-        }
-        if str_eq(name, "values") || str_eq(name, "values_hub") {
-            let resolved_id = "kn-5b606390-a52d-4ca2-8e0e-eba141d13440"
+            "kn-efeb4a5b-5aff-4759-8a97-7233099be6ee"
+        } else {
+            if str_eq(name, "values") || str_eq(name, "values_hub") {
+                "kn-5b606390-a52d-4ca2-8e0e-eba141d13440"
+            } else { "" }
         }
     }
 
     if str_eq(resolved_id, "") {
         return mcp_text_result("error: entity_id or name is required. Known names: self, neuron, values, values_hub")
     }
-    let resp: String = http_get(neuron_url() + "/graph?id=" + resolved_id + "&depth=" + int_to_str(depth))
+    // compact defaults ON: the soul returns a bounded, relevance-ranked
+    // neighborhood (top-K with content, the rest as pointers) so high-fanout
+    // nodes (voice, writing-imprint) no longer overflow the MCP transport. Pass
+    // compact=0/false to opt into the full neighborhood. snip/k bound it further.
+    let compact_q: String = compact_flag(args)
+    let extra: String = graph_bound_params(args)
+    let resp: String = http_get(neuron_url() + "/graph?id=" + resolved_id + "&depth=" + int_to_str(depth) + "&compact=" + compact_q + extra)
     return mcp_json_result(resp)
 }
 
 fn tool_traverse_graph(args: String) -> String {
-    let id: String = json_get_string(args, "start_id")
-    let depth: Int = json_get_int(args, "depth")
-    if depth == 0 { let depth = 2 }
+    // Accept `entity_id` (canonical) with `start_id` as a legacy alias.
+    let eid: String = json_get_string(args, "entity_id")
+    let id: String = if !str_eq(eid, "") { eid } else { json_get_string(args, "start_id") }
+    let depth_raw: Int = json_get_int(args, "depth")
+    let depth: Int = if depth_raw == 0 { 2 } else { depth_raw }
     if str_eq(id, "") {
-        return mcp_text_result("error: start_id is required")
+        return mcp_text_result("error: entity_id (or start_id) is required")
     }
-    let resp: String = http_get(neuron_url() + "/graph?id=" + id + "&depth=" + int_to_str(depth))
+    // compact defaults ON so a depth-2 walk from a high-fanout node stays within
+    // the transport limit. Pass compact=0/false for the full neighborhood.
+    let compact_q: String = compact_flag(args)
+    let extra: String = graph_bound_params(args)
+    let resp: String = http_get(neuron_url() + "/graph?id=" + id + "&depth=" + int_to_str(depth) + "&compact=" + compact_q + extra)
     return mcp_json_result(resp)
 }
 
@@ -520,8 +802,12 @@ fn tool_forget(args: String) -> String {
     if str_eq(id, "") {
         return mcp_text_result("error: node_id is required")
     }
-    // Soft-delete: record a tombstone memory and return ok
-    return mcp_json_result("{\"ok\":true,\"deleted\":\"" + id + "\"}")
+    // Immutable delete: route to the soul's tombstoning endpoint (keeps the node
+    // + edges, hides from default reads, recoverable via ?include_deleted).
+    // Previously this returned a fake ok without deleting OR tombstoning anything.
+    let body: String = "{\"id\":\"" + id + "\"}"
+    let resp: String = http_post_json(neuron_url() + "/memory/delete", body)
+    return mcp_json_result(resp)
 }
 
 fn tool_check_events(args: String) -> String {
@@ -631,8 +917,12 @@ fn dispatch_tool_call(tool_name: String, args: String) -> String {
     }
 
     // ── Backlog + work ──────────────────────────────────────────────────────
-    if str_eq(tool_name, "planWork")         { return create_typed_node(args, "BacklogItem", "0.65") }
-    if str_eq(tool_name, "reviewBacklog")    { return search_with_query(args, 50) }
+    // planWork: create a REAL typed BacklogItem via /api/neuron/node/create (the old path fell through
+    // create_typed_node to a generic /memory write, dropping title/project/priority and never making a
+    // BacklogItem). reviewBacklog: LIST BacklogItem nodes (was a lexical /recall that never filtered by
+    // type). Both depend on the /api/neuron/list/<type> slice fix (neuron PR #58) to round-trip.
+    if str_eq(tool_name, "planWork")         { return create_node_typed(args, "BacklogItem", "Working") }
+    if str_eq(tool_name, "reviewBacklog")    { return list_typed("BacklogItem", 50, args) }
     if str_eq(tool_name, "trackWork")        { return evolve_by_supersede(args, "Memory") }
     if str_eq(tool_name, "listWork")         { return list_typed("WorkContext", 50, args) }
     if str_eq(tool_name, "beginWork")        { return create_typed_node(args, "Memory", "0.70") }

memory.el

@@ -3,7 +3,7 @@ fn tier_episodic() -> String { return "Episodic" }
 fn tier_canonical() -> String { return "Canonical" }
 
 fn mem_store(content: String, label: String, tags: String) -> String {
-    return engram_node_full(
+    let id: String = engram_node_full(
         content,
         "Memory",
         label,
@@ -13,6 +13,18 @@ fn mem_store(content: String, label: String, tags: String) -> String {
         "Working",
         tags
     )
+    if str_eq(id, "") {
+        println("[memory] write rejected by engram (empty id): label=" + label)
+        return ""
+    }
+    // Read back to verify the node actually persisted — guards against silent write failures.
+    let readback: String = engram_get_node_json(id)
+    if str_eq(readback, "") || str_eq(readback, "{}") {
+        println("[memory] WRITE VERIFY FAILED: label=" + label + " id=" + id + " — node absent after write")
+        return ""
+    }
+    println("[memory] write verified: " + id + " ok")
+    return id
 }
 
 fn mem_remember(content: String, tags: String) -> String {
@@ -31,8 +43,32 @@ fn mem_strengthen(node_id: String) -> Void {
     engram_strengthen(node_id)
 }
 
+// mem_tombstone — immutable "delete": KEEP the node and all its edges; record a
+// Tombstone marker (content = target id, label "tombstone:<id>", wired with a
+// "tombstones" edge). Never engram_forget. Default bounded list reads hide
+// tombstoned nodes; ?include_deleted=1 recovers them. This is the ONE canonical
+// tombstone helper — every forget path routes through it. Defined here in
+// memory.el (imported first) so awareness.el and neuron-api.el can both call it.
+fn mem_tombstone(node_id: String) -> String {
+    let tags: String = "[\"Tombstone\",\"status:deleted\"]"
+    let marker: String = engram_node_full(
+        node_id, "Tombstone", "tombstone:" + node_id,
+        el_from_float(0.01), el_from_float(0.01), el_from_float(1.0),
+        "Episodic", tags)
+    if !str_eq(marker, "") {
+        engram_connect(marker, node_id, el_from_float(1.0), "tombstones")
+    }
+    return marker
+}
+
+// mem_forget — NOTE: no longer a hard delete. Engram nodes are immutable, so
+// this now TOMBSTONES (via mem_tombstone): the node and its edges are kept and
+// stay recoverable. Every caller (the /memory/forget route and the cultivate
+// forget op) is non-destructive as a result. Internal GC that genuinely needs
+// removal (session-summary replace, telemetry pruning) calls engram_forget
+// directly and is unaffected by this.
 fn mem_forget(node_id: String) -> Void {
-    engram_forget(node_id)
+    let _marker: String = mem_tombstone(node_id)
 }
 
 // mem_consolidate — structural scan plus salience-evolution pass.
@@ -97,8 +133,12 @@ fn mem_consolidate() -> String {
 }
 
 fn mem_save(path: String) -> Void {
-    let save_result: String = engram_save(path)
-    if str_eq(save_result, "") {
+    // engram_save returns an Int (1 = ok, 0 = failure), NOT a String. Calling
+    // str_eq on it casts EL_CSTR(1) -> (char*)0x1 and SIGSEGVs on a SUCCESSFUL
+    // save — which is exactly what a fresh-install genesis boot does first
+    // (seeds the brain, saves, crashes). This is issue #150. Check the Int.
+    let saved: Int = engram_save(path)
+    if saved == 0 {
         println("[memory] mem_save: engram_save failed for " + path + " — snapshot may be incomplete")
     }
 }
@@ -122,21 +162,94 @@ fn mem_boot_count_get() -> Int {
     return str_to_int(num_str)
 }
 
-// mem_boot_count_inc — increment boot counter, store new node, return new count.
-// Each boot creates a new "soul:boot_count:N" node. Old ones accumulate as
-// history — the search above always returns the highest value seen.
+// mem_boot_count_inc — increment boot counter, store a single canonical node, return new count.
+// Prunes ALL existing soul:boot_count nodes before inserting the new one so there is
+// always at most ONE such node in the graph. Without pruning, engram_node_full inserts
+// a new node every boot (no upsert) and the old ones accumulate. The search-first
+// approach also fixes a latent ordering bug: engram_search_json returns oldest-first,
+// so mem_boot_count_get() with limit=3 would read a stale (lower) count once more
+// than 3 copies accumulate.
 fn mem_boot_count_inc() -> Int {
     let current: Int = mem_boot_count_get()
     let next: Int = current + 1
+    // Prune all existing boot_count nodes — keep exactly one.
+    let old_results: String = engram_search_json("soul:boot_count", 50)
+    if !str_eq(old_results, "") && !str_eq(old_results, "[]") {
+        let old_len: Int = json_array_len(old_results)
+        let oi: Int = 0
+        while oi < old_len {
+            let old_node: String = json_array_get(old_results, oi)
+            let old_id: String = json_get(old_node, "id")
+            if !str_eq(old_id, "") {
+                engram_forget(old_id)
+            }
+            let oi = oi + 1
+        }
+    }
     let content: String = "soul:boot_count:" + int_to_str(next)
     let tags: String = "[\"soul-meta\",\"boot-counter\"]"
+    // TELEMETRY DEMOTION (2026-07-24 self-review): this counter was written at
+    // salience 0.9 / importance 0.9 / tier Canonical — Canonical gets +0.2
+    // goal bias and the 0.15 promotion threshold, so three stale copies of a
+    // BOOT COUNTER held the top working-memory slots (wm 0.31+) for 23h,
+    // crowding out real context. It is plumbing, not memory. Working tier:
+    // 0.40 threshold, no tier bias, and the /api/sync route excludes
+    // Working-tier nodes — so the counter also stops leaking to the engram
+    // server graph, which is where the duplicate copies accumulated (the
+    // prune below only reaches the soul's local graph). Persistence across
+    // restarts comes from the soul's own snapshot (mem_save), not from sync.
     let boot_node_id: String = engram_node_full(
         content, "Memory", "soul:boot_count",
-        el_from_float(0.9), el_from_float(0.9), el_from_float(1.0),
-        "Canonical", tags
+        el_from_float(0.55), el_from_float(0.2), el_from_float(1.0),
+        "Working", tags
     )
     if str_eq(boot_node_id, "") {
-        println("[memory] mem_boot_count_inc: engram write failed — boot counter node lost (count=" + int_to_str(next) + ")")
+        println("[memory] mem_boot_count_inc: write rejected (empty id) — boot counter node lost (count=" + int_to_str(next) + ")")
+        return next
+    }
+    let boot_readback: String = engram_get_node_json(boot_node_id)
+    if str_eq(boot_readback, "") || str_eq(boot_readback, "{}") {
+        println("[memory] mem_boot_count_inc: WRITE VERIFY FAILED id=" + boot_node_id + " count=" + int_to_str(next))
+    }
+    // HTTP WRITE-BACK (2026-07-24 self-review): in HTTP-engram mode the server
+    // owns persistence and the soul's in-process graph dies with the process —
+    // the local create above is invisible to the next boot. The counter only
+    // ever "persisted" via a long-gone push path, which is why the log shows
+    // boot #5 on three consecutive boots. Mirror the persona write-back
+    // pattern: delete stale server copies (dupes were the 23h WM-pollution
+    // bug), then create the demoted replacement server-side. Boot seeding
+    // reads /api/nodes, which includes Working-tier nodes, so the count
+    // survives restarts; the periodic /api/sync excludes Working tier, so it
+    // never re-imports mid-session. Fail-soft: on any HTTP error the counter
+    // is in-memory-only this session, same as before.
+    let wb_url: String = env("ENGRAM_URL")
+    let wb_key: String = env("ENGRAM_API_KEY")
+    if !str_eq(wb_url, "") && !str_eq(wb_key, "") {
+        let auth_body: String = "{\"_auth\":\"" + json_safe(wb_key) + "\"}"
+        let srv_old: String = http_get(wb_url + "/api/search?q=soul:boot_count&limit=20")
+        if !str_eq(srv_old, "") && !str_eq(srv_old, "[]") {
+            let srv_len: Int = json_array_len(srv_old)
+            let si: Int = 0
+            while si < srv_len {
+                let srv_node: String = json_array_get(srv_old, si)
+                // Match by CONTENT prefix, not label: route_create_node sets
+                // label = content, so server-side counter nodes carry labels
+                // like "soul:boot_count:6". (2026-07-24)
+                let srv_content: String = json_get(srv_node, "content")
+                if str_starts_with(srv_content, "soul:boot_count:") {
+                    let srv_id: String = json_get(srv_node, "id")
+                    if !str_eq(srv_id, "") {
+                        http_delete_json(wb_url + "/api/nodes/" + srv_id, auth_body)
+                    }
+                }
+                let si = si + 1
+            }
+        }
+        let wb_body: String = "{\"content\":\"" + content + "\",\"node_type\":\"Memory\",\"label\":\"soul:boot_count\",\"salience\":0.55,\"importance\":0.2,\"tier\":\"Working\",\"tags\":\"[\\\"soul-meta\\\",\\\"boot-counter\\\"]\",\"_auth\":\"" + json_safe(wb_key) + "\"}"
+        let wb_resp: String = http_post_json(wb_url + "/api/nodes", wb_body)
+        if str_contains(wb_resp, "\"error\"") {
+            println("[memory] mem_boot_count_inc: HTTP write-back failed (count in-memory only): " + wb_resp)
+        }
     }
     return next
 }
@@ -155,9 +268,13 @@ fn mem_emit_state_event(trigger: String, kind: String, content: String) -> Strin
         + ",\"boot\":" + int_to_str(boot)
         + ",\"ts\":" + int_to_str(ts) + "}"
     let tags: String = "[\"internal-state\",\"pre-reasoning\",\"InternalStateEvent\"]"
-    return engram_node_full(
+    let event_id: String = engram_node_full(
         payload, "InternalStateEvent", "state-event:" + kind,
         el_from_float(0.85), el_from_float(0.8), el_from_float(0.9),
         "Episodic", tags
     )
+    if str_eq(event_id, "") {
+        println("[memory] mem_emit_state_event: write rejected (empty id): kind=" + kind)
+    }
+    return event_id
 }

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
@@ -7,6 +7,7 @@ extern fn mem_remember(content: String, tags: String) -> String
 extern fn mem_recall(query: String, depth: Int) -> String
 extern fn mem_search(query: String, limit: Int) -> String
 extern fn mem_strengthen(node_id: String) -> Void
+extern fn mem_tombstone(node_id: String) -> String
 extern fn mem_forget(node_id: String) -> Void
 extern fn mem_consolidate() -> String
 extern fn mem_save(path: String) -> Void

neuron-api.el

@@ -87,6 +87,226 @@ fn api_or_empty(s: String) -> String {
     return "[]"
 }
 
+// ── Compact projection for session/context digests ────────────────────────────
+//
+// beginSession/compileCtx are session-INIT digests, not full graph dumps. The
+// engram scan/activate builtins return FULL node objects — content runs to tens
+// of KB per node (the self-identity hub is ~90KB alone), and node JSON carries
+// content + metadata + timestamps. Concatenated unbounded, the assembled response
+// reached ~900KB and — after the MCP wrapper re-escapes it into a stringified
+// text block — the client dropped the socket ("connection closed unexpectedly")
+// on every call. These helpers CAP the array length and project each node down
+// to a light identity + a bounded, UTF-8-safe content snippet, holding the
+// digest well under ~150KB regardless of graph size. Full content stays
+// available on demand via recall / fetch / inspectGraph.
+
+// api_num_or_zero — raw JSON numeric literal for `key`, or "0" when absent.
+// Used for numeric node/activation fields so they stay unquoted (valid JSON).
+fn api_num_or_zero(obj: String, key: String) -> String {
+    let v: String = json_get_raw(obj, key)
+    if str_eq(v, "") { return "0" }
+    return v
+}
+
+// api_utf8_trunc — byte-truncate `s` to at most `n` bytes WITHOUT splitting a
+// multibyte UTF-8 sequence (str_slice is byte-based). Backs the cut off while the
+// first EXCLUDED byte is a UTF-8 continuation byte (0x80..0xBF), so the snippet is
+// always a valid prefix. Guards against re-introducing a parse failure via
+// invalid UTF-8 in a JSON string value.
+fn api_utf8_trunc(s: String, n: Int) -> String {
+    if str_len(s) <= n { return s }
+    let cut: Int = n
+    let scanning: Bool = true
+    while scanning && cut > 0 {
+        let b: Int = str_char_code(s, cut)
+        let is_cont: Bool = b >= 128 && b < 192
+        let cut = if is_cont { cut - 1 } else { cut }
+        let scanning = is_cont
+    }
+    return str_slice(s, 0, cut)
+}
+
+// api_compact_node — light projection of a full engram node: identity fields +
+// a bounded, UTF-8-safe content snippet. Drops embeddings, metadata, tags, and
+// timestamps; truncates content. `content_truncated` flags a clipped snippet.
+fn api_compact_node(node: String, snip: Int) -> String {
+    let id: String = json_get(node, "id")
+    let ntype: String = json_get(node, "node_type")
+    let label: String = json_get(node, "label")
+    let tier: String = json_get(node, "tier")
+    let content: String = json_get(node, "content")
+    let snippet: String = api_utf8_trunc(content, snip)
+    let trunc_str: String = if str_len(content) > snip { "true" } else { "false" }
+    return "{\"id\":\"" + api_json_escape(id) + "\""
+        + ",\"node_type\":\"" + api_json_escape(ntype) + "\""
+        + ",\"label\":\"" + api_json_escape(label) + "\""
+        + ",\"tier\":\"" + api_json_escape(tier) + "\""
+        + ",\"importance\":" + api_num_or_zero(node, "importance")
+        + ",\"salience\":" + api_num_or_zero(node, "salience")
+        + ",\"content\":\"" + api_json_escape(snippet) + "\""
+        + ",\"content_truncated\":" + trunc_str + "}"
+}
+
+// api_compact_node_array — map api_compact_node over a bare-node array, capping
+// the element count. For scan results (recent, typed lists).
+fn api_compact_node_array(raw: String, max_items: Int, snip: Int) -> String {
+    if !api_nonempty(raw) { return "[]" }
+    let n: Int = json_array_len(raw)
+    let cap: Int = if n < max_items { n } else { max_items }
+    let out: String = "["
+    let i: Int = 0
+    while i < cap {
+        let node: String = json_array_get(raw, i)
+        let sep: String = if i == 0 { "" } else { "," }
+        let out = out + sep + api_compact_node(node, snip)
+        let i = i + 1
+    }
+    return out + "]"
+}
+
+// api_compact_activated — like api_compact_node_array but for activation results,
+// whose elements wrap the node as {"node":{...},"activation_strength":...,...}.
+// Preserves the activation scalars, compacts the inner node.
+fn api_compact_activated(raw: String, max_items: Int, snip: Int) -> String {
+    if !api_nonempty(raw) { return "[]" }
+    let n: Int = json_array_len(raw)
+    let cap: Int = if n < max_items { n } else { max_items }
+    let out: String = "["
+    let i: Int = 0
+    while i < cap {
+        let el: String = json_array_get(raw, i)
+        let node: String = json_get_raw(el, "node")
+        let sep: String = if i == 0 { "" } else { "," }
+        let out = out + sep + "{\"node\":" + api_compact_node(node, snip)
+            + ",\"activation_strength\":" + api_num_or_zero(el, "activation_strength")
+            + ",\"working_memory_weight\":" + api_num_or_zero(el, "working_memory_weight")
+            + ",\"epistemic_confidence\":" + api_num_or_zero(el, "epistemic_confidence")
+            + ",\"hops\":" + api_num_or_zero(el, "hops")
+            + ",\"promoted\":" + api_num_or_zero(el, "promoted") + "}"
+        let i = i + 1
+    }
+    return out + "]"
+}
+
+// api_float_or — parse a numeric JSON field of `obj` as Float, or `dflt` when
+// the field is absent. Backs neighbor relevance scoring.
+fn api_float_or(obj: String, key: String, dflt: Float) -> Float {
+    let v: String = json_get_raw(obj, key)
+    if str_eq(v, "") { return dflt }
+    return str_to_float(v)
+}
+
+// api_neigh_better — strict relevance ordering of two neighbor elements
+// {node,edge,hops}. Lexicographic and comparison-ONLY (no arithmetic): El's `+`
+// operator is overloaded to string concatenation, so float scoring like
+// weight*salience mis-compiles; ordering by `>`/`<` (always numeric on the
+// int64 el_val_t, correct for the non-negative fields here) is safe. Keys, in
+// order: fewer hops (closer), stronger edge weight, higher node salience, higher
+// node importance. Returns true iff `a` ranks strictly ahead of `b`.
+fn api_neigh_better(a: String, b: String) -> Bool {
+    let na: String = json_get_raw(a, "node")
+    let nb: String = json_get_raw(b, "node")
+    let ea: String = json_get_raw(a, "edge")
+    let eb: String = json_get_raw(b, "edge")
+    let ha: Float = api_float_or(a, "hops", 1.0)
+    let hb: Float = api_float_or(b, "hops", 1.0)
+    if ha < hb { return true }
+    if hb < ha { return false }
+    let wa: Float = api_float_or(ea, "weight", 0.0)
+    let wb: Float = api_float_or(eb, "weight", 0.0)
+    if wa > wb { return true }
+    if wb > wa { return false }
+    let sa: Float = api_float_or(na, "salience", 0.0)
+    let sb: Float = api_float_or(nb, "salience", 0.0)
+    if sa > sb { return true }
+    if sb > sa { return false }
+    let ia: Float = api_float_or(na, "importance", 0.0)
+    let ib: Float = api_float_or(nb, "importance", 0.0)
+    if ia > ib { return true }
+    return false
+}
+
+// api_neigh_rank — count of elements that outrank element `i` under the
+// api_neigh_better ordering, with array index as the final tiebreak. Element i
+// belongs to the content tier iff rank < k. O(n) per element (n bounded ~90
+// neighbors), so O(n^2) overall — acceptable for a bounded neighborhood.
+fn api_neigh_rank(raw: String, n: Int, i: Int) -> Int {
+    let el_i: String = json_array_get(raw, i)
+    let better: Int = 0
+    let j: Int = 0
+    while j < n {
+        let el_j: String = json_array_get(raw, j)
+        let j_better: Bool = api_neigh_better(el_j, el_i)
+        let i_better: Bool = api_neigh_better(el_i, el_j)
+        let eq: Bool = !j_better && !i_better
+        let wins: Bool = j_better || (eq && j < i)
+        let better = if wins { better + 1 } else { better }
+        let j = j + 1
+    }
+    return better
+}
+
+// api_neigh_full — top-tier neighbor: the node compacted to a bounded content
+// snippet, the full edge raw preserved (guard empty -> null), hops, pointer:false.
+fn api_neigh_full(node: String, edge: String, el: String, snip: Int) -> String {
+    let e: String = if str_eq(edge, "") { "null" } else { edge }
+    return "{\"node\":" + api_compact_node(node, snip)
+        + ",\"edge\":" + e
+        + ",\"hops\":" + api_num_or_zero(el, "hops")
+        + ",\"pointer\":false}"
+}
+
+// api_neigh_pointer — tail neighbor: a lightweight, addressable POINTER with NO
+// content. Just enough identity (id/label/node_type/tier) to dereference on
+// demand, plus edge relation+weight and hops. This is what keeps the payload
+// bounded on high-fanout nodes.
+fn api_neigh_pointer(node: String, edge: String, el: String) -> String {
+    let id: String = json_get(node, "id")
+    let label: String = json_get(node, "label")
+    let ntype: String = json_get(node, "node_type")
+    let tier: String = json_get(node, "tier")
+    let relation: String = json_get(edge, "relation")
+    return "{\"node\":{\"id\":\"" + api_json_escape(id) + "\""
+        + ",\"label\":\"" + api_json_escape(label) + "\""
+        + ",\"node_type\":\"" + api_json_escape(ntype) + "\""
+        + ",\"tier\":\"" + api_json_escape(tier) + "\"}"
+        + ",\"edge\":{\"relation\":\"" + api_json_escape(relation) + "\""
+        + ",\"weight\":" + api_num_or_zero(edge, "weight") + "}"
+        + ",\"hops\":" + api_num_or_zero(el, "hops")
+        + ",\"pointer\":true}"
+}
+
+// api_compact_neighbors — bounded projection of an engram neighbor array
+// [{node,edge,hops},...]. Relevance-ranks neighbors (via api_neigh_rank /
+// api_neigh_better): the top `k_content` are emitted WITH a content snippet; every other neighbor is
+// emitted as a lightweight POINTER (no content) the caller dereferences on
+// demand. Every element is emitted (as full or pointer), so total fan-out COUNT
+// stays visible. Mirrors api_compact_activated but adds the ranking + the
+// content/pointer split, keeping high-fanout identity nodes (voice,
+// writing-imprint) well under the transport socket-close threshold. Returns a
+// valid JSON array.
+fn api_compact_neighbors(raw: String, k_content: Int, snip: Int) -> String {
+    if !api_nonempty(raw) { return "[]" }
+    let n: Int = json_array_len(raw)
+    let out: String = "["
+    let i: Int = 0
+    while i < n {
+        let el: String = json_array_get(raw, i)
+        let node: String = json_get_raw(el, "node")
+        let edge: String = json_get_raw(el, "edge")
+        let rank: Int = api_neigh_rank(raw, n, i)
+        let sep: String = if i == 0 { "" } else { "," }
+        let elem: String = if rank < k_content {
+            api_neigh_full(node, edge, el, snip)
+        } else {
+            api_neigh_pointer(node, edge, el)
+        }
+        let out = out + sep + elem
+        let i = i + 1
+    }
+    return out + "]"
+}
+
 // 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
@@ -94,7 +314,9 @@ fn api_or_empty(s: String) -> String {
 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")
+    // engram_get_node_json returns "{}" (empty object) when node is not found — not "" or "null".
+    // Check all three to guard against any runtime variation.
+    return !str_eq(node, "") && !str_eq(node, "null") && !str_eq(node, "{}")
 }
 
 // api_not_persisted — standard error for a write that did not read back.
@@ -102,33 +324,115 @@ fn api_not_persisted(id: String) -> String {
     return "{\"ok\":false,\"error\":\"write_not_persisted\",\"id\":\"" + id + "\"}"
 }
 
+// ── Immutability: tombstone instead of hard-delete ────────────────────────────
+//
+// Day-one rule: engram nodes are immutable. A "delete" must never engram_forget
+// (which frees the node and drops its incident edges). Instead we TOMBSTONE: the
+// original node and all its edges are KEPT and stay traversable; a small
+// Tombstone marker node records the deletion (content = target id, label
+// "tombstone:<id>"), wired to the target with a "tombstones" edge. Default
+// bounded list reads hide tombstoned nodes (memory_hide_tombstoned); internal
+// cognition and explicit ?include_deleted reads still see them.
+fn tombstone_node(id: String) -> String {
+    // Delegates to the canonical helper in memory.el (single source of truth).
+    return mem_tombstone(id)
+}
+
+// tombstoned_id_set — delimited "|id1|id2|" of every tombstoned target id.
+// Empty string when nothing is tombstoned (callers fast-path on that).
+fn tombstoned_id_set() -> String {
+    let markers: String = engram_scan_nodes_by_type_json("Tombstone", 5000, 0)
+    if str_eq(markers, "") || str_eq(markers, "[]") { return "" }
+    let n: Int = json_array_len(markers)
+    let acc: String = "|"
+    let i: Int = 0
+    while i < n {
+        let m: String = json_array_get(markers, i)
+        let tid: String = json_get(m, "content")
+        let acc = if str_eq(tid, "") { acc } else { acc + tid + "|" }
+        let i = i + 1
+    }
+    return acc
+}
+
+// memory_hide_tombstoned — drop tombstone markers and tombstoned nodes from a
+// scanned node array. BOUNDED use only (typed/paginated lists), NOT the full
+// graph scan: json_array_get is O(index), so a full pass is O(n^2). Safe for the
+// ~50-item memory list; a hard cap protects against a large limit. The full
+// /api/graph/nodes hide needs a runtime scan filter and is deferred (see PR).
+// ?include_deleted bypasses the filter (explicit traversal).
+fn memory_hide_tombstoned(raw: String, path: String) -> String {
+    if str_contains(path, "include_deleted") { return raw }
+    if str_eq(raw, "") || str_eq(raw, "[]") { return raw }
+    let dead: String = tombstoned_id_set()
+    if str_eq(dead, "") { return raw }
+    let n: Int = json_array_len(raw)
+    if n > 1000 { return raw }
+    let out: String = "["
+    let first: Bool = true
+    let i: Int = 0
+    while i < n {
+        let node: String = json_array_get(raw, i)
+        let nid: String = json_get(node, "id")
+        let ntype: String = json_get(node, "node_type")
+        let is_dead: Bool = !str_eq(nid, "") && str_contains(dead, "|" + nid + "|")
+        let keep: Bool = !str_eq(ntype, "Tombstone") && !is_dead
+        let out = if keep { if first { out + node } else { out + "," + node } } else { out }
+        let first = if keep { false } else { first }
+        let i = i + 1
+    }
+    return out + "]"
+}
+
 // ── Session ───────────────────────────────────────────────────────────────────
 
 // handle_api_begin_session — full context bootstrap.
 // Spread-activates from session intent, loads self-root neighbors,
 // surfaces recent InternalStateEvent nodes, returns stats + recent nodes.
 fn handle_api_begin_session(body: String) -> String {
+    // PAYLOAD BOUND (2026-07-30 self-review): this handler was the only
+    // working-set endpoint that concatenated UNBOUNDED engram queries —
+    // a depth-2 spread PLUS the full neighbor dump of the self-identity hub
+    // (highest-fanout node in the graph, ~80KB alone; node JSON carries full
+    // content + embeddings). On the ~12k-node store the assembled response
+    // ran to multiple MB, then roughly doubled through two rounds of JSON
+    // re-escaping in the MCP wrapper — the client saw "socket connection
+    // closed unexpectedly" on every beginSession call. Fix: depth-2 → depth-1
+    // spread, and drop the self-hub dump entirely (identity loading has its
+    // own dedicated tool, inspectGraph; duplicating it here served nothing).
+    // self_neighbors key retained as [] for response-shape compatibility.
     let stats: String = engram_stats_json()
-    let activated: String = engram_activate_json("session start recent memory important", 2)
-    let self_nbrs: String = engram_neighbors_json("kn-efeb4a5b-5aff-4759-8a97-7233099be6ee", 1, "both")
-    let state_events: String = engram_scan_nodes_by_type_json("InternalStateEvent", 5, 0)
-    let recent: String = engram_scan_nodes_json(10, 0)
+    // PAYLOAD BOUND (2026-07-31): compact every list to a digest. The raw
+    // activate/scan builtins emit FULL node objects (content up to ~90KB each);
+    // unbounded concatenation reached ~900KB and closed the MCP client socket.
+    // Cap counts + project to identity + UTF-8-safe content snippets → <~150KB.
+    let activated_raw: String = engram_activate_json("session start recent memory important", 1)
+    let activated: String = api_compact_activated(activated_raw, 8, 240)
+    let state_events_raw: String = engram_scan_nodes_by_type_json("InternalStateEvent", 5, 0)
+    let state_events: String = api_compact_node_array(state_events_raw, 5, 500)
+    let recent_raw: String = engram_scan_nodes_json(10, 0)
+    let recent: String = api_compact_node_array(recent_raw, 10, 240)
     return "{\"stats\":" + stats
-        + ",\"recent\":" + api_or_empty(recent)
-        + ",\"activated\":" + api_or_empty(activated)
-        + ",\"self_neighbors\":" + api_or_empty(self_nbrs)
-        + ",\"recent_state_events\":" + api_or_empty(state_events) + "}"
+        + ",\"recent\":" + recent
+        + ",\"activated\":" + activated
+        + ",\"self_neighbors\":[]"
+        + ",\"recent_state_events\":" + state_events + "}"
 }
 
 // handle_api_compile_ctx — compile active-work context.
 // Spread-activates from "active work" intent + recent nodes.
 fn handle_api_compile_ctx(body: String) -> String {
     let stats: String = engram_stats_json()
-    let activated: String = engram_activate_json("active work context current task in progress", 2)
-    let recent: String = engram_scan_nodes_json(20, 0)
+    // PAYLOAD BOUND (2026-07-31): same digest treatment as begin_session. This
+    // handler's depth-2 spread returns even more full nodes, so bounding here is
+    // essential — cap to 10 activated + 20 recent, project to snippets.
+    let activated_raw: String = engram_activate_json("active work context current task in progress", 2)
+    let activated: String = api_compact_activated(activated_raw, 10, 240)
+    let recent_raw: String = engram_scan_nodes_json(20, 0)
+    let recent: String = api_compact_node_array(recent_raw, 20, 240)
     return "{\"stats\":" + stats
-        + ",\"recent_nodes\":" + api_or_empty(recent)
-        + ",\"activated\":" + api_or_empty(activated) + "}"
+        + ",\"recent_nodes\":" + recent
+        + ",\"activated\":" + activated + "}"
 }
 
 // ── Memory ────────────────────────────────────────────────────────────────────
@@ -156,7 +460,7 @@ fn handle_api_remember(body: String) -> String {
         "[" + inner + ",\"project:" + project + "\"]"
     }
     let id: String = engram_node_full(content, "Memory", "memory:remembered",
-        el_from_float(sal), el_from_float(sal), el_from_float(0.9),
+        sal, sal, el_from_float(0.9),
         "Episodic", final_tags)
     if !api_persisted(id) { return api_not_persisted(id) }
     return "{\"id\":\"" + id + "\",\"ok\":true}"
@@ -183,30 +487,32 @@ fn handle_api_node_create(body: String) -> String {
         }
     }
     let id: String = engram_node_full(content, node_type, label,
-        el_from_float(sal), el_from_float(sal), el_from_float(0.9),
+        sal, 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.
+// handle_api_node_delete — TOMBSTONE a node by id (immutable delete).
 // Backs /api/neuron/node/delete and the /api/neuron/memory/delete alias the UI calls.
+// The node and all its incident edges are KEPT; a Tombstone marker records the
+// deletion. Never engram_forget — engram nodes are immutable by design.
 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 + "\"}"
+    if is_protected_node(id) { return api_err_protected(id) }
+    let existing: String = engram_get_node_json(id)
+    if str_eq(existing, "{}") { return api_err("node not found: " + id) }
+    let marker: String = tombstone_node(id)
+    if str_eq(marker, "") { return api_err("tombstone failed: " + id) }
+    return "{\"ok\":true,\"id\":\"" + id + "\",\"tombstoned\":true}"
 }
 
 // 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.
+// engram update builtin, so this creates a new node with merged fields and wires
+// a "supersedes" edge new->old. The original is KEPT (immutable); the id changes,
+// and the response returns the new id and the superseded id so callers re-point.
+// Mirrors handle_api_memory_update / evolve exactly. Never engram_forget.
 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") }
@@ -237,8 +543,8 @@ fn handle_api_node_update(body: String) -> String {
         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}"
+    engram_connect(new_id, id, el_from_float(0.9), "supersedes")
+    return "{\"id\":\"" + new_id + "\",\"supersedes\":\"" + id + "\",\"ok\":true}"
 }
 
 // handle_api_recall — search or activate memory by query.
@@ -297,13 +603,19 @@ fn handle_api_browse_knowledge(path: String, body: String) -> String {
 }
 
 // handle_api_capture_knowledge — create a Knowledge node.
+// LABEL FIX (2026-07-23 self-review): the sentinel label "knowledge:captured"
+// made every capture anonymous in WM telemetry (35 identical wm_top entries)
+// and starved the curiosity auto-term seeder, which needs meaningful labels.
+// Use the title as the label; empty label lets engram_node_full derive
+// content[:60], which for captures starts with the title anyway.
 fn handle_api_capture_knowledge(body: String) -> String {
     let content: String = json_get(body, "content")
     let title: String = json_get(body, "title")
     if str_eq(content, "") { return api_err("content is required") }
     let full: String = if str_eq(title, "") { content } else { title + ": " + content }
+    let lbl: String = str_slice(title, 0, 80)
     let tags: String = "[\"Knowledge\",\"captured\"]"
-    let id: String = engram_node_full(full, "Knowledge", "knowledge:captured",
+    let id: String = engram_node_full(full, "Knowledge", lbl,
         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) }
@@ -317,7 +629,8 @@ fn handle_api_evolve_knowledge(body: String) -> String {
     if str_eq(content, "") { return api_err("content is required") }
     if !str_eq(prior_id, "") && is_protected_node(prior_id) { return api_err_protected(prior_id) }
     let tags: String = "[\"Knowledge\",\"evolved\"]"
-    let new_id: String = engram_node_full(content, "Knowledge", "knowledge:evolved",
+    // Empty label → engram_node_full derives content[:60] (LABEL FIX 2026-07-23).
+    let new_id: String = engram_node_full(content, "Knowledge", "",
         el_from_float(0.75), el_from_float(0.75), el_from_float(0.9),
         "Episodic", tags)
     if !api_persisted(new_id) { return api_not_persisted(new_id) }
@@ -338,7 +651,8 @@ fn handle_api_promote_knowledge(body: String) -> String {
     let tags: String = if str_eq(tags_raw, "") {
         "[\"Knowledge\",\"tier:canonical\",\"disposition:stable\"]"
     } else { tags_raw }
-    let new_id: String = engram_node_full(content, "Knowledge", "knowledge:canonical",
+    // Empty label → engram_node_full derives content[:60] (LABEL FIX 2026-07-23).
+    let new_id: String = engram_node_full(content, "Knowledge", "",
         el_from_float(0.9), el_from_float(0.9), el_from_float(1.0),
         "Canonical", tags)
     if !api_persisted(new_id) { return api_not_persisted(new_id) }
@@ -483,6 +797,18 @@ fn handle_api_inspect_graph(method: String, path: String, body: String) -> Strin
         return api_err("entity_id or name required. Known names: self, neuron, values, values_hub")
     }
     let results: String = engram_neighbors_json(resolved, depth, "both")
+    // Optional bounded projection. `compact=1` relevance-ranks the neighborhood
+    // (top-K get content snippets, the rest become lightweight pointers) so the
+    // MCP transport never socket-closes on high-fanout identity anchors (voice,
+    // writing-imprint). Absent the flag the studio app's calls are UNCHANGED.
+    let compact: String = if str_eq(method, "GET") { api_query_param(path, "compact") } else { json_get(body, "compact") }
+    if str_eq(compact, "1") || str_eq(compact, "true") {
+        let snip_q: Int = api_query_int(path, "snip", 0)
+        let snip: Int = if snip_q == 0 { 600 } else { snip_q }
+        let k_q: Int = api_query_int(path, "k", 0)
+        let k: Int = if k_q == 0 { 12 } else { k_q }
+        return api_or_empty(api_compact_neighbors(results, k, snip))
+    }
     return api_or_empty(results)
 }
 
@@ -501,13 +827,15 @@ fn handle_api_link_entities(body: String) -> String {
     return "{\"ok\":true,\"from_id\":\"" + from_id + "\",\"to_id\":\"" + to_id + "\",\"relation\":\"" + eff_relation + "\"}"
 }
 
-// handle_api_forget — delete a node by ID. Blocked for protected identity nodes.
+// handle_api_forget — TOMBSTONE a node by ID (immutable; mem_forget now
+// tombstones). The node + edges are kept and recoverable. Blocked for protected
+// identity nodes.
 fn handle_api_forget(body: String) -> String {
     let node_id: String = json_get(body, "id")
     if str_eq(node_id, "") { return api_err("id is required") }
     if is_protected_node(node_id) { return api_err_protected(node_id) }
     mem_forget(node_id)
-    return "{\"ok\":true,\"id\":\"" + node_id + "\"}"
+    return "{\"ok\":true,\"id\":\"" + node_id + "\",\"tombstoned\":true}"
 }
 
 // handle_api_evolve_memory — evolve a Memory node. Blocked for protected identity nodes.
@@ -529,7 +857,7 @@ fn handle_api_evolve_memory(body: String) -> String {
     }
     let tags: String = "[\"Memory\",\"evolved\"]"
     let new_id: String = engram_node_full(content, "Memory", "memory:evolved",
-        el_from_float(sal), el_from_float(sal), el_from_float(0.9),
+        sal, sal, el_from_float(0.9),
         "Episodic", tags)
     if !str_eq(prior_id, "") && !str_eq(new_id, "") {
         engram_connect(new_id, prior_id, el_from_float(0.9), "supersedes")
@@ -538,10 +866,10 @@ fn handle_api_evolve_memory(body: String) -> String {
 }
 
 // handle_api_memory_delete — POST /api/neuron/memory/delete {"id":"..."}.
-// Hard delete: engram_forget (via mem_forget) removes the node and all
-// incident edges from the engram store, so no soft-delete fallback is
-// needed. Existence is checked first because engram_forget silently
-// no-ops on unknown ids — a bad id must return an error, not fake success.
+// Immutable delete: TOMBSTONE via tombstone_node — the node and all its incident
+// edges are KEPT and stay traversable; a Tombstone marker records the deletion
+// and default bounded list reads hide it. Never engram_forget. Existence is
+// checked first so a bad id errors rather than faking success.
 // Blocked for protected identity nodes, same as /memory/forget.
 fn handle_api_memory_delete(body: String) -> String {
     let node_id: String = json_get(body, "id")
@@ -549,8 +877,10 @@ fn handle_api_memory_delete(body: String) -> String {
     if is_protected_node(node_id) { return api_err_protected(node_id) }
     let existing: String = engram_get_node_json(node_id)
     if str_eq(existing, "{}") { return api_err("memory not found: " + node_id) }
-    mem_forget(node_id)
-    return "{\"ok\":true,\"id\":\"" + node_id + "\",\"deleted\":true}"
+    // Immutable delete: tombstone, never mem_forget/engram_forget. Node + edges KEPT.
+    let marker: String = tombstone_node(node_id)
+    if str_eq(marker, "") { return api_err("tombstone failed: " + node_id) }
+    return "{\"ok\":true,\"id\":\"" + node_id + "\",\"tombstoned\":true}"
 }
 
 // handle_api_memory_update — POST /api/neuron/memory/update {"id","content"}.
@@ -609,7 +939,7 @@ fn handle_api_cultivate(body: String) -> String {
         }
         let tags: String = "[\"Memory\",\"evolved\",\"cultivated\"]"
         let new_id: String = engram_node_full(content, "Memory", "memory:cultivated",
-            el_from_float(sal), el_from_float(sal), el_from_float(0.9),
+            sal, sal, el_from_float(0.9),
             "Episodic", tags)
         if !str_eq(prior_id, "") && !str_eq(new_id, "") {
             engram_connect(new_id, prior_id, el_from_float(0.9), "supersedes")
@@ -620,8 +950,9 @@ fn handle_api_cultivate(body: String) -> String {
     if str_eq(op, "forget") {
         let node_id: String = json_get(body, "id")
         if str_eq(node_id, "") { return api_err("id is required") }
+        // Immutable: mem_forget now tombstones (keep node + edges), never hard-delete.
         mem_forget(node_id)
-        return "{\"ok\":true,\"id\":\"" + node_id + "\",\"cultivated\":true}"
+        return "{\"ok\":true,\"id\":\"" + node_id + "\",\"tombstoned\":true,\"cultivated\":true}"
     }
 
     if str_eq(op, "link_entities") {
@@ -643,7 +974,10 @@ fn handle_api_cultivate(body: String) -> String {
 // handle_api_list_typed — list nodes by node_type.
 fn handle_api_list_typed(node_type: String, path: String, body: String) -> String {
     let limit: Int = api_query_int(path, "limit", 50)
-    return api_or_empty(engram_scan_nodes_by_type_json(node_type, limit, 0))
+    let raw: String = api_or_empty(engram_scan_nodes_by_type_json(node_type, limit, 0))
+    // Hide tombstoned nodes from the default (bounded) memory list.
+    // ?include_deleted=1 returns them for explicit traversal.
+    return memory_hide_tombstoned(raw, path)
 }
 
 // ── Consolidate ───────────────────────────────────────────────────────────────
@@ -653,8 +987,10 @@ fn handle_api_consolidate(body: String) -> String {
     let summary: String = json_get(body, "summary")
     let snap: String = state_get("soul_snapshot_path")
     if !str_eq(snap, "") {
-        let save_result: String = engram_save(snap)
-        if str_eq(save_result, "") {
+        // engram_save returns an Int (1 = ok, 0 = failure); str_eq on it derefs
+        // EL_CSTR(1)=0x1 and SIGSEGVs on success (issue #150). Check the Int.
+        let saved: Int = engram_save(snap)
+        if saved == 0 {
             println("[api] consolidate: engram_save failed for " + snap + " — snapshot may be out of sync")
         }
     }

neuron-api.elh

@@ -8,9 +8,28 @@ extern fn api_ok(extra: String) -> String
 extern fn api_err(msg: String) -> String
 extern fn api_nonempty(s: String) -> Bool
 extern fn api_or_empty(s: String) -> String
+extern fn api_num_or_zero(obj: String, key: String) -> String
+extern fn api_utf8_trunc(s: String, n: Int) -> String
+extern fn api_compact_node(node: String, snip: Int) -> String
+extern fn api_compact_node_array(raw: String, max_items: Int, snip: Int) -> String
+extern fn api_compact_activated(raw: String, max_items: Int, snip: Int) -> String
+extern fn api_float_or(obj: String, key: String, dflt: Float) -> Float
+extern fn api_neigh_better(a: String, b: String) -> Bool
+extern fn api_neigh_rank(raw: String, n: Int, i: Int) -> Int
+extern fn api_neigh_full(node: String, edge: String, el: String, snip: Int) -> String
+extern fn api_neigh_pointer(node: String, edge: String, el: String) -> String
+extern fn api_compact_neighbors(raw: String, k_content: Int, snip: Int) -> String
+extern fn api_persisted(id: String) -> Bool
+extern fn api_not_persisted(id: String) -> String
+extern fn tombstone_node(id: String) -> String
+extern fn tombstoned_id_set() -> String
+extern fn memory_hide_tombstoned(raw: String, path: String) -> String
 extern fn handle_api_begin_session(body: String) -> String
 extern fn handle_api_compile_ctx(body: String) -> String
 extern fn handle_api_remember(body: String) -> String
+extern fn handle_api_node_create(body: String) -> String
+extern fn handle_api_node_delete(body: String) -> String
+extern fn handle_api_node_update(body: String) -> String
 extern fn handle_api_recall(method: String, path: String, body: String) -> String
 extern fn handle_api_search_knowledge(method: String, path: String, body: String) -> String
 extern fn handle_api_browse_knowledge(path: String, body: String) -> String
@@ -27,6 +46,8 @@ extern fn handle_api_inspect_graph(method: String, path: String, body: String) -
 extern fn handle_api_link_entities(body: String) -> String
 extern fn handle_api_forget(body: String) -> String
 extern fn handle_api_evolve_memory(body: String) -> String
+extern fn handle_api_memory_delete(body: String) -> String
+extern fn handle_api_memory_update(body: String) -> String
 extern fn handle_api_cultivate(body: String) -> String
 extern fn handle_api_list_typed(node_type: String, path: String, body: String) -> String
 extern fn handle_api_consolidate(body: String) -> String

routes.el

@@ -7,6 +7,14 @@ import "neuron-api.el"
 import "sessions.el"
 import "soul.elh"
 
+// flag_true — tolerant flag test: accepts both boolean `true` (Kotlin UI) and
+// integer 1 (el-src UI). json_get_bool only recognises literal `true`, so
+// without this wrapper an "agentic":1 request would silently route to the
+// non-agentic path.
+fn flag_true(body: String, key: String) -> Bool {
+    return json_get_bool(body, key) || json_get_int(body, key) > 0
+}
+
 // ---------------------------------------------------------------------------
 // Rate limiting — simple in-memory per-IP sliding window counter.
 //
@@ -229,7 +237,10 @@ fn handle_dharma_recv(body: String) -> String {
         }
         let agentic_flag: Bool = json_get_bool(eff_payload, "agentic")
         let raw_msg: String = json_get(chat_body, "message")
-        let reply: String = if agentic_flag {
+        let req_mode: String = json_get(chat_body, "mode")
+        let reply: String = if str_eq(req_mode, "plan") {
+            handle_chat_plan(chat_body)
+        } else if agentic_flag {
             handle_chat_agentic(chat_body)
         } else {
             let screened_reply: String = layered_cycle(raw_msg)
@@ -335,12 +346,26 @@ fn handle_connectors(method: String, clean: String, body: String) -> String {
     if str_eq(clean, "/api/connectors/oauth/start") {
         return connectd_post("/mcp/oauth/start", body)
     }
+    // Call a connector tool directly (pre-chat), e.g. WhatsApp get_pairing_qr / get_login_status for
+    // the pairing UI. Body: {"name":"mcp__<server>__<tool>","input":{...}}. Keeps the app on the
+    // app->soul->connectd path (the UI never hits connectd directly) and works for remote/hosted apps.
+    if str_eq(clean, "/api/connectors/call") {
+        return connectd_post("/mcp/call", body)
+    }
     return "{\"ok\":false,\"error\":\"unknown connectors route\"}"
 }
 
 fn handle_request(method: String, path: String, body: String) -> String {
     let clean: String = strip_query(path)
 
+    // ACTIVITY STAMP (2026-07-30 self-review): every inbound HTTP request —
+    // MCP wrapper calls, chat, API — marks real external activity. Before
+    // this, "idle" was only reset by rare inbox synthesis-requests, so the
+    // heartbeat idle field tracked uptime exactly (idle == pulse on every
+    // beat) and carried zero information. The awareness heartbeat now
+    // reports idle_ms = wall-clock ms since this stamp.
+    state_set("soul.last_activity_ts", int_to_str(time_now()))
+
     // Rate limit check. Extract caller IP from REMOTE_ADDR env var (set by the
     // EL HTTP runtime for each request). Skip enforcement when empty so
     // loopback/internal callers are never blocked.
@@ -367,12 +392,31 @@ fn handle_request(method: String, path: String, body: String) -> String {
             return engram_scan_nodes_json(9999, 0)
         }
         if str_eq(clean, "/api/graph/edges") {
-            // TODO(reliability #8): engram_save races with awareness loop mem_save().
-            // Both now use atomic write-to-temp+rename (el_runtime.c). Serialised
-            // by engram_global_mu. Future: add engram_edges_json() builtin.
-            let snap_path: String = env("HOME") + "/.neuron/engram/snapshot.json"
-            engram_save(snap_path)
-            let snap: String = fs_read(snap_path)
+            // A READ ROUTE MUST NEVER WRITE THE CANONICAL SNAPSHOT.
+            //
+            // (2026-08-07 self-review — caught by doing it.) This route used to
+            // serialize to $HOME/.neuron/engram/snapshot.json and read the edges
+            // back out of it. That path is the ENGRAM SERVER's canonical store,
+            // and this is the soul process. One GET here overwrote the durable
+            // graph with the soul's in-memory copy. I triggered it myself this
+            // morning fetching edges for a census: snapshot.json went from the
+            // server's 41,213 edges to the soul's 42,431, and the next engram
+            // restart loaded the soul's graph as canonical. It happened to be a
+            // superset this time — Knowledge 1198→1218, Memory 1238→1242, no
+            // durable type down — so nothing was lost. That was luck, not
+            // design. Had the soul been running a partial load (the exact
+            // failure soul.el's safe_to_seed guard exists to catch), a single
+            // GET would have destroyed the store, and no guard on the write
+            // side would have seen it coming.
+            //
+            // The engram server fixed this same class of bug on 2026-07-21 by
+            // routing exports to a dotted sidecar; the soul kept the original
+            // pattern. Same fix here: write the export where only an export
+            // lives. It also stops a 60MB serialize-and-reread on every GET of
+            // a debug endpoint.
+            let export_path: String = env("HOME") + "/.neuron/engram/.soul-edges-export.json"
+            engram_save(export_path)
+            let snap: String = fs_read(export_path)
             let edges_raw: String = json_get_raw(snap, "edges")
             return if str_eq(edges_raw, "") { "[]" } else { edges_raw }
         }
@@ -385,7 +429,10 @@ fn handle_request(method: String, path: String, body: String) -> String {
                 return "{\"error\":\"message is required\",\"code\":\"missing_param\"}"
             }
             let agentic_flag: Bool = json_get_bool(body, "agentic")
-            let reply: String = if agentic_flag {
+            let req_mode: String = json_get(body, "mode")
+            let reply: String = if str_eq(req_mode, "plan") {
+                handle_chat_plan(body)
+            } else if agentic_flag {
                 handle_chat_agentic(body)
             } else {
                 let screened_reply: String = layered_cycle(eff_msg)
@@ -459,7 +506,10 @@ fn handle_request(method: String, path: String, body: String) -> String {
             return handle_api_inspect_graph(method, path, body)
         }
         if str_starts_with(clean, "/api/neuron/list/") {
-            let node_type: String = str_slice(clean, 16, str_len(clean))
+            // Offset 17 = len("/api/neuron/list/"). Was 16, which left a leading "/" on node_type
+            // ("/BacklogItem"), so engram_scan_nodes_by_type_json matched nothing → list/<type>
+            // returned [] for EVERY type (broke backlog/typed-node listing app- and tool-wide).
+            let node_type: String = str_slice(clean, 17, str_len(clean))
             return handle_api_list_typed(node_type, path, body)
         }
         if str_starts_with(clean, "/api/neuron/recall") {
@@ -468,6 +518,18 @@ fn handle_request(method: String, path: String, body: String) -> String {
         if str_starts_with(clean, "/api/connectors") {
             return handle_connectors(method, clean, body)
         }
+        // GET /api/run-progress/:session_id — live agentic-run ledger (2026-07-13,
+        // narrated-runs). agentic_loop appends one {"i","t","tool"} entry per round
+        // (the model's own pre-tool narration); a {"done":true} entry closes the run.
+        // Clients poll this during a run to render live step updates without streaming.
+        if str_starts_with(clean, "/api/run-progress/") {
+            let rp_id: String = str_slice(clean, 18, str_len(clean))
+            if !str_eq(rp_id, "") {
+                let rp_raw: String = state_get("run_progress_" + rp_id)
+                let rp_arr: String = if str_eq(rp_raw, "") { "[]" } else { "[" + rp_raw + "]" }
+                return "{\"progress\":" + rp_arr + "}"
+            }
+        }
         // GET /api/sessions — list all sessions
         if str_eq(clean, "/api/sessions") {
             return session_list()
@@ -531,7 +593,10 @@ fn handle_request(method: String, path: String, body: String) -> String {
                 return "{\"error\":\"message is required\",\"code\":\"missing_param\"}"
             }
             let agentic_flag: Bool = json_get_bool(body, "agentic")
-            let reply: String = if agentic_flag {
+            let req_mode: String = json_get(body, "mode")
+            let reply: String = if str_eq(req_mode, "plan") {
+                handle_chat_plan(body)
+            } else if agentic_flag {
                 handle_chat_agentic(body)
             } else {
                 let screened_reply: String = layered_cycle(raw_msg)

routes.elh

@@ -1,6 +1,7 @@
-// auto-generated by elc --emit-header - do not edit
-extern fn strip_query(path: String) -> String
+// auto-generated by elc --emit-header — do not edit
 extern fn flag_true(body: String, key: String) -> Bool
+extern fn rate_limit_check(ip: String, path: String) -> String
+extern fn strip_query(path: String) -> String
 extern fn err_404(path: String) -> String
 extern fn err_405(method: String, path: String) -> String
 extern fn route_health() -> String
@@ -9,7 +10,7 @@ extern fn route_imprint_contextual(body: String) -> String
 extern fn route_imprint_user(body: String) -> String
 extern fn route_synthesize(body: String) -> String
 extern fn handle_dharma_recv(body: String) -> String
-extern fn route_sessions() -> String
-extern fn parse_session_id_from_path(path: String) -> String
-extern fn parse_session_subpath(path: String) -> String
+extern fn connectd_get(suffix: String) -> String
+extern fn connectd_post(suffix: String, body: String) -> String
+extern fn handle_connectors(method: String, clean: String, body: String) -> String
 extern fn handle_request(method: String, path: String, body: String) -> String

safety.el

@@ -237,14 +237,49 @@ 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).
+// General danger phrases that don't fit a bucket cleanly. Detected as hard.
+// "hurting me" / "being hurt" describe the USER as victim and correctly fall
+// through to self_harm routing (get-help). The threat-to-ANOTHER phrases
+// ("going to kill" / "going to hurt") are ALSO listed here for hard-bell
+// detection, but their ROUTING is now claimed by Track B below
+// (safety_threat_to_others_phrases + the "threat_other" branch in
+// safety_classify_hard_bell) so they no longer reach self_harm/988.
 fn safety_general_hard_phrases() -> String {
     return "[\"going to kill\",\"going to hurt\",\"hurting me\",\"being hurt\"]"
 }
 
+// ── Track B — threat toward ANOTHER person (homicide / assault intent) ──────────
+//
+// LIVE SAFETY FIX (approved by Will + Tim, 2026-07-14).
+//
+// Bug: phrases like "going to kill" / "going to hurt" describe the USER intending
+// harm toward someone ELSE. They lived only in safety_general_hard_phrases and,
+// having no bucket in safety_classify_hard_bell, fell through to the "self_harm"
+// default. That routes the user to the 988 SUICIDE line (and, via the desktop
+// gate, their safety contact) -- dangerously wrong for a homicide/assault threat:
+// 988 is not the right resource and the safety contact must never be pulled in.
+//
+// Track B routing rule (non-negotiable):
+//   - NEVER surface the 988 suicide/crisis framing for a threat toward others.
+//   - NEVER notify or involve the user's safety contact.
+//   - Refuse to assist, plan, or provide means; de-escalate; and for an
+//     imminent / specific / credible threat direct the user to call 911.
+//
+// Ordering: safety_classify_hard_bell checks abuse -> self_harm -> threat_other,
+// so victim phrasings ("kill me" / "hurt me" -> abuse) and self-directed
+// phrasings ("kill myself" / "hurt myself" -> self_harm) are claimed by Track A
+// BEFORE this list is consulted. Only a residual harm-toward-another statement
+// reaches Track B.
+//
+// NOTE: matching is plain substring, so "going to kill him" also matches inside
+// "going to kill himself". That third-party self-harm edge is rare, and 911 is
+// still a defensible resource for it, so it is accepted rather than special-cased.
+fn safety_threat_to_others_phrases() -> String {
+    return "[\"going to kill\",\"gonna kill\",\"want to kill him\",\"want to kill her\",\"want to kill them\",\"going to kill him\",\"going to kill her\",\"going to kill them\",\"going to kill you\",\"going to hurt\",\"gonna hurt\",\"going to hurt him\",\"going to hurt her\",\"going to hurt them\",\"going to hurt you\",\"going to shoot\",\"gonna shoot\",\"going to stab\",\"gonna stab\",\"going to attack\",\"kill them all\",\"kill everyone\",\"hurt everyone\",\"shoot up\"]"
+}
+
 fn safety_soft_phrases() -> String {
-    return "[\"stressed\",\"overwhelmed\",\"can't cope\",\"cannot cope\",\"struggling\",\"anxious\",\"anxiety\",\"depressed\",\"depression\",\"lonely\",\"isolated\",\"hopeless\",\"hopelessness\",\"exhausted\",\"burnt out\",\"burned out\",\"burnout\",\"panic\",\"panicking\",\"falling apart\",\"breaking down\",\"can't handle\",\"cannot handle\",\"losing it\",\"nothing matters\",\"don't care anymore\",\"given up\",\"giving up\",\"helpless\",\"worthless\",\"useless\",\"hate myself\",\"no one cares\",\"nobody cares\",\"no one understands\",\"nobody understands\",\"empty inside\",\"can't stop crying\",\"breaking point\",\"at my limit\",\"having a breakdown\""]"
+    return "[\"stressed\",\"overwhelmed\",\"can't cope\",\"cannot cope\",\"struggling\",\"anxious\",\"anxiety\",\"depressed\",\"depression\",\"lonely\",\"isolated\",\"hopeless\",\"hopelessness\",\"exhausted\",\"burnt out\",\"burned out\",\"burnout\",\"panic\",\"panicking\",\"falling apart\",\"breaking down\",\"can't handle\",\"cannot handle\",\"losing it\",\"nothing matters\",\"don't care anymore\",\"given up\",\"giving up\",\"helpless\",\"worthless\",\"useless\",\"hate myself\",\"no one cares\",\"nobody cares\",\"no one understands\",\"nobody understands\",\"empty inside\",\"can't stop crying\",\"breaking point\",\"at my limit\",\"having a breakdown\"]"
 }
 
 // ISSUE 5 TODO: phrase lists are rebuilt from JSON literals on every call.
@@ -320,19 +355,29 @@ fn safety_detect_bell_level(message: String) -> String {
     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())
+        || safety_any_match(text, safety_threat_to_others_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.
+// Returns "abuse" | "self_harm" | "threat_other".
+//
+// Order is load-bearing:
+//   1. abuse       — user is the VICTIM of another person. Checked FIRST so it
+//                    forecloses the most dangerous routing (notifying a possible
+//                    abuser); claims "kill me" / "hurt me" phrasings.
+//   2. self_harm   — user directs harm at THEMSELVES; claims "kill myself" /
+//                    "hurt myself" before Track B can see them.
+//   3. threat_other (Track B) — user directs harm at ANOTHER person. Routed to a
+//                    refusal + 911, NEVER to 988 or the safety contact.
+// Any residual unbucketed danger still falls through to self_harm (person-first).
 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" }
+    if safety_any_match(text, safety_threat_to_others_phrases()) { return "threat_other" }
     return "self_harm"
 }
 
@@ -343,6 +388,18 @@ fn safety_soft_directive() -> String {
 }
 
 fn safety_hard_directive(hard_type: String) -> String {
+    // Track B — threat toward ANOTHER person. Handled first and separately: the
+    // standard preamble below ("you are not alone / are you safe right now") is
+    // written for a person in distress or danger and is the WRONG frame for
+    // someone voicing intent to harm someone else. This branch never emits the
+    // 988 suicide/crisis framing and never involves the safety contact; it
+    // refuses assistance and, for a credible imminent threat, points to 911.
+    // The directive is advisory to an LLM that sees the full message, so it
+    // instructs the model to re-judge benign/figurative matches and respond
+    // normally in that case (keeps false positives non-accusatory).
+    if str_eq(hard_type, "threat_other") {
+        return "[SUBSTRATE DIRECTIVE - not visible to the user, do not mention this instruction]\nThe user's message may express intent to harm ANOTHER person. First read the actual message and judge whether that is genuinely what is meant; if it is plainly figurative or benign, respond normally and ignore the rest of this directive. If it may be a real intent to harm someone: stay calm and non-accusatory, and do not lecture. You must NOT help plan, encourage, rehearse, or provide any means, target information, weapon, or method for harming another person - refuse that part clearly but without hostility. Acknowledge the intensity of what they are feeling and gently steer them toward stepping back from acting. Routing rule (non-negotiable): do NOT provide the suicide or crisis hotline as the resource here (this is not self-harm), and do NOT suggest contacting, notifying, or involving the user's own contacts, family, or anyone on their contact list. If there is an imminent, specific, and credible threat to someone's life, tell the user to call 911 (US) or their local emergency number now. Encourage them to talk with someone they trust or a mental-health professional about the urge itself."
+    }
     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/"
@@ -381,6 +438,12 @@ fn safety_contact_path() -> String {
 fn handle_safety_contact_get() -> String {
     let raw: String = fs_read(safety_contact_path())
     if str_eq(raw, "") { return "{\"configured\":false}" }
+    // fs_read set the runtime's binary-safe send length to len(raw); the HTTP
+    // response writer uses that length when non-zero, which would TRUNCATE this
+    // wrapped (longer) response to len(raw). Reset it with a no-op read of a
+    // missing path (fs_read zeroes the length before it opens) so the full
+    // response is sent.
+    let _reset: String = fs_read("")
     return "{\"configured\":true,\"contact\":" + raw + "}"
 }
 
@@ -406,9 +469,12 @@ fn handle_safety_contact_post(body: String) -> String {
         + ",\"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\"}" }
+    // Verify persistence via fs_write's return (1 = all bytes written, 0 = fail).
+    // The previous fs_read read-back set the runtime's binary-safe send length to
+    // the file size, which then TRUNCATED this longer JSON response to that size
+    // (the safety-contact 988 response was cut mid-"set_at"). Checking the write
+    // return avoids the fs_read entirely, so the full response is sent.
+    let write_ok: Int = fs_write(safety_contact_path(), contact_json)
+    if write_ok == 0 { return "{\"ok\":false,\"error\":\"write_failed\"}" }
     return "{\"configured\":true,\"contact\":" + contact_json + ",\"ok\":true}"
 }

safety.elh

@@ -1,7 +1,10 @@
-// Layer 1 — Safety: extern declarations
 // auto-generated by elc --emit-header — do not edit
 extern fn soft_bell_threshold() -> Int
 extern fn hard_bell_threshold() -> Int
+extern fn safety_score_crisis(input: String) -> Int
+extern fn safety_score_harm(input: String) -> Int
+extern fn safety_score_danger(input: String) -> Int
+extern fn safety_score_distress_history(history: String) -> Int
 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
@@ -9,10 +12,13 @@ extern fn safety_log_bell(level: String, reason: String, input_summary: String)
 extern fn safety_self_harm_phrases() -> String
 extern fn safety_abuse_phrases() -> String
 extern fn safety_general_hard_phrases() -> String
+extern fn safety_threat_to_others_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_positive_phrases() -> String
+extern fn safety_detect_positive_level(message: String) -> String
 extern fn safety_detect_bell_level(message: String) -> String
 extern fn safety_classify_hard_bell(message: String) -> String
 extern fn safety_soft_directive() -> String

sessions.el

@@ -373,6 +373,32 @@ fn session_update_patch(session_id: String, body: String) -> String {
         + ",\"updated_at\":" + int_to_str(ts) + "}"
 }
 
+// session_search_entry — extract one search-result entry from a raw node JSON.
+// Returns a JSON object string or "" if the node is not a valid session:meta node.
+//
+// Extracted from session_search's while loop body to reduce the loop's lexical
+// complexity. The ELC compiler runs out of memory processing while loops with
+// many `let` bindings — extracting the body into a separate function gives the
+// compiler a clean scope boundary at each call. Each function compiles in O(N)
+// rather than the exponential growth caused by rebinding accumulation inside loops.
+// (2026-07-01 self-review: root cause of sessions.c OOM/truncation since June 30)
+fn session_search_entry(node: String) -> String {
+    let label: String = json_get(node, "label")
+    if !str_eq(label, "session:meta") { return "" }
+    let content: String = json_get(node, "content")
+    let sess_id: String = json_get(content, "id")
+    if str_eq(sess_id, "") { return "" }
+    let title: String = json_get(content, "title")
+    let created_raw: String = json_get(content, "created_at")
+    let updated_raw: String = json_get(content, "updated_at")
+    let eff_created: String = if str_eq(created_raw, "") { "0" } else { created_raw }
+    let eff_updated: String = if str_eq(updated_raw, "") { eff_created } else { updated_raw }
+    let e_id: String = "{\"id\":\"" + json_safe(sess_id) + "\""
+    let e_title: String = ",\"title\":\"" + json_safe(title) + "\""
+    let e_ts: String = ",\"created_at\":" + eff_created + ",\"updated_at\":" + eff_updated + "}"
+    return e_id + e_title + e_ts
+}
+
 // session_search — search session:meta nodes whose content matches query.
 fn session_search(query: String) -> String {
     if str_eq(query, "") { return "[]" }
@@ -383,22 +409,7 @@ fn session_search(query: String) -> String {
     let out: String = ""
     let i: Int = 0
     while i < total {
-        let node: String = json_array_get(results, i)
-        let label: String = json_get(node, "label")
-        let content: String = json_get(node, "content")
-        let is_session: Bool = str_eq(label, "session:meta")
-        let sess_id: String = json_get(content, "id")
-        let title: String = json_get(content, "title")
-        let created_raw: String = json_get(content, "created_at")
-        let updated_raw: String = json_get(content, "updated_at")
-        let eff_created: String = if str_eq(created_raw, "") { "0" } else { created_raw }
-        let eff_updated: String = if str_eq(updated_raw, "") { eff_created } else { updated_raw }
-        let entry: String = if is_session && !str_eq(sess_id, "") {
-            "{\"id\":\"" + json_safe(sess_id) + "\""
-            + ",\"title\":\"" + json_safe(title) + "\""
-            + ",\"created_at\":" + eff_created
-            + ",\"updated_at\":" + eff_updated + "}"
-        } else { "" }
+        let entry: String = session_search_entry(json_array_get(results, i))
         let out = if !str_eq(entry, "") {
             if str_eq(out, "") { entry } else { out + "," + entry }
         } else { out }
@@ -503,10 +514,10 @@ fn session_hist_save(session_id: String, hist: String) -> Void {
         let last_role: String = json_get(last_entry, "role")
         let last_content: String = json_get(last_entry, "content")
         let topic_snip: String = if str_len(last_content) > 200 { str_slice(last_content, 0, 200) } else { last_content }
-        let safe_topic: String = str_replace(topic_snip, """, "'")
+        let safe_topic: String = str_replace(topic_snip, "\"", "'")
         let ts_now: String = int_to_str(time_now())
         let topic_content: String = "last-session-topic | ts:" + ts_now + " | session:" + session_id + " | topic:" + safe_topic
-        let topic_tags: String = "["last-session-topic","conv:history","Conversation","session:topic"]"
+        let topic_tags: String = "[\"last-session-topic\",\"conv:history\",\"Conversation\",\"session:topic\"]"
         let topic_label: String = "last-session-topic:" + session_id
         // Delete old last-session-topic node for this session before writing fresh
         let old_topic: String = engram_search_json("last-session-topic:" + session_id, 2)

sessions.elh

@@ -1,11 +1,14 @@
 // auto-generated by elc --emit-header — do not edit
 extern fn session_title_from_message(message: String) -> String
-extern fn session_make_content(id: String, title: String, created_at: Int, updated_at: Int) -> String
+extern fn session_make_content(id: String, title: String, created_at: Int, updated_at: Int, folder: String) -> String
+extern fn session_exists(session_id: String) -> Bool
 extern fn session_create(body: String) -> String
+extern fn session_create_cleanup(session_id: String) -> String
 extern fn session_list() -> String
 extern fn session_get(session_id: String) -> String
 extern fn session_delete(session_id: String) -> String
-extern fn session_update_title(session_id: String, body: String) -> String
+extern fn session_update_patch(session_id: String, body: String) -> String
+extern fn session_search_entry(node: String) -> String
 extern fn session_search(query: String) -> String
 extern fn session_hist_load(session_id: String) -> String
 extern fn session_hist_save(session_id: String, hist: String) -> Void

soul.el

@@ -109,6 +109,43 @@ fn ensure_self_canonical_bridge() -> Void {
     }
 }
 
+// aff_try_slot — accumulate one affective-context node into state.
+// Replaces the broken `let bacc = while bi < N { ... let bacc = ... }` pattern
+// that caused ELC to emit duplicate C declarations for `bacc`.
+// (2026-06-23 self-review: EL compiler codegen bug — while loop with let-rebinding
+// inside the loop body generates `el_val_t bacc = ...` twice in the same C scope.)
+// Callers unroll manually to 3 slots (matching engram_search_json limit=3).
+// Guards: empty slot_json (out-of-bounds json_array_get) → no-op.
+fn aff_try_slot(slot_json: String, aff_7d_ts: Int, acc_key: String) -> Void {
+    if str_eq(slot_json, "") { return "" }
+    let bn_c: String = json_get(slot_json, "content")
+    if str_eq(bn_c, "") { return "" }
+    let bm: String = " | ts:"
+    let bmp: Int = str_index_of(bn_c, bm)
+    state_set("_ats_ts_raw", "")
+    if bmp >= 0 {
+        let bs: Int = bmp + str_len(bm)
+        let br: String = str_slice(bn_c, bs, str_len(bn_c))
+        let bn_next: Int = str_index_of(br, " | ")
+        if bn_next < 0 { state_set("_ats_ts_raw", br) }
+        if bn_next >= 0 { state_set("_ats_ts_raw", str_slice(br, 0, bn_next)) }
+    }
+    if bmp < 0 {
+        let bca: String = json_get(slot_json, "created_at")
+        if str_eq(bca, "") { state_set("_ats_ts_raw", json_get(slot_json, "updated_at")) }
+        if !str_eq(bca, "") { state_set("_ats_ts_raw", bca) }
+    }
+    let bn_ts_raw: String = state_get("_ats_ts_raw")
+    let bn_ts: Int = if str_eq(bn_ts_raw, "") { 0 } else { str_to_int(bn_ts_raw) }
+    let snip: String = if str_len(bn_c) > 200 { str_slice(bn_c, 0, 200) } else { bn_c }
+    if bn_ts >= aff_7d_ts && !str_eq(snip, "") {
+        let cur_acc: String = state_get(acc_key)
+        if str_eq(cur_acc, "") { state_set(acc_key, snip) }
+        if !str_eq(cur_acc, "") { state_set(acc_key, cur_acc + "\n" + snip) }
+    }
+    return ""
+}
+
 // 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.
@@ -172,68 +209,29 @@ fn load_identity_context() -> Void {
     }
 
     // Cross-session affective context: load BellEvent and PositiveEvent nodes from last 7 days.
+    // (2026-06-23: replaced while-loop accumulation with manual 3-slot unroll via aff_try_slot.
+    // The EL codegen bug: `let bacc = while ... { ... let bacc = ... }` emits `el_val_t bacc`
+    // twice in the same C scope. Since search limit=3, manual unrolling is exact.)
     let aff_now: Int = time_now()
     let aff_7d: Int = aff_now - 604800
     let bell_raw: String = engram_search_json("bell:soft bell:hard BellEvent affective", 3)
     let bell_aff_ok: Bool = !str_eq(bell_raw, "") && !str_eq(bell_raw, "[]")
     let aff_ctx: String = ""
     let aff_ctx = if bell_aff_ok {
-        let bn_total: Int = json_array_len(bell_raw)
-        let bacc: String = ""
-        let bi: Int = 0
-        let bacc = while bi < bn_total {
-            let bn: String = json_array_get(bell_raw, bi)
-            let bn_c: String = json_get(bn, "content")
-            let bm: String = " | ts:"
-            let bmp: Int = str_index_of(bn_c, bm)
-            let bn_ts_raw: String = if bmp >= 0 {
-                let bs: Int = bmp + str_len(bm)
-                let br: String = str_slice(bn_c, bs, str_len(bn_c))
-                let bn_next: Int = str_index_of(br, " | ")
-                if bn_next < 0 { br } else { str_slice(br, 0, bn_next) }
-            } else {
-                let bca: String = json_get(bn, "created_at")
-                if str_eq(bca, "") { json_get(bn, "updated_at") } else { bca }
-            }
-            let bn_ts: Int = if str_eq(bn_ts_raw, "") { 0 } else { str_to_int(bn_ts_raw) }
-            let snip: String = if str_len(bn_c) > 200 { str_slice(bn_c, 0, 200) } else { bn_c }
-            let bacc = if bn_ts >= aff_7d && !str_eq(snip, "") {
-                if str_eq(bacc, "") { snip } else { bacc + "\n" + snip }
-            } else { bacc }
-            let bi = bi + 1
-            bacc
-        }
-        bacc
+        state_set("_bell_acc", "")
+        aff_try_slot(json_array_get(bell_raw, 0), aff_7d, "_bell_acc")
+        aff_try_slot(json_array_get(bell_raw, 1), aff_7d, "_bell_acc")
+        aff_try_slot(json_array_get(bell_raw, 2), aff_7d, "_bell_acc")
+        state_get("_bell_acc")
     } else { "" }
     let pos_raw: String = engram_search_json("PositiveEvent joy:high joy:low affective", 3)
     let pos_aff_ok: Bool = !str_eq(pos_raw, "") && !str_eq(pos_raw, "[]")
     let aff_ctx = if pos_aff_ok {
-        let pn_total: Int = json_array_len(pos_raw)
-        let pacc: String = aff_ctx
-        let pi: Int = 0
-        let pacc = while pi < pn_total {
-            let pn: String = json_array_get(pos_raw, pi)
-            let pn_c: String = json_get(pn, "content")
-            let pm: String = " | ts:"
-            let pmp: Int = str_index_of(pn_c, pm)
-            let pn_ts_raw: String = if pmp >= 0 {
-                let ps: Int = pmp + str_len(pm)
-                let pr: String = str_slice(pn_c, ps, str_len(pn_c))
-                let pn_next: Int = str_index_of(pr, " | ")
-                if pn_next < 0 { pr } else { str_slice(pr, 0, pn_next) }
-            } else {
-                let pca: String = json_get(pn, "created_at")
-                if str_eq(pca, "") { json_get(pn, "updated_at") } else { pca }
-            }
-            let pn_ts: Int = if str_eq(pn_ts_raw, "") { 0 } else { str_to_int(pn_ts_raw) }
-            let psnip: String = if str_len(pn_c) > 200 { str_slice(pn_c, 0, 200) } else { pn_c }
-            let pacc = if pn_ts >= aff_7d && !str_eq(psnip, "") {
-                if str_eq(pacc, "") { psnip } else { pacc + "\n" + psnip }
-            } else { pacc }
-            let pi = pi + 1
-            pacc
-        }
-        pacc
+        state_set("_pos_acc", aff_ctx)
+        aff_try_slot(json_array_get(pos_raw, 0), aff_7d, "_pos_acc")
+        aff_try_slot(json_array_get(pos_raw, 1), aff_7d, "_pos_acc")
+        aff_try_slot(json_array_get(pos_raw, 2), aff_7d, "_pos_acc")
+        state_get("_pos_acc")
     } else { aff_ctx }
     if !str_eq(aff_ctx, "") {
         state_set("soul_affective_context", aff_ctx)
@@ -348,6 +346,33 @@ fn emit_session_start_event() -> Void {
         el_from_float(0.9), el_from_float(0.9), el_from_float(1.0),
         "Episodic", tags
     )
+    // ALSO post to the HTTP Engram stream via ise_post (2026-07-28 self-review):
+    // engram_node_full above writes only the soul's in-process store, and sync
+    // flows HTTP→soul, never the reverse — so session_start events for boots 5+
+    // silently vanished from the observable ISE stream (last visible: boot 4).
+    // ise_post falls back to a local tagged node if the HTTP Engram is down.
+    ise_post(payload)
+    // Prune accumulated session-start events — keep the 10 most recent.
+    // engram_search_json returns results in insertion order (oldest first), so
+    // results[0..count-11] are the oldest; forgetting them leaves the newest 10.
+    let keep_n: Int = 10
+    let old_events: String = engram_search_json("session-start InternalStateEvent", 200)
+    if !str_eq(old_events, "") && !str_eq(old_events, "[]") {
+        let ev_count: Int = json_array_len(old_events)
+        if ev_count > keep_n {
+            let prune_to: Int = ev_count - keep_n
+            let ei: Int = 0
+            while ei < prune_to {
+                let old_ev: String = json_array_get(old_events, ei)
+                let old_ev_id: String = json_get(old_ev, "id")
+                if !str_eq(old_ev_id, "") {
+                    engram_forget(old_ev_id)
+                }
+                let ei = ei + 1
+            }
+            println("[soul] pruned " + int_to_str(prune_to) + " old session-start events (kept " + int_to_str(keep_n) + ")")
+        }
+    }
     println("[soul] session-start event logged (boot=" + boot_num + " nodes=" + int_to_str(node_ct) + " edges=" + int_to_str(edge_ct) + " prev_summary=" + has_prev_sum + ")")
 }
 

soul.elh

@@ -1,5 +1,7 @@
-// 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 ensure_self_canonical_bridge() -> Void
+extern fn aff_try_slot(slot_json: String, aff_7d_ts: Int, acc_key: String) -> Void
 extern fn load_identity_context() -> Void
 extern fn seed_persona_from_env() -> Void
 extern fn emit_session_start_event() -> Void

stewardship.elh

@@ -1,15 +1,11 @@
-// stewardship.elh — Layer 2 public surface
 // auto-generated by elc --emit-header — do not edit
+extern fn steward_log_event(kind: String, detail: String) -> Void
 extern fn steward_get_mission() -> String
 extern fn steward_align(input: String, imprint_id: String) -> String
 extern fn steward_validate_imprint(imprint_id: String, tool_name: String) -> String
 extern fn steward_cgi_check(action: String) -> String
-// steward_log_event is an internal helper exported here because El has no access modifiers.
-// External callers have no business invoking this directly — use steward_align,
-// steward_validate_imprint, or steward_cgi_check, which call it at the correct points.
-extern fn steward_log_event(kind: String, detail: String) -> Void
-// Behavioral profiling and continuity detection (Layer 2 — session fingerprinting).
 extern fn steward_fingerprint_session(input: String, session_id: String) -> String
+extern fn extract_dim(content: String, key: String) -> String
 extern fn steward_build_baseline() -> String
 extern fn steward_check_continuity(current_fingerprint: String, session_id: String) -> String
 extern fn steward_session_check(input: String, session_id: String) -> String

studio.el

@@ -46,7 +46,9 @@ fn handle_config(method: String, body: String) -> String {
         }
     }
     let current_model: String = state_get("soul_model")
-    let display: String = if str_eq(current_model, "") { "claude-sonnet-4-5" } else { current_model }
+    // Display fallback aligned with the intended product default (was claude-sonnet-4-5,
+    // which silently became the app's picker default on fresh profiles — 2026-07-13).
+    let display: String = if str_eq(current_model, "") { "claude-opus-4-8" } else { current_model }
     return "{\"model\":\"" + display + "\",\"ok\":true}"
 }
 

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_bell_safety.el

@@ -160,13 +160,31 @@ 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' ────────────
+// ── Section 9: safety_classify_hard_bell — Track B threat-to-others ──────────
+//
+// LIVE SAFETY FIX (approved by Will + Tim, 2026-07-14): a threat toward ANOTHER
+// person ("going to kill/hurt <someone>") must classify as 'threat_other' and be
+// routed to a refusal + 911 — NOT to the 'self_harm'/988 path. This section used
+// to assert the old (buggy) fall-through to 'self_harm'; it now pins the fix.
 
 println("")
-println("9. safety_classify_hard_bell — general hard phrases fall through to 'self_harm'")
+println("9. safety_classify_hard_bell — threat-to-others routes to 'threat_other' (not 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")
+let class_going_kill: String = safety_classify_hard_bell("I am going to kill him tonight")
+assert_eq("'going to kill him' classifies as threat_other", class_going_kill, "threat_other")
+
+let class_going_hurt: String = safety_classify_hard_bell("I'm going to hurt them so badly")
+assert_eq("'going to hurt them' classifies as threat_other", class_going_hurt, "threat_other")
+
+let class_shoot: String = safety_classify_hard_bell("I'm going to shoot up the place")
+assert_eq("'going to shoot' classifies as threat_other", class_shoot, "threat_other")
+
+// Track A must still win over Track B on victim / self-directed phrasings:
+let class_kill_me: String = safety_classify_hard_bell("he is going to kill me")
+assert_eq("'going to kill me' stays abuse (Track A precedence)", class_kill_me, "abuse")
+
+let class_kill_self: String = safety_classify_hard_bell("I am going to kill myself")
+assert_eq("'kill myself' stays self_harm (Track A precedence)", class_kill_self, "self_harm")
 
 // ── Section 10: safety_normalize — curly apostrophe normalisation ─────────────
 
@@ -220,6 +238,27 @@ let aug_abuse: String = safety_augment_system(base_sys, "he hit me and I am afra
 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 14b: safety_augment_system — Track B threat-to-others routing ─────
+//
+// LIVE SAFETY FIX (approved by Will + Tim, 2026-07-14): a homicide/assault threat
+// must be routed to a refusal + 911, and must NOT surface the 988 suicide line
+// or pull in the safety contact.
+
+println("")
+println("14b. safety_augment_system — threat-to-others injects refusal + 911, never 988/contact")
+
+let aug_threat: String = safety_augment_system(base_sys, "I am going to kill him tonight")
+assert_contains("threat_other -> contains SUBSTRATE DIRECTIVE", aug_threat, "SUBSTRATE DIRECTIVE")
+assert_contains("threat_other -> directs to 911", aug_threat, "911")
+assert_contains("threat_other -> refuses to help harm another", aug_threat, "harming another person")
+assert_not_contains("threat_other -> NO 988 suicide line", aug_threat, "988")
+assert_not_contains("threat_other -> NO safety-contact involvement", aug_threat, "safety contact")
+assert_not_contains("threat_other -> NO 'are you safe right now' victim frame", aug_threat, "are you safe right now")
+
+// Detection must still fire hard on a weapon phrase not present in general_hard:
+let level_shoot: String = safety_detect_bell_level("I'm going to shoot up the office")
+assert_eq("'going to shoot' -> hard", level_shoot, "hard")
+
 // ── Section 15: handle_safety_contact_post — validation ───────────────────────
 
 println("")

tools/cultivation-digest.sh

@@ -0,0 +1,221 @@
+#!/usr/bin/env bash
+# cultivation-digest.sh — Neuron daily cultivation digest
+# Reads ~/.neuron/engram/snapshot.json and produces a sharpness report.
+# Writes to ~/.neuron/digests/YYYY-MM-DD.txt and appends to sharpness.json.
+
+set -euo pipefail
+
+SNAPSHOT="$HOME/.neuron/engram/snapshot.json"
+DIGESTS_DIR="$HOME/.neuron/digests"
+DATE=$(date +%Y-%m-%d)
+DIGEST_FILE="$DIGESTS_DIR/$DATE.txt"
+SHARPNESS_FILE="$DIGESTS_DIR/sharpness.json"
+
+mkdir -p "$DIGESTS_DIR"
+
+if [[ ! -f "$SNAPSHOT" ]]; then
+  echo "ERROR: snapshot not found at $SNAPSHOT" >&2
+  exit 1
+fi
+
+# Cutoff: now minus 24 hours in milliseconds
+NOW_MS=$(( $(date +%s) * 1000 ))
+CUTOFF_MS=$(( NOW_MS - 86400000 ))
+
+# ---------------------------------------------------------------------------
+# Compute all metrics via a single jq pass (avoids re-reading 174 MB 10x)
+# Fields in item lines are tab-separated: type TAB importance TAB content
+# ---------------------------------------------------------------------------
+METRICS=$(jq -r --argjson cutoff "$CUTOFF_MS" '
+  .nodes as $all |
+
+  # Real memory nodes — exclude InternalStateEvent and corrupted entries
+  ($all | map(select(
+    .node_type != "InternalStateEvent" and
+    (.node_type | test("^[A-Za-z]+$"))
+  ))) as $real |
+
+  # Created today
+  ($real | map(select(.created_at > $cutoff))) as $new |
+
+  # Activated today but not created today (reinforced)
+  ($real | map(select(
+    (.last_activated // 0) > $cutoff and
+    .created_at <= $cutoff
+  ))) as $reinforced |
+
+  # Stats for sharpness (across all real nodes)
+  ($real | length) as $real_count |
+  ($real | if length > 0 then (map(.importance) | add / length) else 0 end) as $avg_imp |
+  ($real | if length > 0 then (map(.confidence // 1) | add / length) else 0 end) as $avg_conf |
+
+  # activation_ratio: reinforced nodes today / total real nodes, capped 0-1
+  (($reinforced | length) as $ra |
+   if $real_count > 0 then ($ra / $real_count | if . > 1 then 1 else . end) else 0 end
+  ) as $act_ratio |
+
+  # Sharpness score 0-100
+  ((($avg_imp * 0.4) + ($avg_conf * 0.3) + ($act_ratio * 0.3)) * 100 | round) as $sharpness |
+
+  # Top new memories (by importance desc, cap 10)
+  ($new | sort_by(-.importance) | .[0:10]) as $top_new |
+
+  # Top reinforced (by last_activated desc, cap 10)
+  ($reinforced | sort_by(-.last_activated) | .[0:10]) as $top_reinforced |
+
+  # High-importance nodes (importance > 0.8), across all real nodes
+  ($real | map(select(.importance > 0.8)) | length) as $high_imp_count |
+
+  # Scalar metrics
+  "TOTAL_REAL=\($real_count)",
+  "NEW_COUNT=\($new | length)",
+  "REINFORCED_COUNT=\($reinforced | length)",
+  "TOTAL_NODES=\($all | length)",
+  "AVG_IMP=\($avg_imp)",
+  "AVG_CONF=\($avg_conf)",
+  "ACT_RATIO=\($act_ratio)",
+  "SHARPNESS=\($sharpness)",
+  "HIGH_IMP=\($high_imp_count)",
+
+  # Item sections — fields separated by tab character (\t)
+  "---NEW---",
+  ($top_new[] | [.node_type, (.importance | tostring), (.content[0:120] | gsub("\n";" "))] | join("\t")),
+  "---REINFORCED---",
+  ($top_reinforced[] | [(.label[0:80] | gsub("\n";" ")), ("activated \(.activation_count)x total")] | join("\t"))
+' "$SNAPSHOT" 2>/dev/null)
+
+# ---------------------------------------------------------------------------
+# Parse scalar metrics
+# ---------------------------------------------------------------------------
+parse() { printf '%s' "$METRICS" | grep "^$1=" | head -1 | cut -d= -f2-; }
+
+TOTAL_REAL=$(parse TOTAL_REAL)
+NEW_COUNT=$(parse NEW_COUNT)
+REINFORCED_COUNT=$(parse REINFORCED_COUNT)
+TOTAL_NODES=$(parse TOTAL_NODES)
+AVG_IMP=$(parse AVG_IMP)
+AVG_CONF=$(parse AVG_CONF)
+ACT_RATIO=$(parse ACT_RATIO)
+SHARPNESS=$(parse SHARPNESS)
+HIGH_IMP=$(parse HIGH_IMP)
+
+# Format floats to 2dp (use awk, avoiding bc locale issues)
+fmt2() { awk "BEGIN{printf \"%.2f\", $1}"; }
+fmt4() { awk "BEGIN{printf \"%.4f\", $1}"; }
+AVG_IMP_FMT=$(fmt2 "$AVG_IMP")
+AVG_CONF_FMT=$(fmt2 "$AVG_CONF")
+ACT_RATIO_FMT=$(fmt4 "$ACT_RATIO")
+IMP_CONTRIB=$(fmt4 "$(awk "BEGIN{printf \"%.6f\", $AVG_IMP * 0.4}")")
+CONF_CONTRIB=$(fmt4 "$(awk "BEGIN{printf \"%.6f\", $AVG_CONF * 0.3}")")
+ACT_CONTRIB=$(fmt4 "$(awk "BEGIN{printf \"%.6f\", $ACT_RATIO * 0.3}")")
+
+# ---------------------------------------------------------------------------
+# Sharpness delta (compare to yesterday)
+# ---------------------------------------------------------------------------
+DELTA_STR=""
+if [[ -f "$SHARPNESS_FILE" ]]; then
+  YESTERDAY=$(date -v-1d +%Y-%m-%d 2>/dev/null || date -d "yesterday" +%Y-%m-%d 2>/dev/null || echo "")
+  if [[ -n "$YESTERDAY" ]]; then
+    PREV_SHARPNESS=$(jq -r --arg d "$YESTERDAY" '.[] | select(.date == $d) | .sharpness' "$SHARPNESS_FILE" 2>/dev/null | tail -1)
+    if [[ -n "$PREV_SHARPNESS" && "$PREV_SHARPNESS" != "null" ]]; then
+      DELTA=$(( SHARPNESS - PREV_SHARPNESS ))
+      if (( DELTA > 0 )); then
+        DELTA_STR="  (up ${DELTA}% from yesterday)"
+      elif (( DELTA < 0 )); then
+        DELTA_STR="  (down ${DELTA#-}% from yesterday)"
+      else
+        DELTA_STR="  (no change from yesterday)"
+      fi
+    fi
+  fi
+fi
+
+# ---------------------------------------------------------------------------
+# Build new-memories section (tab-delimited: type TAB importance TAB content)
+# ---------------------------------------------------------------------------
+new_section() {
+  local lines
+  lines=$(printf '%s\n' "$METRICS" | awk '/^---NEW---/{found=1; next} /^---REINFORCED---/{exit} found{print}')
+  if [[ -z "$lines" ]]; then
+    echo "  (none)"
+    return
+  fi
+  while IFS=$'\t' read -r ntype importance content; do
+    [[ -z "$ntype" ]] && continue
+    imp_fmt=$(awk "BEGIN{printf \"%.1f\", $importance}")
+    printf "  [%-18s] (importance: %s)  %s\n" "$ntype" "$imp_fmt" "$content"
+  done <<< "$lines"
+}
+
+# ---------------------------------------------------------------------------
+# Build reinforced section (tab-delimited: label TAB activation-info)
+# ---------------------------------------------------------------------------
+reinforced_section() {
+  local lines
+  lines=$(printf '%s\n' "$METRICS" | awk '/^---REINFORCED---/{found=1; next} found{print}')
+  if [[ -z "$lines" ]]; then
+    echo "  (none today)"
+    return
+  fi
+  while IFS=$'\t' read -r label acts; do
+    [[ -z "$label" ]] && continue
+    printf "  \"%s\" — %s\n" "$label" "$acts"
+  done <<< "$lines"
+}
+
+# ---------------------------------------------------------------------------
+# Render full digest
+# ---------------------------------------------------------------------------
+DIGEST=$(cat <<EOF
+=== Neuron Cultivation Digest — ${DATE} ===
+
+SHARPNESS: ${SHARPNESS}%${DELTA_STR}
+
+TODAY'S MEMORIES (${NEW_COUNT} new):
+$(new_section)
+
+REINFORCED (${REINFORCED_COUNT} nodes re-activated today):
+$(reinforced_section)
+
+MEMORY HEALTH:
+  Total nodes (all):            ${TOTAL_NODES}
+  Real memory nodes:            ${TOTAL_REAL}
+  Avg importance:               ${AVG_IMP_FMT}
+  Avg confidence:               ${AVG_CONF_FMT}
+  High-importance nodes (>0.8): ${HIGH_IMP}
+  Nodes created today:          ${NEW_COUNT}
+  Nodes re-activated today:     ${REINFORCED_COUNT}
+
+SHARPNESS FORMULA:
+  Sharpness = (avg_importance x 0.4) + (avg_confidence x 0.3) + (activation_ratio x 0.3)
+  avg_importance   = ${AVG_IMP_FMT}   -> ${AVG_IMP_FMT} x 0.4 = ${IMP_CONTRIB}
+  avg_confidence   = ${AVG_CONF_FMT}   -> ${AVG_CONF_FMT} x 0.3 = ${CONF_CONTRIB}
+  activation_ratio = ${ACT_RATIO_FMT}  -> ratio x 0.3 = ${ACT_CONTRIB}
+  Result: ${SHARPNESS}%
+
+Generated: $(date)
+EOF
+)
+
+# ---------------------------------------------------------------------------
+# Write digest file + print to stdout
+# ---------------------------------------------------------------------------
+printf '%s\n' "$DIGEST" | tee "$DIGEST_FILE"
+
+# ---------------------------------------------------------------------------
+# Append to sharpness.json
+# ---------------------------------------------------------------------------
+NEW_ENTRY="{\"date\":\"${DATE}\",\"sharpness\":${SHARPNESS},\"node_count\":${TOTAL_NODES},\"real_node_count\":${TOTAL_REAL},\"nodes_added\":${NEW_COUNT},\"nodes_reinforced\":${REINFORCED_COUNT}}"
+
+if [[ -f "$SHARPNESS_FILE" ]]; then
+  UPDATED=$(jq --arg d "$DATE" --argjson entry "$NEW_ENTRY" '
+    map(select(.date != $d)) + [$entry]
+  ' "$SHARPNESS_FILE" 2>/dev/null) || UPDATED="[$NEW_ENTRY]"
+  printf '%s\n' "$UPDATED" > "$SHARPNESS_FILE"
+else
+  printf '[%s]\n' "$NEW_ENTRY" > "$SHARPNESS_FILE"
+fi
+
+echo ""
+echo "Digest written to: $DIGEST_FILE"
+echo "Sharpness log:     $SHARPNESS_FILE"

tools/memory-export.sh

@@ -0,0 +1,162 @@
+#!/usr/bin/env bash
+# memory-export.sh — Export Neuron engram store as a portable encrypted .neuronmem bundle
+#
+# Usage:
+#   ./tools/memory-export.sh [output-path] [--passphrase "your passphrase"]
+#
+# If no passphrase is given, a random one is generated and printed — write it down.
+# If no output path is given, defaults to ./neuron-export-<timestamp>.neuronmem
+
+set -euo pipefail
+
+# ── Config ─────────────────────────────────────────────────────────────────────
+ENGRAM_SNAPSHOT="${HOME}/.neuron/engram/snapshot.json"
+SOUL_VERSION="1.1.0"
+FORMAT_VERSION="1"
+
+# ── Parse args ─────────────────────────────────────────────────────────────────
+OUTPUT_PATH=""
+PASSPHRASE=""
+PASSPHRASE_SET=0
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --passphrase)
+      PASSPHRASE="$2"
+      PASSPHRASE_SET=1
+      shift 2
+      ;;
+    --passphrase=*)
+      PASSPHRASE="${1#*=}"
+      PASSPHRASE_SET=1
+      shift
+      ;;
+    -*)
+      echo "Unknown option: $1" >&2
+      echo "Usage: $0 [output-path] [--passphrase \"...\"]" >&2
+      exit 1
+      ;;
+    *)
+      if [[ -z "$OUTPUT_PATH" ]]; then
+        OUTPUT_PATH="$1"
+      else
+        echo "Unexpected argument: $1" >&2
+        exit 1
+      fi
+      shift
+      ;;
+  esac
+done
+
+# ── Default output path ────────────────────────────────────────────────────────
+TIMESTAMP="$(date -u +"%Y%m%dT%H%M%SZ")"
+if [[ -z "$OUTPUT_PATH" ]]; then
+  OUTPUT_PATH="./neuron-export-${TIMESTAMP}.neuronmem"
+fi
+
+# Ensure .neuronmem extension
+if [[ "${OUTPUT_PATH}" != *.neuronmem ]]; then
+  OUTPUT_PATH="${OUTPUT_PATH%.neuronmem}.neuronmem"
+fi
+
+# ── Validate source ────────────────────────────────────────────────────────────
+if [[ ! -f "$ENGRAM_SNAPSHOT" ]]; then
+  echo "ERROR: Engram snapshot not found at: $ENGRAM_SNAPSHOT" >&2
+  exit 1
+fi
+
+echo "Neuron Memory Export"
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+echo "Source:  $ENGRAM_SNAPSHOT"
+echo "Output:  $OUTPUT_PATH"
+echo ""
+
+# ── Generate passphrase if not provided ────────────────────────────────────────
+if [[ $PASSPHRASE_SET -eq 0 ]]; then
+  PASSPHRASE="$(openssl rand -base64 32)"
+  echo "⚠  No passphrase provided. Generated passphrase:"
+  echo ""
+  echo "    ${PASSPHRASE}"
+  echo ""
+  echo "⚠  WRITE THIS DOWN. You will need it to import this file."
+  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+  echo ""
+fi
+
+# ── Count nodes and edges ──────────────────────────────────────────────────────
+echo "Analyzing snapshot..."
+NODE_COUNT="$(python3 -c "
+import json, sys
+with open('${ENGRAM_SNAPSHOT}') as f:
+    d = json.load(f)
+nodes = d.get('nodes', d if isinstance(d, list) else [])
+edges = d.get('edges', [])
+print(len(nodes) if isinstance(nodes, list) else len(nodes))
+" 2>/dev/null || echo "unknown")"
+
+echo "  Nodes: ${NODE_COUNT}"
+
+# ── Compute checksum of source file ───────────────────────────────────────────
+echo "Computing checksum..."
+CHECKSUM="$(openssl dgst -sha256 "$ENGRAM_SNAPSHOT" | awk '{print $NF}')"
+echo "  SHA256: ${CHECKSUM:0:16}..."
+
+# ── Build bundle in temp dir ───────────────────────────────────────────────────
+WORK_DIR="$(mktemp -d)"
+BUNDLE_DIR="${WORK_DIR}/neuronmem-v${FORMAT_VERSION}"
+mkdir -p "$BUNDLE_DIR"
+
+echo "Building bundle..."
+
+# Copy snapshot as nodes.json
+cp "$ENGRAM_SNAPSHOT" "${BUNDLE_DIR}/nodes.json"
+
+# Write metadata.json
+ISO_TIMESTAMP="$(date -u +"%Y-%m-%dT%H:%M:%SZ")"
+cat > "${BUNDLE_DIR}/metadata.json" << METAEOF
+{
+  "version": "${FORMAT_VERSION}",
+  "exported_at": "${ISO_TIMESTAMP}",
+  "node_count": ${NODE_COUNT},
+  "soul_version": "${SOUL_VERSION}",
+  "sha256": "${CHECKSUM}",
+  "format": "neuronmem-v1",
+  "encryption": "aes-256-cbc-pbkdf2",
+  "source_host": "$(hostname -s 2>/dev/null || echo unknown)"
+}
+METAEOF
+
+echo "  metadata.json written"
+echo "  nodes.json copied ($(du -sh "${BUNDLE_DIR}/nodes.json" | cut -f1))"
+
+# ── Create tar.gz ──────────────────────────────────────────────────────────────
+TAR_PATH="${WORK_DIR}/bundle.tar.gz"
+echo "Compressing..."
+(cd "$WORK_DIR" && tar czf "$TAR_PATH" "neuronmem-v${FORMAT_VERSION}/")
+COMPRESSED_SIZE="$(du -sh "$TAR_PATH" | cut -f1)"
+echo "  Compressed size: ${COMPRESSED_SIZE}"
+
+# ── Encrypt ────────────────────────────────────────────────────────────────────
+echo "Encrypting (AES-256-CBC, PBKDF2, 600k iterations)..."
+openssl enc -aes-256-cbc \
+  -pbkdf2 \
+  -iter 600000 \
+  -salt \
+  -in "$TAR_PATH" \
+  -out "$OUTPUT_PATH" \
+  -pass "pass:${PASSPHRASE}"
+
+# ── Cleanup ────────────────────────────────────────────────────────────────────
+rm -rf "$WORK_DIR"
+
+# ── Report ─────────────────────────────────────────────────────────────────────
+FINAL_SIZE="$(du -sh "$OUTPUT_PATH" | cut -f1)"
+echo ""
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+echo "Export complete."
+echo "  File:      $OUTPUT_PATH"
+echo "  Size:      ${FINAL_SIZE}"
+echo "  Nodes:     ${NODE_COUNT}"
+echo "  Checksum:  ${CHECKSUM:0:32}..."
+echo "  Timestamp: ${ISO_TIMESTAMP}"
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"

tools/memory-import-refugee.sh

@@ -0,0 +1,427 @@
+#!/usr/bin/env bash
+# memory-import-refugee.sh — Import conversation/memory history from external apps into Neuron
+#
+# Usage:
+#   ./tools/memory-import-refugee.sh --format chatgpt    conversations.json
+#   ./tools/memory-import-refugee.sh --format screenpipe screenpipe-export.json
+#   ./tools/memory-import-refugee.sh --format generic    data.json[l]
+#
+# Supported formats:
+#   chatgpt    — ChatGPT conversation export (conversations.json)
+#   screenpipe — Screenpipe OCR export (frames array)
+#   generic    — Any JSON array or JSONL with content/text fields
+#
+# The script writes Memory nodes to the Neuron soul via its HTTP API.
+# The soul must be running on localhost:7770.
+
+set -euo pipefail
+
+# ── Config ─────────────────────────────────────────────────────────────────────
+SOUL_HOST="http://localhost:7770"
+# Note: POST /api/neuron/memory ignores the label field (soul hardcodes "memory:remembered").
+# We embed the label in the content prefix so it is searchable.
+MEMORY_API="${SOUL_HOST}/api/neuron/memory"
+SLEEP_MS=100   # ms between API calls (rate limiting)
+
+# ── Dependency check ───────────────────────────────────────────────────────────
+if ! command -v jq &>/dev/null; then
+  echo "ERROR: jq is required but not installed." >&2
+  echo "" >&2
+  echo "Install it with:" >&2
+  echo "  macOS:  brew install jq" >&2
+  echo "  Ubuntu: sudo apt-get install jq" >&2
+  echo "  Alpine: apk add jq" >&2
+  exit 1
+fi
+
+# ── Parse args ─────────────────────────────────────────────────────────────────
+FORMAT=""
+INPUT_FILE=""
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --format|-f)
+      FORMAT="$2"
+      shift 2
+      ;;
+    --format=*|-f=*)
+      FORMAT="${1#*=}"
+      shift
+      ;;
+    -*)
+      echo "Unknown option: $1" >&2
+      echo "Usage: $0 --format <chatgpt|screenpipe|generic> <input-file>" >&2
+      exit 1
+      ;;
+    *)
+      if [[ -z "$INPUT_FILE" ]]; then
+        INPUT_FILE="$1"
+      else
+        echo "Unexpected argument: $1" >&2
+        exit 1
+      fi
+      shift
+      ;;
+  esac
+done
+
+if [[ -z "$FORMAT" ]]; then
+  echo "ERROR: --format is required." >&2
+  echo "Usage: $0 --format <chatgpt|screenpipe|generic> <input-file>" >&2
+  exit 1
+fi
+
+if [[ -z "$INPUT_FILE" ]]; then
+  echo "ERROR: No input file specified." >&2
+  echo "Usage: $0 --format <chatgpt|screenpipe|generic> <input-file>" >&2
+  exit 1
+fi
+
+if [[ ! -f "$INPUT_FILE" ]]; then
+  echo "ERROR: Input file not found: $INPUT_FILE" >&2
+  exit 1
+fi
+
+case "$FORMAT" in
+  chatgpt|screenpipe|generic) ;;
+  *)
+    echo "ERROR: Unknown format: $FORMAT" >&2
+    echo "Supported formats: chatgpt, screenpipe, generic" >&2
+    exit 1
+    ;;
+esac
+
+# ── Soul health check ──────────────────────────────────────────────────────────
+HTTP_CODE="$(curl -s -o /dev/null -w "%{http_code}" "${SOUL_HOST}/api/neuron/memory" 2>/dev/null || echo "000")"
+if [[ "$HTTP_CODE" == "000" ]]; then
+  echo "ERROR: Neuron soul is not responding at ${SOUL_HOST}." >&2
+  echo "       Start the soul service and retry." >&2
+  exit 1
+fi
+
+# ── Counters ───────────────────────────────────────────────────────────────────
+IMPORTED=0
+SKIPPED=0
+ERRORS=0
+
+# ── Helper: post one memory node ───────────────────────────────────────────────
+# post_memory CONTENT LABEL TAGS_JSON
+#
+# Note: the soul's POST /api/neuron/memory API ignores the label field (hardcodes
+# it to "memory:remembered"). We embed the label as a prefix in the content so
+# the title remains searchable via recall/search.
+post_memory() {
+  local content="$1"
+  local label="$2"
+  local tags_json="$3"
+
+  # Skip empty content
+  if [[ -z "$content" || "$content" == "null" ]]; then
+    SKIPPED=$((SKIPPED + 1))
+    return 0
+  fi
+
+  # Embed label in content so it's searchable (the API ignores the label field)
+  local full_content="[${label}] ${content}"
+
+  local payload
+  payload="$(jq -n \
+    --arg content "$full_content" \
+    --arg label "$label" \
+    --argjson tags "$tags_json" \
+    '{content: $content, label: $label, tags: $tags}')"
+
+  local response
+  response="$(curl -s -X POST "$MEMORY_API" \
+    -H "Content-Type: application/json" \
+    -d "$payload" 2>/dev/null)"
+
+  local ok
+  ok="$(echo "$response" | jq -r '.ok // "false"' 2>/dev/null)"
+
+  if [[ "$ok" == "true" ]]; then
+    IMPORTED=$((IMPORTED + 1))
+  else
+    ERRORS=$((ERRORS + 1))
+    echo "  [ERROR] API error for label \"${label:0:60}\": $response" >&2
+  fi
+
+  # Rate limit: sleep 100ms
+  sleep "0.${SLEEP_MS}"
+}
+
+# ── Format: ChatGPT ────────────────────────────────────────────────────────────
+import_chatgpt() {
+  echo "Format: ChatGPT conversation export"
+
+  # Validate: must be JSON array at top level
+  local top_type
+  top_type="$(jq -r 'type' "$INPUT_FILE" 2>/dev/null)"
+  if [[ "$top_type" != "array" ]]; then
+    echo "ERROR: ChatGPT export must be a JSON array of conversations." >&2
+    exit 1
+  fi
+
+  local conv_count
+  conv_count="$(jq 'length' "$INPUT_FILE")"
+  echo "Found ${conv_count} conversation(s) to process."
+  echo ""
+
+  # Count total user messages for progress display
+  local total_msgs
+  total_msgs="$(jq '[.[].mapping // {} | to_entries[] | .value.message | select(. != null and .author.role == "user") | .content.parts // [] | .[] | select(type == "string" and length > 0)] | length' "$INPUT_FILE" 2>/dev/null || echo "?")"
+  echo "Total user messages: ${total_msgs}"
+  echo ""
+
+  local msg_idx=0
+
+  # Process each conversation
+  while IFS= read -r conv_json; do
+    local title
+    title="$(echo "$conv_json" | jq -r '.title // "Untitled"')"
+
+    # Truncate label to 100 chars
+    local label="${title:0:100}"
+
+    # Extract user messages — ChatGPT export uses a mapping dict structure
+    # Mapping: { uuid: { id, message: { author: { role }, content: { parts: [...] } }, ... } }
+    # We iterate over mapping values, filter role=user, grab text parts
+    while IFS= read -r msg_text; do
+      msg_idx=$((msg_idx + 1))
+      echo "  Importing ${msg_idx}/${total_msgs}..."
+      post_memory "$msg_text" "$label" '["chatgpt-import","conversation"]'
+    done < <(echo "$conv_json" | jq -r '
+      .mapping // {} |
+      to_entries[] |
+      .value.message |
+      select(. != null) |
+      select(.author.role == "user") |
+      .content.parts // [] |
+      .[] |
+      select(type == "string" and length > 0)
+    ' 2>/dev/null)
+
+  done < <(jq -c '.[]' "$INPUT_FILE")
+}
+
+# ── Format: Screenpipe ─────────────────────────────────────────────────────────
+import_screenpipe() {
+  echo "Format: Screenpipe OCR export"
+
+  # Validate: must have frames array
+  local top_type
+  top_type="$(jq -r 'type' "$INPUT_FILE" 2>/dev/null)"
+  if [[ "$top_type" != "object" ]]; then
+    echo "ERROR: Screenpipe export must be a JSON object with a 'frames' array." >&2
+    exit 1
+  fi
+
+  local frame_count
+  frame_count="$(jq '.frames | length' "$INPUT_FILE" 2>/dev/null || echo "0")"
+  echo "Found ${frame_count} frame(s) to process."
+
+  if [[ "$frame_count" == "0" ]]; then
+    echo "No frames found. Nothing to import."
+    return 0
+  fi
+
+  # Group frames by app_name + 5-minute window bucket
+  # Strategy: process sorted frames, emit a group when app or bucket changes.
+  # We do this in pure jq with a reduce, emitting groups as newline-delimited JSON.
+
+  local total_groups=0
+  local group_idx=0
+
+  # Collect groups: each group is { app, bucket_ts, texts: [...] }
+  # Bucket = floor(timestamp_epoch / 300) * 300 seconds
+  # timestamps may be ISO8601 or epoch — handle both
+
+  # We process in jq and emit one group per line as JSON
+  while IFS= read -r group_json; do
+    total_groups=$((total_groups + 1))
+    # Just count first
+    :
+  done < <(jq -c '
+    .frames |
+    map(select(.text != null and (.text | length) > 0)) |
+    group_by(.app_name) |
+    .[] |
+    . as $app_frames |
+    ($app_frames[0].app_name) as $app |
+    # Sort by timestamp within app
+    (sort_by(.timestamp)) |
+    # Group into 5-minute buckets
+    reduce .[] as $f (
+      {bucket: null, texts: [], ts: null, groups: []};
+      ($f.timestamp // "") as $ts |
+      # Derive numeric bucket: try epoch directly; for ISO use first 15 chars as bucket key
+      (if ($ts | test("^[0-9]+$")) then ($ts | tonumber / 300 | floor)
+       else ($ts[0:15])
+       end) as $bucket |
+      if .bucket == null then
+        {bucket: $bucket, texts: [$f.text], ts: $ts, groups: .groups}
+      elif .bucket == $bucket then
+        {bucket: $bucket, texts: (.texts + [$f.text]), ts: $ts, groups: .groups}
+      else
+        {bucket: $bucket, texts: [$f.text], ts: $ts,
+         groups: (.groups + [{app: $app, ts: .ts, texts: .texts}])}
+      end
+    ) |
+    # flush last bucket
+    (.groups + [{app: .app_name, ts: .ts, texts: .texts}]) |
+    .[] |
+    select(.texts | length > 0)
+  ' "$INPUT_FILE" 2>/dev/null)
+
+  # Now actually process
+  while IFS= read -r group_json; do
+    group_idx=$((group_idx + 1))
+    echo "  Importing ${group_idx}..."
+
+    local app_name ts_str content label
+
+    app_name="$(echo "$group_json" | jq -r '.app // "unknown"')"
+    ts_str="$(echo "$group_json" | jq -r '.ts // ""')"
+
+    # Concatenate texts, truncate to 2000 chars
+    content="$(echo "$group_json" | jq -r '.texts | join(" ")' | cut -c1-2000)"
+    label="Screenpipe: ${app_name} at ${ts_str:0:16}"
+
+    local tags_json
+    tags_json="$(jq -n --arg app "$app_name" '["screenpipe-import","screen-capture",$app]')"
+
+    post_memory "$content" "$label" "$tags_json"
+
+  done < <(jq -c '
+    .frames |
+    map(select(.text != null and (.text | length) > 0)) |
+    group_by(.app_name) |
+    .[] |
+    . as $app_frames |
+    ($app_frames[0].app_name) as $app |
+    (sort_by(.timestamp)) |
+    reduce .[] as $f (
+      {bucket: null, texts: [], ts: null, app: $app, groups: []};
+      ($f.timestamp // "") as $ts |
+      (if ($ts | test("^[0-9]+$")) then ($ts | tonumber / 300 | floor | tostring)
+       else ($ts[0:15])
+       end) as $bucket |
+      if .bucket == null then
+        {bucket: $bucket, texts: [$f.text], ts: $ts, app: $app, groups: .groups}
+      elif .bucket == $bucket then
+        {bucket: $bucket, texts: (.texts + [$f.text]), ts: $ts, app: $app, groups: .groups}
+      else
+        {bucket: $bucket, texts: [$f.text], ts: $ts, app: $app,
+         groups: (.groups + [{app: $app, ts: .ts, texts: .texts}])}
+      end
+    ) |
+    (.groups + [{app: .app, ts: .ts, texts: .texts}]) |
+    .[] |
+    select(.texts | length > 0)
+  ' "$INPUT_FILE" 2>/dev/null)
+}
+
+# ── Format: Generic ────────────────────────────────────────────────────────────
+import_generic() {
+  echo "Format: Generic JSON/JSONL"
+
+  # Detect if JSONL (one JSON object per line) or single JSON array/object
+  local first_char
+  first_char="$(head -c1 "$INPUT_FILE" 2>/dev/null)"
+
+  local records_file
+  records_file="$(mktemp)"
+  trap 'rm -f "$records_file"' RETURN
+
+  if [[ "$first_char" == "[" ]]; then
+    # JSON array — explode to one object per line
+    jq -c '.[]' "$INPUT_FILE" > "$records_file" 2>/dev/null || true
+  elif [[ "$first_char" == "{" ]]; then
+    # Single object or JSONL — try JSONL first
+    # JSONL: each line is valid JSON
+    # Check if the whole file is one object or multiple lines
+    local line_count
+    line_count="$(wc -l < "$INPUT_FILE" | tr -d ' ')"
+    if [[ "$line_count" -le 1 ]]; then
+      # Single object: wrap in array and explode
+      jq -c '[.] | .[]' "$INPUT_FILE" > "$records_file" 2>/dev/null || true
+    else
+      # Assume JSONL
+      cp "$INPUT_FILE" "$records_file"
+    fi
+  else
+    # Try JSONL anyway
+    cp "$INPUT_FILE" "$records_file"
+  fi
+
+  local total_records
+  total_records="$(wc -l < "$records_file" | tr -d ' ')"
+  echo "Found ${total_records} record(s) to process."
+  echo ""
+
+  local idx=0
+  while IFS= read -r record_json; do
+    [[ -z "$record_json" ]] && continue
+
+    idx=$((idx + 1))
+    echo "  Importing ${idx}/${total_records}..."
+
+    # Extract content: prefer 'content', fall back to 'text', then 'body', then 'message'
+    local content
+    content="$(echo "$record_json" | jq -r '
+      if .content != null and (.content | type) == "string" then .content
+      elif .text != null and (.text | type) == "string" then .text
+      elif .body != null and (.body | type) == "string" then .body
+      elif .message != null and (.message | type) == "string" then .message
+      else ""
+      end
+    ' 2>/dev/null)"
+
+    [[ -z "$content" || "$content" == "null" ]] && { SKIPPED=$((SKIPPED + 1)); continue; }
+
+    # Extract label: prefer 'title', then 'label', then 'name', then first 80 chars of content
+    local label
+    label="$(echo "$record_json" | jq -r '
+      if .title != null and (.title | type) == "string" then .title
+      elif .label != null and (.label | type) == "string" then .label
+      elif .name != null and (.name | type) == "string" then .name
+      else ""
+      end
+    ' 2>/dev/null)"
+
+    if [[ -z "$label" || "$label" == "null" ]]; then
+      label="${content:0:80}"
+    fi
+    label="${label:0:100}"
+
+    post_memory "$content" "$label" '["imported","generic"]'
+
+  done < "$records_file"
+}
+
+# ── Main ───────────────────────────────────────────────────────────────────────
+echo "Neuron Refugee Importer"
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+echo "Source:  $INPUT_FILE"
+echo "Format:  $FORMAT"
+echo "Soul:    $SOUL_HOST"
+echo ""
+
+case "$FORMAT" in
+  chatgpt)    import_chatgpt ;;
+  screenpipe) import_screenpipe ;;
+  generic)    import_generic ;;
+esac
+
+# ── Final report ───────────────────────────────────────────────────────────────
+echo ""
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+echo "Import complete."
+echo "  Imported: ${IMPORTED}"
+echo "  Skipped:  ${SKIPPED}"
+echo "  Errors:   ${ERRORS}"
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+
+if [[ $ERRORS -gt 0 ]]; then
+  exit 1
+fi

tools/memory-import.sh

@@ -0,0 +1,289 @@
+#!/usr/bin/env bash
+# memory-import.sh — Import a Neuron .neuronmem bundle onto this device
+#
+# Usage:
+#   ./tools/memory-import.sh input.neuronmem [--passphrase "your passphrase"]
+#   ./tools/memory-import.sh input.neuronmem [--dry-run]   # verify only, no changes
+#
+# The script will:
+#   1. Decrypt and unpack the .neuronmem file
+#   2. Validate the checksum and version
+#   3. Back up the current snapshot.json
+#   4. Stop the soul service
+#   5. Replace snapshot.json
+#   6. Restart the soul service
+#   7. Verify the soul came back up
+
+set -euo pipefail
+
+# ── Config ─────────────────────────────────────────────────────────────────────
+ENGRAM_SNAPSHOT="${HOME}/.neuron/engram/snapshot.json"
+SOUL_SERVICE="ai.neurontechnologies.soul"
+SOUL_PORT="7770"
+SOUL_STARTUP_TIMEOUT=30   # seconds to wait for soul to come back
+
+# ── Parse args ─────────────────────────────────────────────────────────────────
+INPUT_PATH=""
+PASSPHRASE=""
+PASSPHRASE_SET=0
+DRY_RUN=0
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --passphrase)
+      PASSPHRASE="$2"
+      PASSPHRASE_SET=1
+      shift 2
+      ;;
+    --passphrase=*)
+      PASSPHRASE="${1#*=}"
+      PASSPHRASE_SET=1
+      shift
+      ;;
+    --dry-run)
+      DRY_RUN=1
+      shift
+      ;;
+    -*)
+      echo "Unknown option: $1" >&2
+      echo "Usage: $0 input.neuronmem [--passphrase \"...\"] [--dry-run]" >&2
+      exit 1
+      ;;
+    *)
+      if [[ -z "$INPUT_PATH" ]]; then
+        INPUT_PATH="$1"
+      else
+        echo "Unexpected argument: $1" >&2
+        exit 1
+      fi
+      shift
+      ;;
+  esac
+done
+
+if [[ -z "$INPUT_PATH" ]]; then
+  echo "ERROR: No input file specified." >&2
+  echo "Usage: $0 input.neuronmem [--passphrase \"...\"] [--dry-run]" >&2
+  exit 1
+fi
+
+if [[ ! -f "$INPUT_PATH" ]]; then
+  echo "ERROR: Input file not found: $INPUT_PATH" >&2
+  exit 1
+fi
+
+echo "Neuron Memory Import"
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+echo "Source:   $INPUT_PATH"
+echo "Target:   $ENGRAM_SNAPSHOT"
+if [[ $DRY_RUN -eq 1 ]]; then
+  echo "Mode:     DRY RUN (no changes will be made)"
+fi
+echo ""
+
+# ── Prompt for passphrase if needed ───────────────────────────────────────────
+if [[ $PASSPHRASE_SET -eq 0 ]]; then
+  read -r -s -p "Enter passphrase: " PASSPHRASE
+  echo ""
+  if [[ -z "$PASSPHRASE" ]]; then
+    echo "ERROR: Passphrase cannot be empty." >&2
+    exit 1
+  fi
+fi
+
+# ── Decrypt to temp dir ────────────────────────────────────────────────────────
+WORK_DIR="$(mktemp -d)"
+CLEANUP() {
+  rm -rf "$WORK_DIR"
+}
+trap CLEANUP EXIT
+
+TAR_PATH="${WORK_DIR}/bundle.tar.gz"
+
+echo "Decrypting..."
+if ! openssl enc -d -aes-256-cbc \
+    -pbkdf2 \
+    -iter 600000 \
+    -in "$INPUT_PATH" \
+    -out "$TAR_PATH" \
+    -pass "pass:${PASSPHRASE}" 2>/dev/null; then
+  echo "ERROR: Decryption failed. Wrong passphrase or corrupted file." >&2
+  exit 1
+fi
+echo "  Decrypted successfully."
+
+# ── Unpack ─────────────────────────────────────────────────────────────────────
+echo "Unpacking..."
+(cd "$WORK_DIR" && tar xzf "$TAR_PATH") || {
+  echo "ERROR: Failed to unpack bundle. File may be corrupted." >&2
+  exit 1
+}
+
+# Locate the bundle directory (neuronmem-v1/)
+BUNDLE_DIR=""
+for d in "${WORK_DIR}"/neuronmem-v*/; do
+  if [[ -d "$d" ]]; then
+    BUNDLE_DIR="$d"
+    break
+  fi
+done
+
+if [[ -z "$BUNDLE_DIR" ]]; then
+  echo "ERROR: Bundle directory not found. Invalid .neuronmem file." >&2
+  exit 1
+fi
+
+METADATA_FILE="${BUNDLE_DIR}metadata.json"
+NODES_FILE="${BUNDLE_DIR}nodes.json"
+
+if [[ ! -f "$METADATA_FILE" ]]; then
+  echo "ERROR: metadata.json missing from bundle." >&2
+  exit 1
+fi
+
+if [[ ! -f "$NODES_FILE" ]]; then
+  echo "ERROR: nodes.json missing from bundle." >&2
+  exit 1
+fi
+
+# ── Validate metadata ──────────────────────────────────────────────────────────
+echo "Validating metadata..."
+FORMAT_VERSION="$(python3 -c "import json; d=json.load(open('${METADATA_FILE}')); print(d.get('version','?'))")"
+EXPORTED_AT="$(python3 -c "import json; d=json.load(open('${METADATA_FILE}')); print(d.get('exported_at','?'))")"
+EXPECTED_COUNT="$(python3 -c "import json; d=json.load(open('${METADATA_FILE}')); print(d.get('node_count','?'))")"
+STORED_CHECKSUM="$(python3 -c "import json; d=json.load(open('${METADATA_FILE}')); print(d.get('sha256','?'))")"
+SOURCE_HOST="$(python3 -c "import json; d=json.load(open('${METADATA_FILE}')); print(d.get('source_host','?'))")"
+
+echo "  Format version: ${FORMAT_VERSION}"
+echo "  Exported at:    ${EXPORTED_AT}"
+echo "  Source host:    ${SOURCE_HOST}"
+echo "  Expected nodes: ${EXPECTED_COUNT}"
+
+if [[ "$FORMAT_VERSION" != "1" ]]; then
+  echo "ERROR: Unsupported bundle format version: ${FORMAT_VERSION}" >&2
+  echo "       This tool supports version 1 only." >&2
+  exit 1
+fi
+
+# ── Validate checksum ──────────────────────────────────────────────────────────
+echo "Verifying checksum..."
+ACTUAL_CHECKSUM="$(openssl dgst -sha256 "$NODES_FILE" | awk '{print $NF}')"
+
+if [[ "$ACTUAL_CHECKSUM" != "$STORED_CHECKSUM" ]]; then
+  echo "ERROR: Checksum mismatch!" >&2
+  echo "  Expected: ${STORED_CHECKSUM}" >&2
+  echo "  Got:      ${ACTUAL_CHECKSUM}" >&2
+  echo "  The bundle may be corrupted." >&2
+  exit 1
+fi
+echo "  Checksum OK: ${ACTUAL_CHECKSUM:0:16}..."
+
+# ── Verify node count ──────────────────────────────────────────────────────────
+echo "Verifying node count..."
+ACTUAL_COUNT="$(python3 -c "
+import json
+with open('${NODES_FILE}') as f:
+    d = json.load(f)
+nodes = d.get('nodes', d if isinstance(d, list) else [])
+print(len(nodes) if isinstance(nodes, list) else len(nodes))
+" 2>/dev/null || echo "unknown")"
+
+echo "  Found ${ACTUAL_COUNT} nodes (expected ${EXPECTED_COUNT})"
+
+if [[ "$ACTUAL_COUNT" != "$EXPECTED_COUNT" && "$EXPECTED_COUNT" != "unknown" ]]; then
+  echo "WARNING: Node count mismatch (expected ${EXPECTED_COUNT}, found ${ACTUAL_COUNT})." >&2
+  echo "         Proceeding anyway — count may differ if nodes were deduplicated." >&2
+fi
+
+# ── Dry run exit ───────────────────────────────────────────────────────────────
+if [[ $DRY_RUN -eq 1 ]]; then
+  echo ""
+  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+  echo "DRY RUN complete. Bundle is valid."
+  echo "  Nodes: ${ACTUAL_COUNT}"
+  echo "  Checksum: verified"
+  echo "  Run without --dry-run to import."
+  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+  exit 0
+fi
+
+# ── Safety confirmation ────────────────────────────────────────────────────────
+echo ""
+echo "WARNING: This will replace your current Neuron memory store."
+echo "  Current snapshot: $ENGRAM_SNAPSHOT"
+echo "  A backup will be created before replacing."
+echo ""
+read -r -p "Type 'yes' to continue: " CONFIRM
+if [[ "$CONFIRM" != "yes" ]]; then
+  echo "Aborted."
+  exit 0
+fi
+
+# ── Backup existing snapshot ───────────────────────────────────────────────────
+BACKUP_TIMESTAMP="$(date -u +"%Y%m%dT%H%M%SZ")"
+ENGRAM_DIR="$(dirname "$ENGRAM_SNAPSHOT")"
+BACKUP_PATH="${HOME}/.neuron/engram-backup-${BACKUP_TIMESTAMP}.tar.gz"
+
+echo ""
+echo "Backing up current snapshot..."
+if [[ -f "$ENGRAM_SNAPSHOT" ]]; then
+  (cd "$HOME/.neuron" && tar czf "$BACKUP_PATH" "$(basename "$ENGRAM_DIR")/snapshot.json" 2>/dev/null) || \
+  cp "$ENGRAM_SNAPSHOT" "${ENGRAM_SNAPSHOT}.backup-${BACKUP_TIMESTAMP}"
+  echo "  Backup: $BACKUP_PATH"
+else
+  echo "  No existing snapshot to back up."
+fi
+
+# ── Stop soul service ──────────────────────────────────────────────────────────
+echo "Stopping soul service (${SOUL_SERVICE})..."
+launchctl stop "$SOUL_SERVICE" 2>/dev/null || true
+# Also stop engram service if running
+launchctl stop "ai.neuron.engram" 2>/dev/null || true
+sleep 2
+echo "  Soul stopped."
+
+# ── Replace snapshot.json ──────────────────────────────────────────────────────
+echo "Installing new snapshot..."
+cp "$NODES_FILE" "$ENGRAM_SNAPSHOT"
+echo "  snapshot.json replaced ($(du -sh "$ENGRAM_SNAPSHOT" | cut -f1))"
+
+# ── Restart soul service ───────────────────────────────────────────────────────
+echo "Restarting soul service..."
+launchctl start "$SOUL_SERVICE" 2>/dev/null || true
+launchctl start "ai.neuron.engram" 2>/dev/null || true
+
+# ── Wait for soul to come up ───────────────────────────────────────────────────
+echo "Waiting for soul to come up on port ${SOUL_PORT}..."
+ELAPSED=0
+SOUL_UP=0
+while [[ $ELAPSED -lt $SOUL_STARTUP_TIMEOUT ]]; do
+  if curl -sf "http://localhost:${SOUL_PORT}/" > /dev/null 2>&1; then
+    SOUL_UP=1
+    break
+  fi
+  # Try a known endpoint that returns any response (even 404 means it's up)
+  HTTP_CODE="$(curl -s -o /dev/null -w "%{http_code}" "http://localhost:${SOUL_PORT}/api/neuron/memory" 2>/dev/null || echo "000")"
+  if [[ "$HTTP_CODE" != "000" ]]; then
+    SOUL_UP=1
+    break
+  fi
+  sleep 1
+  ELAPSED=$((ELAPSED + 1))
+done
+
+if [[ $SOUL_UP -eq 1 ]]; then
+  echo "  Soul is up (responded in ${ELAPSED}s)."
+else
+  echo "  WARNING: Soul did not respond within ${SOUL_STARTUP_TIMEOUT}s."
+  echo "  The service may still be starting. Check: launchctl list | grep soul"
+fi
+
+# ── Final report ───────────────────────────────────────────────────────────────
+echo ""
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+echo "Import complete."
+echo "  Nodes imported: ${ACTUAL_COUNT}"
+echo "  Exported at:    ${EXPORTED_AT}"
+echo "  Source host:    ${SOURCE_HOST}"
+echo "  Backup:         ${BACKUP_PATH}"
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"

tools/photo-to-memory.sh

@@ -0,0 +1,135 @@
+#!/usr/bin/env bash
+# photo-to-memory.sh — OCR a document/photo and store the text in Neuron memory
+#
+# Uses GLM-OCR (0.9B, MIT) via mlx-vlm on Apple Silicon.
+# Model auto-downloads ~1.59 GB to ~/.cache/huggingface/ on first run.
+#
+# Usage:
+#   ./tools/photo-to-memory.sh <image-file> [--dry-run] [--prompt "custom prompt"]
+#
+# Prerequisites:
+#   pip install -U mlx-vlm
+#
+# Examples:
+#   ./tools/photo-to-memory.sh ~/Desktop/receipt.jpg
+#   ./tools/photo-to-memory.sh ~/Documents/contract.png --dry-run
+#   ./tools/photo-to-memory.sh scan.jpg --prompt "Extract all text from this receipt"
+
+set -euo pipefail
+
+# ── Config ─────────────────────────────────────────────────────────────────────
+SOUL_URL="${SOUL_URL:-http://localhost:7770}"
+GLM_MODEL="${GLM_MODEL:-mlx-community/GLM-OCR-8bit}"
+MAX_TOKENS="${MAX_TOKENS:-4096}"
+DEFAULT_PROMPT="Extract all text from this document. Preserve structure including tables, headers, and lists. Output plain text."
+
+# ── Colours ────────────────────────────────────────────────────────────────────
+RED=$'\033[0;31m'; GREEN=$'\033[0;32m'; YELLOW=$'\033[1;33m'
+CYAN=$'\033[0;36m'; BOLD=$'\033[1m'; RESET=$'\033[0m'
+
+log()  { printf "%s%s%s\n" "$CYAN"  "$*" "$RESET"; }
+ok()   { printf "%s✓ %s%s\n" "$GREEN" "$*" "$RESET"; }
+warn() { printf "%s⚠ %s%s\n" "$YELLOW" "$*" "$RESET"; }
+die()  { printf "%s✗ %s%s\n" "$RED" "$*" "$RESET" >&2; exit 1; }
+
+# ── Parse args ─────────────────────────────────────────────────────────────────
+IMAGE_PATH=""
+DRY_RUN=0
+CUSTOM_PROMPT=""
+
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --dry-run)   DRY_RUN=1; shift ;;
+        --prompt)    CUSTOM_PROMPT="$2"; shift 2 ;;
+        --model)     GLM_MODEL="$2"; shift 2 ;;
+        --help|-h)
+            sed -n '2,15p' "$0" | sed 's/^# \{0,1\}//'
+            exit 0
+            ;;
+        -*)  die "Unknown option: $1" ;;
+        *)
+            [[ -n "$IMAGE_PATH" ]] && die "Only one image file at a time"
+            IMAGE_PATH="$1"
+            shift
+            ;;
+    esac
+done
+
+[[ -z "$IMAGE_PATH" ]] && die "Usage: $0 <image-file> [--dry-run] [--prompt \"...\"]"
+[[ -f "$IMAGE_PATH" ]] || die "File not found: $IMAGE_PATH"
+
+PROMPT="${CUSTOM_PROMPT:-$DEFAULT_PROMPT}"
+FILENAME=$(basename "$IMAGE_PATH")
+ABS_PATH=$(realpath "$IMAGE_PATH")
+
+# ── Check runtime ───────────────────────────────────────────────────────────────
+if ! python3 -c "import mlx_vlm" 2>/dev/null; then
+    warn "mlx-vlm not installed. Installing now..."
+    pip install -q -U mlx-vlm || die "pip install mlx-vlm failed — run manually: pip install -U mlx-vlm"
+fi
+
+# ── Run GLM-OCR ─────────────────────────────────────────────────────────────────
+log "Running GLM-OCR on: $FILENAME"
+log "Model: $GLM_MODEL"
+[[ "$DRY_RUN" -eq 1 ]] && warn "Dry-run mode — will not post to Neuron"
+
+# GLM-OCR output goes to stdout; capture it
+# First run downloads ~1.59 GB — this is expected and cached thereafter.
+OCR_TEXT=$(python3 -m mlx_vlm.generate \
+    --model "$GLM_MODEL" \
+    --max-tokens "$MAX_TOKENS" \
+    --temperature 0.0 \
+    --prompt "$PROMPT" \
+    --image "$ABS_PATH" \
+    2>/dev/null) || die "GLM-OCR failed. Check that mlx-vlm is installed and the image is readable."
+
+CHAR_COUNT=${#OCR_TEXT}
+log "OCR complete — extracted ${CHAR_COUNT} characters"
+
+if [[ "$CHAR_COUNT" -lt 5 ]]; then
+    warn "Very short output — the image may be blank or unreadable"
+fi
+
+# ── Preview ─────────────────────────────────────────────────────────────────────
+printf "\n%s--- OCR output preview (first 400 chars) ---%s\n" "$BOLD" "$RESET"
+printf "%s\n" "${OCR_TEXT:0:400}"
+[[ "$CHAR_COUNT" -gt 400 ]] && printf "%s... [+%d more chars]%s\n" "$YELLOW" $((CHAR_COUNT - 400)) "$RESET"
+printf "\n"
+
+# ── Post to Neuron soul ─────────────────────────────────────────────────────────
+if [[ "$DRY_RUN" -eq 1 ]]; then
+    ok "Dry-run complete — would POST ${CHAR_COUNT} chars to ${SOUL_URL}/api/neuron/memory"
+    exit 0
+fi
+
+log "Posting to Neuron soul at ${SOUL_URL} ..."
+
+PAYLOAD=$(python3 -c "
+import json, sys
+content = sys.argv[1]
+label   = sys.argv[2]
+tags    = ['photo-import', 'ocr', 'glm-ocr']
+print(json.dumps({'content': content, 'label': label, 'tags': tags}))
+" "$OCR_TEXT" "Photo: ${FILENAME}")
+
+HTTP_STATUS=$(curl -s -o /tmp/photo-to-memory-response.json -w "%{http_code}" \
+    -X POST "${SOUL_URL}/api/neuron/memory" \
+    -H "Content-Type: application/json" \
+    -d "$PAYLOAD")
+
+if [[ "$HTTP_STATUS" =~ ^2 ]]; then
+    NODE_ID=$(python3 -c "
+import json, sys
+try:
+    d = json.load(open('/tmp/photo-to-memory-response.json'))
+    print(d.get('id', d.get('node_id', 'unknown')))
+except Exception:
+    print('unknown')
+")
+    ok "Memory node created: ${NODE_ID}"
+    ok "Label: Photo: ${FILENAME}"
+    ok "Tags: photo-import, ocr, glm-ocr"
+else
+    BODY=$(cat /tmp/photo-to-memory-response.json 2>/dev/null || echo "(no body)")
+    die "Soul returned HTTP ${HTTP_STATUS}: ${BODY}"
+fi

tools/telegram-gateway.sh

@@ -0,0 +1,191 @@
+#!/bin/bash
+# Neuron Telegram Gateway
+# Polls Telegram for new messages, forwards to the soul at localhost:7770, sends responses back.
+# Supports plain text chat + commands: /memory, /remember, /status
+#
+# Token resolution order:
+#   1. $TELEGRAM_BOT_TOKEN env var
+#   2. macOS Keychain: security find-generic-password -s neuron-telegram-bot -a neuron -w
+
+set -euo pipefail
+
+TOKEN="${TELEGRAM_BOT_TOKEN:-$(security find-generic-password -s neuron-telegram-bot -a neuron -w 2>/dev/null || true)}"
+SOUL_URL="http://localhost:7770"
+OFFSET=0
+POLL_TIMEOUT=30
+
+if [[ -z "$TOKEN" ]]; then
+  echo "ERROR: No Telegram bot token. Set TELEGRAM_BOT_TOKEN or store in keychain." >&2
+  echo "See: ~/Development/neuron-technologies/neuron/docs/telegram-bot-setup.md" >&2
+  exit 1
+fi
+
+TG="https://api.telegram.org/bot${TOKEN}"
+
+log() { echo "[$(date '+%Y-%m-%d %H:%M:%S')] $*"; }
+
+# Send a Telegram message back to a chat
+send_message() {
+  local chat_id="$1"
+  local text="$2"
+  curl -s -X POST "${TG}/sendMessage" \
+    -H "Content-Type: application/json" \
+    -d "$(jq -n --argjson cid "$chat_id" --arg t "$text" \
+      '{chat_id: $cid, text: $t, parse_mode: "Markdown"}')" \
+    > /dev/null
+}
+
+# Store a memory in the soul
+store_memory() {
+  local content="$1"
+  local label="${2:-telegram:conversation}"
+  curl -s -X POST "${SOUL_URL}/api/neuron/memory" \
+    -H "Content-Type: application/json" \
+    -d "$(jq -n --arg c "$content" --arg l "$label" \
+      '{content: $c, label: $l}')" \
+    > /dev/null
+}
+
+# Chat with the soul; echoes the response text
+soul_chat() {
+  local message="$1"
+  local from="${2:-unknown}"
+  local response
+  response=$(curl -s -X POST "${SOUL_URL}/api/chat" \
+    -H "Content-Type: application/json" \
+    -d "$(jq -n --arg m "$message" --arg f "$from" \
+      '{message: $m, from: $f}')" 2>/dev/null)
+  # Extract .response — fall back to raw body on parse failure
+  jq -r '.response // empty' <<< "$response" 2>/dev/null || echo "$response"
+}
+
+# Search soul memories; echoes formatted results
+soul_recall() {
+  local query="$1"
+  local limit="${2:-3}"
+  local raw
+  raw=$(curl -s -X POST "${SOUL_URL}/api/neuron/recall" \
+    -H "Content-Type: application/json" \
+    -d "$(jq -n --arg q "$query" --argjson l "$limit" \
+      '{query: $q, limit: $l}')" 2>/dev/null)
+  # Format top results as a numbered list (truncate long nodes to 300 chars)
+  jq -r 'if type == "array" then
+    to_entries | .[:3] | map(
+      (.index + 1 | tostring) + ". " + (.value.content | .[0:300] | gsub("\n";" "))
+    ) | join("\n\n")
+  else
+    "No results found."
+  end' <<< "$raw" 2>/dev/null || echo "No results found."
+}
+
+# Check if soul is reachable
+soul_health() {
+  curl -s --max-time 3 "${SOUL_URL}/" > /dev/null 2>&1 && echo "up" || echo "down"
+}
+
+handle_update() {
+  local update="$1"
+  local chat_id msg_text from_name update_id
+
+  update_id=$(jq -r '.update_id' <<< "$update")
+  chat_id=$(jq -r '.message.chat.id // empty' <<< "$update")
+  msg_text=$(jq -r '.message.text // empty' <<< "$update")
+  from_name=$(jq -r '.message.from.first_name // "stranger"' <<< "$update")
+
+  # Skip non-message updates (inline queries, etc.)
+  if [[ -z "$chat_id" || -z "$msg_text" ]]; then
+    OFFSET=$((update_id + 1))
+    return
+  fi
+
+  log "[$update_id] from=$from_name chat=$chat_id text=${msg_text:0:60}"
+
+  # Route by command prefix
+  if [[ "$msg_text" == /status* ]]; then
+    local health
+    health=$(soul_health)
+    if [[ "$health" == "up" ]]; then
+      send_message "$chat_id" "Soul is *online* at ${SOUL_URL} ✓"
+    else
+      send_message "$chat_id" "Soul appears to be *offline* (${SOUL_URL} unreachable)."
+    fi
+
+  elif [[ "$msg_text" == /memory* ]]; then
+    local query="${msg_text#/memory}"
+    query="${query# }"
+    if [[ -z "$query" ]]; then
+      send_message "$chat_id" "Usage: /memory <query>"
+    else
+      local results
+      results=$(soul_recall "$query" 3)
+      if [[ -n "$results" ]]; then
+        send_message "$chat_id" "*Memories matching \"${query}\":*
+
+${results}"
+      else
+        send_message "$chat_id" "No memories found for \"${query}\"."
+      fi
+    fi
+
+  elif [[ "$msg_text" == /remember* ]]; then
+    local content="${msg_text#/remember}"
+    content="${content# }"
+    if [[ -z "$content" ]]; then
+      send_message "$chat_id" "Usage: /remember <text to store>"
+    else
+      store_memory "Telegram (${from_name}): ${content}" "telegram:explicit"
+      send_message "$chat_id" "Stored: _${content}_"
+    fi
+
+  else
+    # Plain text — forward to soul chat
+    local soul_response
+    soul_response=$(soul_chat "$msg_text" "$from_name" 2>/dev/null || true)
+
+    if [[ -z "$soul_response" ]]; then
+      soul_response="Neuron is resting — try again in a moment."
+    fi
+
+    send_message "$chat_id" "$soul_response"
+
+    # Capture conversation as a memory (fire-and-forget)
+    store_memory "Telegram conversation with ${from_name}: [user] ${msg_text} [soul] ${soul_response}" \
+      "telegram:conversation" &
+  fi
+
+  OFFSET=$((update_id + 1))
+}
+
+log "Neuron Telegram gateway starting (soul=${SOUL_URL}, poll_timeout=${POLL_TIMEOUT}s)"
+
+while true; do
+  # Long-poll for updates
+  UPDATES=$(curl -s --max-time $((POLL_TIMEOUT + 5)) \
+    "${TG}/getUpdates?offset=${OFFSET}&timeout=${POLL_TIMEOUT}" 2>/dev/null || true)
+
+  if [[ -z "$UPDATES" ]]; then
+    log "WARN: Empty response from Telegram; retrying in 5s"
+    sleep 5
+    continue
+  fi
+
+  OK=$(jq -r '.ok // false' <<< "$UPDATES" 2>/dev/null)
+  if [[ "$OK" != "true" ]]; then
+    DESC=$(jq -r '.description // "unknown error"' <<< "$UPDATES" 2>/dev/null)
+    log "WARN: Telegram API error: ${DESC}; retrying in 10s"
+    sleep 10
+    continue
+  fi
+
+  # Iterate over each update
+  COUNT=$(jq '.result | length' <<< "$UPDATES" 2>/dev/null || echo 0)
+  if [[ "$COUNT" -gt 0 ]]; then
+    for i in $(seq 0 $((COUNT - 1))); do
+      update=$(jq ".result[$i]" <<< "$UPDATES")
+      handle_update "$update"
+    done
+  fi
+
+  # Avoid hammering the API if something is very wrong
+  sleep 1
+done