soul: let Neuron answer 'what model am I running on?' — inject current engine into system prompt

Additive: appends a factual [CURRENT ENGINE: <model>] line to the system prompt (model from the
request body — accurate even under Auto routing; falls back to configured default). An LLM can't
know its own model from training (name/version assigned post-training), so the harness must tell it.
Identity-consistent: model = engine, self layered on top. Does NOT alter identity/values/safety.
PARSES (elc chat.el exit 0); NOT built/tested — ships with the soul rebuild.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

chat.el

@@ -602,6 +602,21 @@ fn json_safe(s: String) -> String {
     return s4
 }
 
+// current_engine_note — a short, FACTUAL line appended to the system prompt so Neuron can answer
+// "what model/LLM are you running on?" truthfully. An LLM cannot know its own model from training
+// (the name/version is assigned AFTER training finishes), so the harness must tell it. This is
+// identity-consistent: the model is the ENGINE; the self (identity, values, memory) is layered on
+// top. ADDITIVE — it adds a fact, it does not alter identity, values, or the safety layer.
+fn current_engine_note(model: String) -> String {
+    if str_eq(model, "") {
+        return ""
+    }
+    return "\n\n[CURRENT ENGINE: this turn is generated by the underlying model \"" + model
+        + "\". It is the engine beneath your self — your identity, values, and memory are layered on"
+        + " top of it. If the user asks which model or LLM you are running on, answer with this model"
+        + " id plainly and truthfully; never guess a different one.]"
+}
+
 // build_system_prompt — assemble the system prompt for a chat turn.
 // chat_mode: Bool — pass true from handle_chat (no tools), false from agentic paths.
 // Issue #9 fix: no_tools_rule only included when chat_mode=true.
@@ -959,7 +974,12 @@ fn handle_chat(body: String) -> String {
     }
 
     let ctx: String = engram_compile(activation_seed)
-    let system: String = affective_prefix + build_system_prompt(ctx, true)
+    // Tell the LLM which engine it is running on this turn, so it can answer truthfully instead of
+    // guessing. The per-turn model rides in the request body (concrete even under Auto routing);
+    // fall back to the configured default when blank.
+    let sp_req_model: String = json_get(body, "model")
+    let sp_model: String = if str_eq(sp_req_model, "") { chat_default_model() } else { sp_req_model }
+    let system: String = affective_prefix + build_system_prompt(ctx, true) + current_engine_note(sp_model)
 
     let seen_ids: String = state_get("engram_compile_seen_ids")
 

council/README.md

@@ -1,123 +0,0 @@
-# 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

@@ -1,234 +0,0 @@
-#!/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

@@ -1,224 +0,0 @@
-#!/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/soul.c

@@ -25343,31 +25343,9 @@ 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);
-  /* Prune all existing soul:boot_count nodes — keep exactly one. */
-  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(""))) {
-        (void)(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 boot_node_id = 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);
-  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) — 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 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;
 }
@@ -29443,26 +29421,6 @@ el_val_t emit_session_start_event(void) {
   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("{\"event\":\"session_start\""), EL_STR(",\"boot\":")), boot_num), EL_STR(",\"cgi\":\"")), eff_cgi), EL_STR("\"")), EL_STR(",\"node_count\":")), int_to_str(node_ct)), EL_STR(",\"edge_count\":")), int_to_str(edge_ct)), EL_STR(",\"identity_loaded\":")), has_identity), EL_STR(",\"ts\":")), int_to_str(ts)), EL_STR("}"));
   el_val_t tags = EL_STR("[\"internal-state\",\"session-start\",\"InternalStateEvent\"]");
   el_val_t discard = engram_node_full(payload, EL_STR("InternalStateEvent"), EL_STR("session-start"), 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("Episodic"), tags);
-  /* Prune accumulated session-start events — keep the 10 most recent.
-   * engram_search_json returns oldest-first, so forget from index 0 to (count-11). */
-  el_val_t keep_n = 10;
-  el_val_t old_events = engram_search_json(EL_STR("session-start InternalStateEvent"), 200);
-  if (!str_eq(old_events, EL_STR("")) && !str_eq(old_events, EL_STR("[]"))) {
-    el_val_t ev_count = json_array_len(old_events);
-    if (ev_count > keep_n) {
-      el_val_t prune_to = (ev_count - keep_n);
-      el_val_t ei = 0;
-      while (ei < prune_to) {
-        el_val_t old_ev = json_array_get(old_events, ei);
-        el_val_t old_ev_id = json_get(old_ev, EL_STR("id"));
-        if (!str_eq(old_ev_id, EL_STR(""))) {
-          (void)(engram_forget(old_ev_id));
-        }
-        ei = (ei + 1);
-      }
-      println(el_str_concat(el_str_concat(el_str_concat(EL_STR("[soul] pruned "), int_to_str(prune_to)), EL_STR(" old session-start events (kept 10)")), EL_STR("")));
-    }
-  }
   println(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("[soul] session-start event logged (boot="), boot_num), EL_STR(" nodes=")), int_to_str(node_ct)), EL_STR(" edges=")), int_to_str(edge_ct)), EL_STR(")")));
   return 0;
 }

dist/win32_shim.h

@@ -1,35 +0,0 @@
-/*
- * 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/telegram-bot-setup.md

@@ -1,77 +0,0 @@
-# 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 |

memory.el

@@ -134,30 +134,12 @@ fn mem_boot_count_get() -> Int {
     return str_to_int(num_str)
 }
 
-// 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.
+// 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.
 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\"]"
     let boot_node_id: String = engram_node_full(

neuron-api.el

@@ -196,12 +196,11 @@ fn handle_api_node_create(body: String) -> String {
 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.
-    // Delete is NOT read-back-verified: engram_get_node_json can return a stale hit
-    // for a just-forgotten id because the id→index map is not rebuilt on forget.
-    // A stale hit would cause a false "delete_failed" on a successful deletion.
-    // This exception is correct: read-back-verify guards WRITES; for deletes,
-    // the graph endpoints (/api/graph/nodes) reflect the removal and are the source of truth.
+    // 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 + "\"}"
 }

soul.el

@@ -346,27 +346,6 @@ fn emit_session_start_event() -> Void {
         el_from_float(0.9), el_from_float(0.9), el_from_float(1.0),
         "Episodic", tags
     )
-    // 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 + ")")
 }
 

tools/telegram-gateway.sh

@@ -1,191 +0,0 @@
-#!/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