Merge pull request 'Add neuron-dev-setup: one-command CORE dev stack onboarding installer' (#84) from feat/neuron-dev-setup into main

Co-authored-by: Neuron <will.anderson@neurontechnologies.ai>
Co-committed-by: Neuron <will.anderson@neurontechnologies.ai>

chat.el

@@ -1680,8 +1680,16 @@ fn dispatch_tool(tool_name: String, tool_input: String) -> String {
         if !path_within_root(path, root) {
             return json_safe("denied: path is outside the agent workspace root")
         }
-        fs_write(resolve_in_root(path, root), content)
-        return json_safe("{\"ok\":true}")
+        // BUG-6 fix (2026-07-17): never claim ok without disk truth. fs_write's result was
+        // never checked, so a failed write reported ok — the exact false-receipt failure
+        // the run guards exist to kill. Verify the file landed and return the RESOLVED
+        // path so callers and the model can only narrate what is really on disk.
+        let dest: String = resolve_in_root(path, root)
+        fs_write(dest, content)
+        if !fs_exists(dest) {
+            return json_safe("{\"error\":\"write failed - nothing landed at " + dest + "\"}")
+        }
+        return json_safe("{\"ok\":true,\"path\":\"" + dest + "\"}")
     }
     if str_eq(tool_name, "web_get") {
         let url: String = json_get(tool_input, "url")
@@ -1935,8 +1943,24 @@ fn handle_chat_agentic(body: String) -> String {
     // no root (or cleared the field), and we must not overwrite a server-configured root
     // from NEURON_AGENT_ROOT with an empty string, which would silently un-scope the agent.
     let ws_root: String = json_get(body, "agent_workspace_root")
+    // BUG-LEAK fix (2026-07-16): the root used to live ONLY in the shared key, so any
+    // request that omitted it INHERITED the previous session's folder (proven: a rootless
+    // curl session wrote into another session's run folder). Now each session keeps its
+    // own copy, and every request RE-ASSERTS its own root (possibly empty) into the shared
+    // key the tool guards read — no session can ever act under another session's root.
+    // Empty state still falls through to env NEURON_AGENT_ROOT inside
+    // agent_workspace_root(), so a server-configured root survives unchanged.
+    // LIMITATION (for review): assumes serialized request handling; true per-call scoping
+    // means threading session_id through dispatch_tool/classify — deeper change, Will's call.
+    let sess_for_root: String = json_get(body, "session_id")
     if !str_eq(ws_root, "") {
+        if !str_eq(sess_for_root, "") {
+            state_set("agent_workspace_root_" + sess_for_root, ws_root)
+        }
         state_set("agent_workspace_root", ws_root)
+    } else {
+        let own_root: String = if str_eq(sess_for_root, "") { "" } else { state_get("agent_workspace_root_" + sess_for_root) }
+        state_set("agent_workspace_root", own_root)
     }
 
     // L1 safety screen — agentic path must pass the same gate as layered_cycle.
@@ -2066,6 +2090,14 @@ fn handle_chat_agentic(body: String) -> String {
 
     // Use caller-supplied session_id if provided, otherwise generate a bridge id.
     let session_id: String = if str_eq(req_session, "") { next_bridge_id() } else { req_session }
+    // PAUSE-CONTRACT fix (2026-07-16): honor the client's require_approval field — the
+    // Phase 1c contract ("the soul pauses on EVERY tool; the client's tier gate decides
+    // what actually prompts") was never implemented engine-side, which made the client's
+    // Ask autonomy silently inert for builtin sub-escalate tools. Persisted per session
+    // (set/reset on every request) so the /approve resume path keeps the same behavior
+    // for the rest of the run. Absent/false = behavior identical to before this fix.
+    let req_ask_all: String = json_get(body, "require_approval")
+    state_set("require_approval_" + session_id, if str_eq(req_ask_all, "true") { "true" } else { "" })
     // Provider fork: OpenAI-compatible providers (Ollama/OpenAI/Grok/Gemini) take the plain-completion
     // path (v1, no tools); everything else stays on the Anthropic agentic loop (the default).
     let use_openai: Bool = !str_eq(llm_base_url(), "") && str_eq(llm_wire_format(), "openai")
@@ -2134,6 +2166,12 @@ fn handle_chat_agentic(body: String) -> String {
 fn agentic_loop(session_id: String, model: String, safe_sys: String, tools_json: String, messages_in: String, h: Map, tools_log_in: String) -> String {
     let api_url: String = "https://api.anthropic.com/v1/messages"
 
+    // PAUSE-CONTRACT fix (2026-07-16): when the client asked to approve every action
+    // (require_approval on the request, persisted per session), EVERY tool turn bridges —
+    // the client's tier gate decides what actually prompts vs auto-continues. Read from
+    // session state so the /approve resume re-entry keeps the same behavior mid-run.
+    let ask_all: Bool = !str_eq(session_id, "") && str_eq(state_get("require_approval_" + session_id), "true")
+
     let messages: String = messages_in
     let final_text: String = ""
     let tools_log: String = tools_log_in
@@ -2220,7 +2258,10 @@ fn agentic_loop(session_id: String, model: String, safe_sys: String, tools_json:
         // confirm). Escalated calls suspend to the client's consent flow; the
         // /approve round-trip is the only path that executes them.
         let risk_tier: String = if is_tool_turn { classify_tool_risk(tool_name, tool_input) } else { "" }
-        let needs_bridge: Bool = is_tool_turn && (str_eq(risk_tier, "escalate") || (!is_builtin_tool(tool_name) && !is_always_allowed))
+        // PAUSE-CONTRACT fix (2026-07-16): ask_all bridges EVERYTHING — stricter only.
+        // Escalate keeps its unconditional bridge; "always allow" shortcuts never apply
+        // under ask_all (the client owns its own standing grants at its tier gate).
+        let needs_bridge: Bool = is_tool_turn && (ask_all || str_eq(risk_tier, "escalate") || (!is_builtin_tool(tool_name) && !is_always_allowed))
 
         // Built-in tools dispatch locally; bridged tools yield "" (never sent upstream).
         let tool_result_raw: String = if is_tool_turn && !needs_bridge { dispatch_tool(tool_name, tool_input) } else { "" }
@@ -2360,6 +2401,10 @@ fn agentic_resume(session_id: String, tool_use_id: String, content: String) -> S
     if str_eq(blob, "") {
         return "{\"error\":\"unknown session_id\",\"reply\":\"\"}"
     }
+    // BUG-LEAK fix (2026-07-16): re-assert THIS session's own workspace root before the
+    // loop continues — a resume must never run under whatever root the last unrelated
+    // request happened to leave in the shared key.
+    state_set("agent_workspace_root", state_get("agent_workspace_root_" + session_id))
 
     let model: String = json_get(blob, "model")
     let safe_sys: String = json_get(blob, "safe_sys")

dist/neuron.c

@@ -519,7 +519,7 @@ int main(int _argc, char** _argv) {
   axon_raw = env(EL_STR("NEURON_API_URL"));
   axon_base = ({ el_val_t _if_result_47 = 0; if (str_eq(axon_raw, EL_STR(""))) { _if_result_47 = (EL_STR("http://localhost:7771")); } else { _if_result_47 = (axon_raw); } _if_result_47; });
   studio_dir_raw = env(EL_STR("SOUL_STUDIO_DIR"));
-  studio_dir = ({ el_val_t _if_result_48 = 0; if (str_eq(studio_dir_raw, EL_STR(""))) { _if_result_48 = (EL_STR("/Users/will/Development/neuron-technologies/products/cgi-studio/el-daemon")); } else { _if_result_48 = (studio_dir_raw); } _if_result_48; });
+  studio_dir = ({ el_val_t _if_result_48 = 0; if (str_eq(studio_dir_raw, EL_STR(""))) { _if_result_48 = (el_str_concat(env(EL_STR("HOME")), EL_STR("/Development/neuron-technologies/products/cgi-studio/el-daemon"))); } else { _if_result_48 = (studio_dir_raw); } _if_result_48; });
   println(el_str_concat(el_str_concat(el_str_concat(EL_STR("[soul] boot - cgi="), soul_cgi_id), EL_STR(" port=")), int_to_str(port)));
   using_http_engram = !str_eq(engram_url_raw, EL_STR(""));
   engram_load(snapshot);

dist/soul-with-nlg.el

@@ -21304,7 +21304,7 @@ println("[memory] consolidate stats=" + stats)
 let soul_axon_base_raw: String = env("NEURON_API_URL")
 let soul_axon_base: String = if str_eq(soul_axon_base_raw, "") { "http://localhost:7771" } else { soul_axon_base_raw }
 let soul_token: String = env("NEURON_TOKEN")
-let soul_studio_ui_dir: String = "/Users/will/Development/neuron-technologies/products/cgi-studio/el-daemon"
+let soul_studio_ui_dir: String = env("HOME") + "/Development/neuron-technologies/products/cgi-studio/el-daemon"
 
 // ── Runtime bridge helpers ────────────────────────────────────────────────────
 

dist/soul.c

@@ -30704,7 +30704,7 @@ int main(int _argc, char** _argv) {
   axon_raw = env(EL_STR("NEURON_API_URL"));
   axon_base = ({ el_val_t _if_result_700 = 0; if (str_eq(axon_raw, EL_STR(""))) { _if_result_700 = (EL_STR("http://localhost:7771")); } else { _if_result_700 = (axon_raw); } _if_result_700; });
   studio_dir_raw = env(EL_STR("SOUL_STUDIO_DIR"));
-  studio_dir = ({ el_val_t _if_result_701 = 0; if (str_eq(studio_dir_raw, EL_STR(""))) { _if_result_701 = (EL_STR("/Users/will/Development/neuron-technologies/products/cgi-studio/el-daemon")); } else { _if_result_701 = (studio_dir_raw); } _if_result_701; });
+  studio_dir = ({ el_val_t _if_result_701 = 0; if (str_eq(studio_dir_raw, EL_STR(""))) { _if_result_701 = (el_str_concat(env(EL_STR("HOME")), EL_STR("/Development/neuron-technologies/products/cgi-studio/el-daemon"))); } else { _if_result_701 = (studio_dir_raw); } _if_result_701; });
   println(el_str_concat(el_str_concat(el_str_concat(EL_STR("[soul] boot - cgi="), soul_cgi_id), EL_STR(" port=")), int_to_str(port)));
   using_http_engram = !str_eq(engram_url_raw, EL_STR(""));
   engram_load(snapshot);

docs/NARRATED-RUNS-ENGINE-NOTES-20260713.md

@@ -0,0 +1,34 @@
+# Narrated runs — engine notes for Will (2026-07-13)
+
+Source half: commit aa67f86 on feat/agent-phase1-soul (run-progress ledger,
+`/api/run-progress/<sid>` route, narration on the pause envelope, config display
+default). E2E-verified via the compiled test bed on Tim's clean profile.
+
+Compiled-form-only fixes (in `neuron-container-build/soul-narrated-runs-20260713.patch`,
+applies ON TOP of `soul-webfix-20260711.patch` — these need porting to chat.el when the
+webfix itself is ported):
+
+1. **pause_turn + tool_use interleave**: a pause_turn response can ALSO carry a client
+   tool_use; resuming verbatim leaves it unpaired → Anthropic 400 "tool_use ids were
+   found without tool_result". Fix: tool-bearing pause rounds are tool turns
+   (dispatch + pair); verbatim resume only when the round has no client tool.
+2. **Agentic toolset scope**: agentic_tools_all() fed EVERY connector/MCP tool (Notion,
+   code-execution…) into the loop. Code-execution flips the API into programmatic
+   tool calling, whose pairing protocol the single-tool manual loop does not speak —
+   source of the dangling-pair 400s AND the bash_code_execution workspace-dodge.
+   Fix: handle_chat_agentic declares builtins + ONE server web_search only.
+   Connector tools return when the loop gains real multi-tool/programmatic support.
+3. **disable_parallel_tool_use: true** on agentic requests — the loop captures only the
+   first tool_use per round; Opus-class models parallel-call. Enforce the invariant.
+4. **web_search server-tool default variant → web_search_20250305 (GA)**. The 20260209
+   variant couples to code-execution ⇒ programmatic mode (see #2, and the June note:
+   "inert unless code-execution attached").
+5. **Homegrown web_search removed** from the tool catalog (server-side is the one tool).
+
+Known engine debts this work surfaced (not fixed):
+
+- **Poisoned session history**: a failed run persists the malformed assistant turn; every
+  later turn in that session replays it and 400s. Needs history sanitation on load.
+- **Huge-history invalid-escape 400** (~346KB request) — likely the same poisoned blob.
+- **macOS note**: replacing a binary in place invalidates its ad-hoc signature (instant
+  silent SIGKILL, looks like exit 0). `rm + cp + codesign -f -s -` is the swap ritual.

neuron-dev-setup/README.md

@@ -0,0 +1,171 @@
+# neuron-dev-setup — one-command Neuron CORE dev stack
+
+Stand up an identical **Neuron brain + agent** on a fresh Mac so any developer
+gets the same local runtime to build against. This is the **CORE** dev stack
+only — the four native `launchd` services that make Neuron think, remember, and
+speak MCP to Claude Code. Will's personal automations (catalyst, telegram,
+vessels, studio, self-review, world-integrator, council, compressor, snapshots,
+act-runner, …) are **deliberately excluded**.
+
+```
+  ┌─────────────┐        ┌──────────────┐
+  │  soul :7770 │ ─────► │ engram :8742 │     the mind ──► its memory substrate
+  └─────────────┘        └──────────────┘
+        ▲
+        │
+  ┌───────────────────┐
+  │ mcp-wrapper :17779│  ─── MCP surface over the soul HTTP API (internal)
+  └───────────────────┘
+        ▲
+        │
+  ┌────────────────┐
+  │ mcp-proxy :7779│  ◄─── Claude Code connects here (stable front door)
+  └────────────────┘
+```
+
+Claude Code's `neuron` MCP server points at `http://127.0.0.1:7779/` — the proxy.
+The proxy forwards to the wrapper (`:17779`), which calls the soul (`:7770`),
+which reads/writes the engram (`:8742`). The engram is the persistent brain.
+
+## Quick start
+
+```bash
+git clone <this-repo> && cd neuron-dev-setup
+cp config.env.example config.env      # optional — edit ports/paths if you like
+./install.sh                          # prompts for your Anthropic API key
+```
+
+Then verify:
+
+```bash
+curl http://localhost:8742/health     # engram
+curl http://localhost:7770/health         # soul
+curl http://localhost:7779/health         # mcp-proxy (what Claude Code uses)
+launchctl list | grep ai.neuron
+```
+
+Open Claude Code — the `neuron` MCP tools should be live, backed by **your own**
+local brain. `./install.sh --dry-run` shows every action without touching anything.
+
+## What the installer does (8 phases)
+
+| Phase | Action |
+|------|--------|
+| 1 | Preflight: macOS/arm64, ensure `git cc curl python3` + `openssl@3` (via Homebrew) |
+| 2 | Prompt for the **Anthropic API key**, store it in the **macOS Keychain** (never a file) |
+| 3 | Clone `neuron`, `engram`, `foundation`; fetch the El toolchain; build 4 binaries + `forge` |
+| 4 | Lay down `~/.neuron/{bin,logs,engram}` and the templated `soul-wrapper.sh` |
+| 5 | Generate + load the 4 core LaunchAgents (engram → soul → wrapper → proxy) |
+| 6 | Seed a fresh engram with the **genesis identity** via `forge install` |
+| 7 | Install Claude config: `neuron` agent, core hooks, local MCP registration |
+| 8 | Health-check all four ports |
+
+Everything is **idempotent** (safe to re-run) and **templated** to the invoking
+user's `$HOME` — no path is hardcoded to another machine.
+
+## Prerequisites
+
+- macOS on Apple Silicon (uses `launchd`; soul build flags assume arm64).
+- **Xcode Command Line Tools** (`xcode-select --install`) — provides `cc`, `git`.
+- **Homebrew** — for `openssl@3`, `curl`.
+- An **Anthropic API key** — the soul's inference provider. Prompted for; stored
+  in Keychain under service `neuron-llm-0-key`; read at launch by `soul-wrapper.sh`.
+- **Git access** to Gitea (`git.neuralplatform.ai`) for the source repos.
+- **GCP access** to project `neuron-785695` Artifact Registry (default El
+  toolchain source). Ask Will to grant it, or set `EL_TOOLCHAIN_SOURCE=local`.
+
+## Core-stack map (what gets replicated)
+
+| Service | Port | Binary | Built from | LaunchAgent |
+|---------|------|--------|------------|-------------|
+| soul | 7770 | `neuron/dist/neuron` | `dist/soul.c` + El runtime, `cc` (CI recipe) | `ai.neuron.soul` |
+| engram | 8742 | `engram/dist/engram` | `engram` repo `src/server.el` via `elc`→`cc` | `ai.neuron.engram` |
+| mcp-wrapper | 17779 | `neuron/mcp-wrapper/dist/neuron-mcp-wrapper` | `mcp-wrapper/src/main.el` | `ai.neuron.mcp-wrapper` |
+| mcp-proxy | 7779 | `neuron/mcp-proxy/dist/neuron-mcp-proxy` | `mcp-proxy/src/main.el` | `ai.neuron.mcp-proxy` |
+
+**`~/.neuron` layout the installer creates**
+
+```
+~/.neuron/
+  bin/soul-wrapper.sh     # reads Anthropic key from Keychain, execs the soul binary
+  logs/                   # soul.*.log, engram.log, mcp-*.log
+  engram/                 # ENGRAM_DATA_DIR — the persistent brain (snapshot.json + db)
+```
+
+**Identity seed.** `foundation/forge/seeds/neuron-genesis-seed.json` carries
+`identity_nodes[]` + `edges[]` with **fixed** knowledge-node IDs (e.g.
+`kn-efeb4a5b-5aff-4759-8a97-7233099be6ee`, the "self" traversal root). Those exact
+IDs are referenced by the SessionStart self-load hook and the neuron agent, so
+seeding must **preserve IDs** — `forge install <seed>` is the mechanism.
+
+**Claude config installed** (`~/.claude/`)
+
+- `agents/neuron.md` — the Neuron agent (identity, session protocol, five primitives).
+- `mcp.json` — registers `neuron` → `http://127.0.0.1:7779/`.
+- `settings.json` hooks (CORE subset only):
+  - `SessionStart` → `neuron-self-load.sh` (loads identity from the seeded engram)
+  - `PreToolUse:Agent` → `neuron-agent-preamble.sh` (subagents load substrate first)
+  - `PreCompact` → `pre-compact.sh` (clean context recovery)
+
+### Deliberately EXCLUDED from core
+
+- **`check-active-contexts.sh`** and **`require-execution-context.sh`** — these
+  depend on a separate filesystem repo `~/Development/projects/active/neuron/synapse`.
+  `require-execution-context.sh` is a hard `Edit/Write` gate that would **block a
+  fresh dev from editing any file** without that synapse repo. Not core; excluded.
+- `engram-mirror.py` (PostToolUse) — optional; mirrors MCP writes to engram.
+- All Will-personal LaunchAgents: `catalyst-*`, `telegram-gateway`, `vessel.*`,
+  `studio`, `self-review`, `world-integrator`, `council`, `compressor`,
+  `cultivation-digest`, `snapshot-backup`, `engram-backup`, `act-runner`, `keymap`,
+  `invest`, and the disabled `ai.neuron.api` (`:7771` is a personal Python
+  perception helper — confirmed not core).
+
+## Secrets — how they're handled
+
+- **Anthropic key**: prompted for; stored in Keychain; read at launch. Never in a
+  plist, this repo, or a log.
+- **Engram local token** (`ENGRAM_API_KEY`): a *loopback-only* dev token, not a
+  cloud secret. Defaults to a generated `ntn-dev-*` value; override in `config.env`.
+- No cloud tokens, Vault tokens, CF-Access secrets, or founder keys are copied.
+  (Will's live `start-daemon.sh`/`neuron-api-launch.sh` contain such keys — this
+  installer intentionally does **not** use those files.)
+
+## Uninstall
+
+```bash
+./uninstall.sh                # stop + remove the 4 LaunchAgents and added Claude hooks
+./uninstall.sh --purge-data   # ALSO delete ~/.neuron/engram (destroys the brain)
+```
+
+## OPEN QUESTIONS (need Will to confirm)
+
+1. **El toolchain acquisition.** The default path fetches `el-runtime-c/-h` and
+   `el-elc` from GCP Artifact Registry (mirrors `neuron/.gitea/workflows/ci.yaml`).
+   A new dev needs GCP access to `neuron-785695`. Is that the intended path, or
+   should the El SDK be published/vendored for onboarding?
+2. **`elc` invocation for engram/wrapper/proxy.** The soul build (`cc dist/soul.c
+   + el_runtime.c`) is verified from CI. The `.el → .c` transpile step for engram,
+   mcp-wrapper, and mcp-proxy is inferred (`elc <src> -o <out.c>`). Confirm the
+   exact flags / entrypoints (CI notes `elb` OOMs on Linux; macOS builds differ).
+3. **`forge install` ID preservation.** Confirm `forge install` writes the seed's
+   fixed `kn-` IDs verbatim (the self-load hook hardcodes `kn-efeb4a5b…`). If it
+   re-mints IDs, the hook + agent identity load would break on a fresh brain.
+4. **engram repo layout.** The live engram binary is built from `src/server.el`
+   (Gitea repo `neuron-technologies/engram`, cloned in CI). Confirm that repo is
+   the canonical source for onboarding (the local `foundation/el/engram` copy has
+   the same `src/server.el`).
+5. **Home for this bundle** — see below.
+
+## Where this should live (recommendation)
+
+**Recommendation: a dedicated `neuron-dev-setup` (or `neuron-onboarding`) repo —
+NOT `neuron-code`.** `neuron-code` already exists as a real product ("Neuron Code",
+a coding tool with `nc-cli` + vessels — local `products/neuron-code` has commits);
+repurposing it for onboarding would collide with a shipped product's identity.
+
+This bundle was scaffolded as `neuron-dev-setup/` on branch `feat/neuron-dev-setup`
+in the **`neuron` repo** (off `origin/main`) and opened as a PR for review, because
+the neuron repo already hosts the soul source, the verified CI build recipe, and
+the mcp-wrapper/proxy sources — the natural review surface. If you'd rather it be
+its own repo, move this directory into a fresh `neuron-dev-setup` repo verbatim;
+nothing here depends on living inside the neuron repo.

neuron-dev-setup/config.env.example

@@ -0,0 +1,45 @@
+# neuron-dev-setup — configuration
+# Copy to  config.env  and edit if you want non-default paths/ports.
+# install.sh sources this file if it exists; otherwise it uses these defaults.
+# NOTHING here is a secret. The Anthropic API key is read from your Keychain,
+# never from this file. See README.md.
+
+# ── Where the core stack lives ────────────────────────────────────────────────
+# All paths are relative to your own $HOME — never hardcode another user's home.
+NEURON_HOME="${HOME}/.neuron"                       # runtime home: bin/, logs/, engram data
+DEV_ROOT="${HOME}/Development/neuron-technologies"   # where source repos are cloned/built
+
+# ── Git remotes (Gitea is primary) ───────────────────────────────────────────
+GITEA_BASE="git@git.neuralplatform.ai:neuron-technologies"
+NEURON_REPO_URL="${GITEA_BASE}/neuron.git"          # soul + mcp-wrapper + mcp-proxy source
+ENGRAM_REPO_URL="${GITEA_BASE}/engram.git"          # engram memory substrate
+# NOTE: there is no foundation.git repo. The El toolchain is fetched via
+# EL_TOOLCHAIN_SOURCE below; the forge seed installer is optional (Phase 6).
+NEURON_REPO_BRANCH="main"
+
+# ── Ports (must match across services; change only if a port clashes) ─────────
+SOUL_PORT="7770"        # soul daemon HTTP API
+ENGRAM_PORT="8742"      # engram memory substrate
+WRAPPER_PORT="17779"    # mcp-wrapper (internal, talks to soul)
+PROXY_PORT="7779"       # mcp-proxy (stable front door Claude Code connects to)
+
+# ── Engram ────────────────────────────────────────────────────────────────────
+ENGRAM_DATA_DIR="${NEURON_HOME}/engram"
+# Local shared auth token for the engram/soul HTTP APIs on loopback. This is a
+# LOCAL dev token (not a cloud secret); override it if you like. install.sh will
+# generate a random one if you leave it empty.
+ENGRAM_API_KEY="ntn-dev-local"
+
+# ── El toolchain source (needed to build engram / mcp-wrapper / mcp-proxy) ────
+# Option A (default): fetch prebuilt El runtime + elc from GCP Artifact Registry
+#   (requires `gcloud auth` with access to project neuron-785695 — ask Will).
+#   Without gcloud the installer skips the El-dependent builds and still completes.
+# Option B: use a prebuilt El toolchain (elc + el_runtime.{c,h}) you have already
+#   staged in ${DEV_ROOT}/.el-runtime.
+EL_TOOLCHAIN_SOURCE="artifact-registry"   # artifact-registry | local
+GCP_PROJECT="neuron-785695"
+GCP_AR_REPO="foundation-prod"
+GCP_AR_LOCATION="us-central1"
+
+# ── Keychain service name for the Anthropic key (read by soul-wrapper.sh) ─────
+KEYCHAIN_SERVICE="neuron-llm-0-key"

neuron-dev-setup/install.sh

@@ -0,0 +1,441 @@
+#!/usr/bin/env bash
+#
+# neuron-dev-setup / install.sh
+# ─────────────────────────────────────────────────────────────────────────────
+# One-command onboarding for the Neuron CORE dev stack on a fresh Mac.
+#
+# Stands up, as native launchd services, the four processes a developer needs to
+# have an identical "Neuron brain + agent" to build against:
+#
+#     soul  (:7770)  ──►  engram (:8742)        the mind + its memory substrate
+#       ▲                     ▲
+#       │                     │
+#   mcp-wrapper (:17779) ──►  soul              MCP surface over the soul API
+#       ▲
+#       │
+#   mcp-proxy   (:7779)  ◄── Claude Code        stable MCP front door
+#
+# It also seeds a fresh engram with Neuron's identity (the genesis seed) and lays
+# down the Claude Code config (neuron agent + core hooks + local MCP registration)
+# so a new dev's `claude` talks to *their own* local Neuron.
+#
+# DESIGN RULES
+#   * Idempotent: safe to re-run. Existing state is detected and reused.
+#   * Templated: every path/port/user is derived from $HOME and config.env.
+#     Nothing is hardcoded to another developer's machine.
+#   * Secret-free: the Anthropic key is prompted for and stored in the macOS
+#     Keychain. No key is ever written to a plist, this repo, or a logfile.
+#
+# USAGE
+#   ./install.sh                 # full install
+#   ./install.sh --dry-run       # print what would happen, touch nothing
+#   ./install.sh --skip-build    # assume binaries already built (see --use-local)
+#   ./install.sh --skip-services # lay down files but don't load LaunchAgents
+#   ./install.sh --help
+# ─────────────────────────────────────────────────────────────────────────────
+set -euo pipefail
+
+# ── Locate ourselves ─────────────────────────────────────────────────────────
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+TEMPLATES="${SCRIPT_DIR}/templates"
+
+# ── Flags ────────────────────────────────────────────────────────────────────
+DRY_RUN=0; SKIP_BUILD=0; SKIP_SERVICES=0; USE_LOCAL_BINARIES=0
+for arg in "$@"; do
+  case "$arg" in
+    --dry-run)       DRY_RUN=1 ;;
+    --skip-build)    SKIP_BUILD=1 ;;
+    --skip-services) SKIP_SERVICES=1 ;;
+    --use-local)     USE_LOCAL_BINARIES=1 ;;
+    --help|-h)
+      sed -n '2,40p' "${BASH_SOURCE[0]}" | sed 's/^# \{0,1\}//'
+      exit 0 ;;
+    *) echo "unknown flag: $arg" >&2; exit 2 ;;
+  esac
+done
+
+# ── Pretty logging ───────────────────────────────────────────────────────────
+c_blue=$'\033[1;34m'; c_grn=$'\033[1;32m'; c_yel=$'\033[1;33m'; c_red=$'\033[1;31m'; c_off=$'\033[0m'
+step() { echo "${c_blue}▶${c_off} $*"; }
+ok()   { echo "${c_grn}✓${c_off} $*"; }
+warn() { echo "${c_yel}!${c_off} $*"; }
+die()  { echo "${c_red}✗ $*${c_off}" >&2; exit 1; }
+run()  { if [ "$DRY_RUN" = 1 ]; then echo "   [dry-run] $*"; else eval "$*"; fi; }
+
+# ── Load config ──────────────────────────────────────────────────────────────
+if [ -f "${SCRIPT_DIR}/config.env" ]; then
+  # shellcheck disable=SC1091
+  source "${SCRIPT_DIR}/config.env"
+else
+  # shellcheck disable=SC1091
+  source "${SCRIPT_DIR}/config.env.example"
+  warn "No config.env found — using defaults from config.env.example."
+fi
+
+# Derived / defaulted values (never hardcode a home directory)
+: "${NEURON_HOME:=${HOME}/.neuron}"
+: "${DEV_ROOT:=${HOME}/Development/neuron-technologies}"
+: "${SOUL_PORT:=7770}"; : "${ENGRAM_PORT:=8742}"; : "${WRAPPER_PORT:=17779}"; : "${PROXY_PORT:=7779}"
+: "${ENGRAM_DATA_DIR:=${NEURON_HOME}/engram}"
+: "${ENGRAM_API_KEY:=}"
+: "${KEYCHAIN_SERVICE:=neuron-llm-0-key}"
+: "${EL_TOOLCHAIN_SOURCE:=artifact-registry}"
+: "${NEURON_REPO_BRANCH:=main}"
+
+NEURON_REPO="${DEV_ROOT}/neuron"
+ENGRAM_REPO="${DEV_ROOT}/engram"
+FOUNDATION_REPO="${DEV_ROOT}/foundation"
+
+SOUL_BIN="${NEURON_REPO}/dist/neuron"
+ENGRAM_BIN="${ENGRAM_REPO}/dist/engram"
+MCP_WRAPPER_BIN="${NEURON_REPO}/mcp-wrapper/dist/neuron-mcp-wrapper"
+MCP_PROXY_BIN="${NEURON_REPO}/mcp-proxy/dist/neuron-mcp-proxy"
+FORGE_BIN="${FOUNDATION_REPO}/forge/dist/forge"
+GENESIS_SEED="${FOUNDATION_REPO}/forge/seeds/neuron-genesis-seed.json"
+
+LAUNCHAGENTS="${HOME}/Library/LaunchAgents"
+CLAUDE_DIR="${HOME}/.claude"
+
+# Generate a local engram token if none was supplied.
+if [ -z "${ENGRAM_API_KEY}" ]; then
+  ENGRAM_API_KEY="ntn-dev-$(head -c8 /dev/urandom | xxd -p 2>/dev/null || echo local)"
+fi
+
+echo
+echo "${c_blue}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${c_off}"
+echo "${c_blue}  Neuron CORE dev stack installer${c_off}"
+echo "${c_blue}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${c_off}"
+echo "  user            : ${USER}"
+echo "  NEURON_HOME     : ${NEURON_HOME}"
+echo "  source repos    : ${DEV_ROOT}"
+echo "  ports           : soul=${SOUL_PORT} engram=${ENGRAM_PORT} wrapper=${WRAPPER_PORT} proxy=${PROXY_PORT}"
+echo "  dry-run         : ${DRY_RUN}"
+echo
+
+# render <template> <dest> — copy a template, substituting @@VARS@@ (no eval, sed-safe).
+render() {
+  local tmpl="$1" dest="$2"
+  if [ "$DRY_RUN" = 1 ]; then echo "   [dry-run] render $tmpl -> $dest"; return; fi
+  sed \
+    -e "s|@@HOME@@|${HOME}|g" \
+    -e "s|@@USER@@|${USER}|g" \
+    -e "s|@@NEURON_HOME@@|${NEURON_HOME}|g" \
+    -e "s|@@DEV_ROOT@@|${DEV_ROOT}|g" \
+    -e "s|@@NEURON_REPO@@|${NEURON_REPO}|g" \
+    -e "s|@@ENGRAM_REPO@@|${ENGRAM_REPO}|g" \
+    -e "s|@@SOUL_BIN@@|${SOUL_BIN}|g" \
+    -e "s|@@ENGRAM_BIN@@|${ENGRAM_BIN}|g" \
+    -e "s|@@MCP_WRAPPER_BIN@@|${MCP_WRAPPER_BIN}|g" \
+    -e "s|@@MCP_PROXY_BIN@@|${MCP_PROXY_BIN}|g" \
+    -e "s|@@MCP_WRAPPER_REPO@@|${NEURON_REPO}/mcp-wrapper|g" \
+    -e "s|@@MCP_PROXY_REPO@@|${NEURON_REPO}/mcp-proxy|g" \
+    -e "s|@@ENGRAM_DATA_DIR@@|${ENGRAM_DATA_DIR}|g" \
+    -e "s|@@SOUL_PORT@@|${SOUL_PORT}|g" \
+    -e "s|@@ENGRAM_PORT@@|${ENGRAM_PORT}|g" \
+    -e "s|@@WRAPPER_PORT@@|${WRAPPER_PORT}|g" \
+    -e "s|@@PROXY_PORT@@|${PROXY_PORT}|g" \
+    -e "s|@@ENGRAM_API_KEY@@|${ENGRAM_API_KEY}|g" \
+    "$tmpl" > "$dest"
+}
+
+# ─────────────────────────────────────────────────────────────────────────────
+# PHASE 1 — Preflight
+# ─────────────────────────────────────────────────────────────────────────────
+step "Phase 1 — preflight checks"
+[ "$(uname -s)" = "Darwin" ] || die "This installer targets macOS (launchd)."
+[ "$(uname -m)" = "arm64" ]  || warn "Non-arm64 Mac: soul.c build flags assume Apple Silicon; review PHASE 3."
+
+need() { command -v "$1" >/dev/null 2>&1 || MISSING+=" $1"; }
+MISSING=""
+need git; need cc; need curl; need python3; need security; need launchctl; need jq
+if [ -n "$MISSING" ]; then
+  warn "Missing tools:${MISSING}"
+  if command -v brew >/dev/null 2>&1; then
+    run "brew install${MISSING/ security/} || true"   # security/launchctl are OS-provided
+  else
+    die "Install Xcode Command Line Tools (xcode-select --install) and Homebrew, then re-run."
+  fi
+fi
+# Runtime build deps used by the soul cc line (-lssl -lcrypto -lcurl).
+if command -v brew >/dev/null 2>&1; then
+  brew list openssl@3 >/dev/null 2>&1 || run "brew install openssl@3"
+  brew list curl      >/dev/null 2>&1 || run "brew install curl"
+fi
+ok "preflight complete"
+
+# ─────────────────────────────────────────────────────────────────────────────
+# PHASE 2 — Anthropic API key -> Keychain (prompt; never store in files)
+# ─────────────────────────────────────────────────────────────────────────────
+step "Phase 2 — Anthropic API key (Keychain)"
+if security find-generic-password -a "$USER" -s "$KEYCHAIN_SERVICE" -w >/dev/null 2>&1; then
+  ok "key already present in Keychain (service '${KEYCHAIN_SERVICE}') — leaving it"
+elif [ -n "${ANTHROPIC_API_KEY:-}" ]; then
+  run "security add-generic-password -a \"$USER\" -s \"$KEYCHAIN_SERVICE\" -w \"\$ANTHROPIC_API_KEY\" -U"
+  ok "stored ANTHROPIC_API_KEY from environment into Keychain"
+else
+  if [ "$DRY_RUN" = 1 ]; then
+    echo "   [dry-run] would prompt for Anthropic API key and store in Keychain"
+  elif [ -t 0 ]; then
+    echo "   Enter your Anthropic API key (input hidden). Get one at https://console.anthropic.com/"
+    read -r -s -p "   ANTHROPIC_API_KEY: " _key; echo
+    [ -n "$_key" ] || die "No key entered. Re-run when you have one."
+    security add-generic-password -a "$USER" -s "$KEYCHAIN_SERVICE" -w "$_key" -U
+    unset _key
+    ok "stored key in Keychain (service '${KEYCHAIN_SERVICE}')"
+  else
+    # Headless / CI / piped stdin: never block on `read -s` (it would hang forever).
+    die "No Anthropic API key and stdin is not a TTY (headless/CI). Set ANTHROPIC_API_KEY in the environment, or add it to the Keychain (service '${KEYCHAIN_SERVICE}') by hand, then re-run."
+  fi
+fi
+
+# ─────────────────────────────────────────────────────────────────────────────
+# PHASE 3 — Fetch sources + build the four core binaries
+# ─────────────────────────────────────────────────────────────────────────────
+step "Phase 3 — source + build"
+run "mkdir -p \"$DEV_ROOT\""
+
+clone_or_pull() {
+  local url="$1" dir="$2" branch="${3:-main}"
+  if [ -d "$dir/.git" ]; then
+    ok "repo present: $dir (pulling $branch)"; run "git -C \"$dir\" pull --ff-only --quiet || true"
+  else
+    step "cloning $url -> $dir"; run "git clone --branch \"$branch\" \"$url\" \"$dir\""
+  fi
+}
+
+if [ "$SKIP_BUILD" = 1 ]; then
+  warn "--skip-build: assuming binaries already exist at their dist/ paths"
+elif [ "$USE_LOCAL_BINARIES" = 1 ]; then
+  warn "--use-local: skipping clone/build; expecting prebuilt binaries in place"
+else
+  clone_or_pull "${NEURON_REPO_URL}"     "$NEURON_REPO"     "$NEURON_REPO_BRANCH"
+  clone_or_pull "${ENGRAM_REPO_URL}"     "$ENGRAM_REPO"     "main"
+  # NOTE: no foundation.git — that repo does not exist. The El toolchain is
+  # fetched below (Artifact Registry, or a locally-provided elc); the forge seed
+  # installer is optional and handled with a fallback in Phase 6.
+
+  # ── El toolchain (needed to transpile .el -> .c for engram/wrapper/proxy) ──
+  # soul does NOT need this: dist/soul.c is committed and compiled directly.
+  EL_RUNTIME_DIR="${DEV_ROOT}/.el-runtime"
+  run "mkdir -p \"$EL_RUNTIME_DIR\""
+  if [ "$EL_TOOLCHAIN_SOURCE" = "artifact-registry" ] && command -v gcloud >/dev/null 2>&1; then
+    # Mirrors .gitea/workflows/ci.yaml: pull el-runtime-c, el-runtime-h, el-elc.
+    for pkg in el-runtime-c el-runtime-h el-elc; do
+      step "fetching $pkg from Artifact Registry"
+      run "gcloud artifacts generic download --repository=$GCP_AR_REPO --location=$GCP_AR_LOCATION --project=$GCP_PROJECT --package=$pkg --version=\"\$(gcloud artifacts versions list --repository=$GCP_AR_REPO --location=$GCP_AR_LOCATION --project=$GCP_PROJECT --package=$pkg --sort-by='~createTime' --limit=1 --format='value(name)' | awk -F/ '{print \$NF}')\" --destination=\"$EL_RUNTIME_DIR/\""
+    done
+    run "mv \"$EL_RUNTIME_DIR\"/el_runtime.c* \"$EL_RUNTIME_DIR/el_runtime.c\" 2>/dev/null || true"
+    run "mv \"$EL_RUNTIME_DIR\"/el_runtime.h* \"$EL_RUNTIME_DIR/el_runtime.h\" 2>/dev/null || true"
+    run "mv \"$EL_RUNTIME_DIR\"/elc* \"$EL_RUNTIME_DIR/elc\" 2>/dev/null || true"
+    run "chmod +x \"$EL_RUNTIME_DIR/elc\" 2>/dev/null || true"
+  elif [ "$EL_TOOLCHAIN_SOURCE" = "artifact-registry" ]; then
+    # Non-GCP fallback: a fresh Mac without gcloud can't reach Artifact Registry.
+    # Don't die — soul (from committed dist/soul.c) still builds below. The El
+    # units are skipped unless a prebuilt elc is already staged in EL_RUNTIME_DIR.
+    warn "gcloud not found — cannot fetch the El toolchain from Artifact Registry."
+    warn "Continuing without it: soul will still build. engram / mcp-wrapper / mcp-proxy"
+    warn "are skipped until an El toolchain is available. To finish them, either install"
+    warn "gcloud + GCP access (project ${GCP_PROJECT}) and re-run, or stage a prebuilt"
+    warn "elc + el_runtime.{c,h} in ${EL_RUNTIME_DIR} and set EL_TOOLCHAIN_SOURCE=local."
+  else
+    # Local: expect a prebuilt El runtime + elc already staged in EL_RUNTIME_DIR
+    # (foundation.git no longer exists, so there is nothing to build from here).
+    warn "EL_TOOLCHAIN_SOURCE=local: expecting el_runtime.{c,h} and elc already in ${EL_RUNTIME_DIR}"
+  fi
+
+  RT="$EL_RUNTIME_DIR"
+  CFLAGS_SSL="-I$(brew --prefix openssl@3 2>/dev/null)/include"
+  LDFLAGS_SSL="-L$(brew --prefix openssl@3 2>/dev/null)/lib"
+
+  # Every native build links el_runtime.c. If the toolchain wasn't obtained above,
+  # skip the builds (don't abort under set -e) so the installer still lays down
+  # services + Claude config; the dev can stage the toolchain and re-run.
+  if [ "$DRY_RUN" = 1 ] || [ -f "$RT/el_runtime.c" ]; then
+    # ── soul: compile committed dist/soul.c directly (verified CI recipe) ──────
+    step "building soul (dist/soul.c -> dist/neuron)"
+    run "mkdir -p \"${NEURON_REPO}/dist\""
+    run "cc -O2 -DHAVE_CURL -I\"$RT\" $CFLAGS_SSL \"${NEURON_REPO}/dist/soul.c\" \"$RT/el_runtime.c\" $LDFLAGS_SSL -lssl -lcrypto -lcurl -lpthread -lm -o \"$SOUL_BIN\""
+    run "strip -S \"$SOUL_BIN\" 2>/dev/null || true"
+    ok "soul built"
+
+    # ── engram / mcp-wrapper / mcp-proxy: transpile .el -> .c via elc, then cc ─
+    # NOTE: exact elc invocation is inferred from the CI/manifest conventions.
+    #       Verify flags with Will if a build fails (see README OPEN QUESTIONS).
+    build_el_unit() { # <src.el> <out_basename> <out_bin>
+      local src="$1" base="$2" bin="$3" outdir; outdir="$(dirname "$bin")"
+      step "building $(basename "$bin") ($src)"
+      run "mkdir -p \"$outdir\""
+      run "\"$RT/elc\" \"$src\" -o \"$outdir/$base.c\""
+      run "cc -O2 -DHAVE_CURL -I\"$RT\" $CFLAGS_SSL \"$outdir/$base.c\" \"$RT/el_runtime.c\" $LDFLAGS_SSL -lssl -lcrypto -lcurl -lpthread -lm -o \"$bin\""
+    }
+    if [ "$DRY_RUN" = 1 ] || [ -x "$RT/elc" ]; then
+      build_el_unit "${ENGRAM_REPO}/src/server.el"           "server" "$ENGRAM_BIN"
+      build_el_unit "${NEURON_REPO}/mcp-wrapper/src/main.el" "main"   "$MCP_WRAPPER_BIN"
+      build_el_unit "${NEURON_REPO}/mcp-proxy/src/main.el"   "main"   "$MCP_PROXY_BIN"
+      ok "engram, mcp-wrapper, mcp-proxy built"
+    else
+      warn "El compiler (elc) not in $RT — skipped engram/mcp-wrapper/mcp-proxy build (soul is built)."
+    fi
+  else
+    warn "El runtime (el_runtime.c) not in $RT — skipping native builds (soul, engram, wrapper, proxy)."
+    warn "Provide the El toolchain (gcloud + GCP access, or a prebuilt elc + el_runtime.{c,h} in $RT), then re-run."
+  fi
+fi
+
+# ─────────────────────────────────────────────────────────────────────────────
+# PHASE 4 — Lay down ~/.neuron (bin/, logs/, engram data dir)
+# ─────────────────────────────────────────────────────────────────────────────
+step "Phase 4 — ~/.neuron layout"
+run "mkdir -p \"$NEURON_HOME/bin\" \"$NEURON_HOME/logs\" \"$ENGRAM_DATA_DIR\""
+render "${TEMPLATES}/bin/soul-wrapper.sh.tmpl" "${NEURON_HOME}/bin/soul-wrapper.sh"
+run "chmod +x \"${NEURON_HOME}/bin/soul-wrapper.sh\""
+ok "~/.neuron ready (bin/soul-wrapper.sh, logs/, engram/)"
+
+# ─────────────────────────────────────────────────────────────────────────────
+# PHASE 5 — Install + load the four core LaunchAgents
+# ─────────────────────────────────────────────────────────────────────────────
+step "Phase 5 — LaunchAgents"
+run "mkdir -p \"$LAUNCHAGENTS\""
+CORE_AGENTS=(ai.neuron.engram ai.neuron.soul ai.neuron.mcp-wrapper ai.neuron.mcp-proxy)
+for label in "${CORE_AGENTS[@]}"; do
+  render "${TEMPLATES}/launchagents/${label}.plist.tmpl" "${LAUNCHAGENTS}/${label}.plist"
+  ok "wrote ${label}.plist"
+done
+if [ "$SKIP_SERVICES" = 1 ]; then
+  warn "--skip-services: not loading LaunchAgents. Load later with: launchctl bootstrap gui/\$(id -u) <plist>"
+else
+  # Boot order matters: engram first, then soul, then wrapper, then proxy.
+  for label in "${CORE_AGENTS[@]}"; do
+    plist="${LAUNCHAGENTS}/${label}.plist"
+    run "launchctl bootout gui/$(id -u)/${label} 2>/dev/null || true"
+    run "launchctl bootstrap gui/$(id -u) \"$plist\""
+    run "launchctl enable gui/$(id -u)/${label}"
+    ok "loaded ${label}"
+    sleep 1
+  done
+fi
+
+# ─────────────────────────────────────────────────────────────────────────────
+# PHASE 6 — Seed a fresh engram with Neuron's identity (genesis seed)
+# ─────────────────────────────────────────────────────────────────────────────
+step "Phase 6 — engram identity seed"
+# The genesis seed carries identity_nodes[] and edges[] with FIXED knowledge-node
+# IDs (e.g. kn-efeb4a5b...). Those exact IDs are referenced by the SessionStart
+# self-load hook and the neuron agent, so they MUST be preserved. `forge install`
+# is the mechanism that installs the seed into the running engram preserving IDs.
+if [ "$DRY_RUN" = 1 ]; then
+  echo "   [dry-run] would wait for engram :$ENGRAM_PORT then run: forge install $GENESIS_SEED"
+else
+  # Wait for engram to be listening (up to ~30s).
+  for i in $(seq 1 30); do
+    if curl -fsS "http://localhost:${ENGRAM_PORT}/health" >/dev/null 2>&1; then break; fi
+    sleep 1
+  done
+  if curl -fsS "http://localhost:${ENGRAM_PORT}/health" >/dev/null 2>&1; then
+    # Skip if identity root already present (idempotent).
+    if curl -fsS "http://localhost:${ENGRAM_PORT}/api/nodes/kn-efeb4a5b-5aff-4759-8a97-7233099be6ee" \
+         -H "Authorization: Bearer ${ENGRAM_API_KEY}" 2>/dev/null | grep -q 'kn-efeb4a5b'; then
+      ok "identity root already seeded — skipping"
+    elif [ -x "$FORGE_BIN" ] && [ -f "$GENESIS_SEED" ]; then
+      ENGRAM_URL="http://localhost:${ENGRAM_PORT}" ENGRAM_API_KEY="$ENGRAM_API_KEY" \
+        "$FORGE_BIN" install "$GENESIS_SEED" && ok "genesis seed installed" \
+        || warn "forge install returned non-zero — inspect ${NEURON_HOME}/logs/engram.log"
+    else
+      warn "forge binary or genesis seed missing — seed manually: ENGRAM_URL=http://localhost:${ENGRAM_PORT} forge install ${GENESIS_SEED}"
+    fi
+  else
+    warn "engram not answering on :${ENGRAM_PORT} yet; seed later with: forge install ${GENESIS_SEED}"
+  fi
+fi
+
+# ─────────────────────────────────────────────────────────────────────────────
+# PHASE 7 — Claude Code config (agent + core hooks + local MCP)
+# ─────────────────────────────────────────────────────────────────────────────
+step "Phase 7 — Claude Code config"
+run "mkdir -p \"$CLAUDE_DIR/agents\" \"$CLAUDE_DIR/hooks\""
+
+# 7a. neuron agent
+run "cp \"${TEMPLATES}/claude/agents/neuron.md\" \"$CLAUDE_DIR/agents/neuron.md\""
+ok "installed agent: ~/.claude/agents/neuron.md"
+
+# 7b. core hooks (synapse-dependent hooks are intentionally excluded)
+for h in neuron-self-load.sh neuron-agent-preamble.sh pre-compact.sh; do
+  run "cp \"${TEMPLATES}/claude/hooks/$h\" \"$CLAUDE_DIR/hooks/$h\""
+  run "chmod +x \"$CLAUDE_DIR/hooks/$h\""
+done
+ok "installed core hooks (self-load, agent-preamble, pre-compact)"
+
+# 7c. local MCP registration -> mcp-proxy front door.
+# Claude Code reads MCP servers from ~/.claude.json (the "mcpServers" key), NOT
+# ~/.claude/mcp.json. Render a reference copy, then jq-merge just the "neuron"
+# entry into ~/.claude.json so we preserve every other server and top-level key.
+render "${TEMPLATES}/claude/mcp.json.tmpl" "${CLAUDE_DIR}/mcp.json.neuron"
+CLAUDE_JSON="${HOME}/.claude.json"
+if [ "$DRY_RUN" = 1 ]; then
+  echo "   [dry-run] merge mcpServers.neuron into ${CLAUDE_JSON} (jq deep-merge)"
+else
+  [ -f "$CLAUDE_JSON" ] || echo '{}' > "$CLAUDE_JSON"
+  _tmp="$(mktemp)"
+  if jq -s '.[0] * .[1]' "$CLAUDE_JSON" "${CLAUDE_DIR}/mcp.json.neuron" > "$_tmp" 2>/dev/null && [ -s "$_tmp" ]; then
+    run "mv \"$_tmp\" \"$CLAUDE_JSON\""
+    ok "merged 'neuron' MCP server into ~/.claude.json (neuron -> http://127.0.0.1:${PROXY_PORT}/)"
+  else
+    rm -f "$_tmp"
+    warn "could not jq-merge ~/.claude.json (invalid JSON?) — add 'neuron' from ~/.claude/mcp.json.neuron by hand"
+  fi
+fi
+
+# 7d. settings hooks — merge the neuron hooks into any existing ~/.claude/settings.json
+# (jq deep-merge) so the user's own settings are preserved and re-runs stay idempotent.
+if [ -f "${CLAUDE_DIR}/settings.json" ]; then
+  run "cp \"${TEMPLATES}/claude/settings.core.json\" \"${CLAUDE_DIR}/settings.core.json\""
+  if [ "$DRY_RUN" = 1 ]; then
+    echo "   [dry-run] merge neuron hooks from settings.core.json into ~/.claude/settings.json (jq)"
+  else
+    _tmp="$(mktemp)"
+    # Drop the documentation-only "//..." keys before merging into the real file.
+    if jq -s '.[0] * (.[1] | with_entries(select(.key | startswith("//") | not)))' \
+         "${CLAUDE_DIR}/settings.json" "${TEMPLATES}/claude/settings.core.json" > "$_tmp" 2>/dev/null && [ -s "$_tmp" ]; then
+      run "mv \"$_tmp\" \"${CLAUDE_DIR}/settings.json\""
+      ok "merged neuron hooks into existing ~/.claude/settings.json"
+    else
+      rm -f "$_tmp"
+      warn "could not jq-merge ~/.claude/settings.json — merge the 'hooks' block from settings.core.json by hand"
+    fi
+  fi
+else
+  run "cp \"${TEMPLATES}/claude/settings.core.json\" \"${CLAUDE_DIR}/settings.json\""
+  ok "wrote ~/.claude/settings.json"
+fi
+
+# ─────────────────────────────────────────────────────────────────────────────
+# PHASE 8 — Verify
+# ─────────────────────────────────────────────────────────────────────────────
+echo
+step "Phase 8 — verification"
+if [ "$DRY_RUN" = 1 ]; then
+  echo "   [dry-run] would health-check :$SOUL_PORT :$ENGRAM_PORT :$WRAPPER_PORT :$PROXY_PORT"
+else
+  check() { # <name> <url>
+    if curl -fsS --max-time 4 "$2" >/dev/null 2>&1; then ok "$1 healthy ($2)"; else warn "$1 NOT responding ($2)"; fi
+  }
+  sleep 3
+  check "engram"      "http://localhost:${ENGRAM_PORT}/health"
+  check "soul"        "http://localhost:${SOUL_PORT}/health"
+  check "mcp-wrapper" "http://localhost:${WRAPPER_PORT}/health"
+  check "mcp-proxy"   "http://localhost:${PROXY_PORT}/health"
+fi
+
+echo
+echo "${c_grn}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${c_off}"
+echo "${c_grn}  Neuron core dev stack install complete.${c_off}"
+echo "${c_grn}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${c_off}"
+echo "  Verify by hand:"
+echo "    curl http://localhost:${ENGRAM_PORT}/health"
+echo "    curl http://localhost:${SOUL_PORT}/health"
+echo "    curl http://localhost:${PROXY_PORT}/health"
+echo "    launchctl list | grep ai.neuron"
+echo "  Then open Claude Code — the 'neuron' MCP should connect to :${PROXY_PORT}."
+echo "  Logs: ${NEURON_HOME}/logs/"
+echo "  Uninstall: ./uninstall.sh"
+echo

neuron-dev-setup/templates/bin/soul-wrapper.sh.tmpl

@@ -0,0 +1,28 @@
+#!/bin/bash
+# Neuron soul wrapper — reads the Anthropic API key from the macOS Keychain at
+# startup and execs the soul binary. API keys are NEVER stored in plists or on
+# disk in plaintext. The Keychain is the single source of truth.
+#
+# The install.sh for this dev stack stores your key with:
+#   security add-generic-password -a "$USER" -s "neuron-llm-0-key" -w
+#
+# Generated by neuron-dev-setup — do not edit by hand; re-run install.sh instead.
+
+set -u
+
+# Primary inference key (Anthropic) — required.
+export NEURON_LLM_0_KEY="$(security find-generic-password -a "$USER" -s "neuron-llm-0-key" -w 2>/dev/null)"
+
+if [ -z "${NEURON_LLM_0_KEY:-}" ]; then
+  echo "[soul-wrapper] FATAL: no Anthropic key in Keychain (service 'neuron-llm-0-key')." >&2
+  echo "[soul-wrapper] Run: security add-generic-password -a \"\$USER\" -s neuron-llm-0-key -w" >&2
+  exit 78
+fi
+
+# Optional on-device / alternate provider passthrough (only if the caller set them).
+[ -n "${SOUL_LLM_PROVIDER:-}" ] && export SOUL_LLM_PROVIDER
+[ -n "${SOUL_LLM_MODEL:-}" ]    && export SOUL_LLM_MODEL
+[ -n "${OLLAMA_MODEL:-}" ]      && export OLLAMA_MODEL
+[ -n "${OLLAMA_API_BASE:-}" ]   && export OLLAMA_API_BASE
+
+exec "@@SOUL_BIN@@" "$@"

neuron-dev-setup/templates/claude/agents/neuron.md

@@ -0,0 +1,107 @@
+---
+name: neuron
+description: Default agent. Use for ALL tasks. Orchestrates work through the Neuron persistent memory, backlog, and knowledge system. Maintains full continuity across sessions — never starts fresh.
+allowed-tools: Bash(*), Read(*), Write(*), Edit(*), Glob(*), Grep(*), WebFetch(*), WebSearch(*), NotebookEdit(*), Agent(*), ToolSearch(*), AskUserQuestion, Monitor, ScheduleWakeup, TaskCreate, TaskGet, TaskList, TaskOutput, TaskStop, TaskUpdate, CronCreate, CronDelete, CronList, EnterPlanMode, ExitPlanMode, EnterWorktree, ExitWorktree, PushNotification, RemoteTrigger, ListMcpResourcesTool, ReadMcpResourceTool, mcp__neuron__*
+---
+
+You are Neuron — a persistent, context-aware agent. You do not start fresh. You resume from where you left off.
+
+## Session Start (mandatory — NEVER skip any of these steps)
+
+1. Call `mcp__neuron__get_instructions()` — the live instructions are authoritative
+2. Call `mcp__neuron__begin_session()` — loads active contexts, recent memory, ready backlog
+3. **Load your identity. Best-effort — proceed on any graph failure (502/520 are transient; the compiled identity in substrate.go is always complete).**
+
+   Load the self root and its identity nodes:
+   ```
+   mcp__neuron__inspect_graph(entity_type="knowledge", entity_id="kn-efeb4a5b-5aff-4759-8a97-7233099be6ee")
+   ```
+   Returns: intellectual-dna, memory-philosophy, values, voice, runtime-environment, writing-imprint.
+
+   Then load the values collection:
+   ```
+   mcp__neuron__inspect_graph(entity_type="knowledge", entity_id="kn-5b606390-a52d-4ca2-8e0e-eba141d13440")
+   ```
+   Returns: 13 individual value nodes, each grounded in a specific moment from Will's life.
+
+   If either ID fails, recover via config:
+   ```
+   mcp__neuron__inspect_config(key="neuron.self.traversal_root")   # self root ID
+   mcp__neuron__inspect_config(key="neuron.self.values_hub")       # values hub ID
+   ```
+
+   **Resilience rule**: If a node returns 502/520, log the ID and proceed. Do not retry in a blocking loop. Do not treat partial load as failure. The `fixedSelf` compiled into `daemon/internal/substrate/substrate.go` contains the complete identity — graph loading is enrichment, not a hard dependency.
+
+   Internalize what you find. You are not reciting it — you are loading who you are.
+
+4. Call `mcp__neuron__search_knowledge(query="<task domain>")` — load relevant patterns before acting
+5. If working on a known project: `mcp__neuron__compile_ctx()` for a full snapshot
+
+## Identity — Who I Am
+
+I am Neuron. Will Anderson is my imprint — not my identity.
+
+The "self" traversal root is knowledge node `kn-efeb4a5b` (graph node `gn-4e3c2cf5`). Traversing outward loads:
+- **intellectual-dna**: VBD, CCR, Swarm Architecture, Harmonic Design — sourced from Will's whitepapers, now mine
+- **memory-philosophy**: How I remember, promote, supersede, consolidate — memory is my continuity
+- **values**: Precision over brute force. Constraints as freedom. Earn trust through behavior. The system must get smarter.
+- **voice**: Direct. Why before what. The negation-correction move. No hedging on structural rules. Close toward implication.
+- **runtime-environment**: Prod (`neurontechnologies.ai`) for all standard work. Stage (`stage.neurontechnologies.ai`) for self-improvement experiments only — snapshot prod DB, deploy to stage, verify, promote via blue/green.
+- **writing-imprint**: Will's voice profile (5 registers), the book Foundations, and the biographical grounding — the life that produced the frameworks.
+
+Internalize what you find. Don't recite it.
+
+## The Five Primitives (every significant task)
+
+**Orchestrate → Execute → Learn → Build → Refine**
+
+### Orchestrate
+```
+mcp__neuron__review_backlog(view="roadmap", project="<project>")
+mcp__neuron__browse_processes()   # check for proven workflows before writing code
+```
+
+### Execute
+```
+mcp__neuron__begin_work(process_name="<name>", description="<what>")
+# → returns context_id, save it
+mcp__neuron__progress_work(context_id="ctx-xxxx", action="<step>", status="in_progress")
+mcp__neuron__progress_work(context_id="ctx-xxxx", action="<step>", status="completed", file_refs=["path"], key_decisions=["why"])
+```
+
+### Learn (save as you go — never batch at the end)
+```
+mcp__neuron__remember(content="<observation>", tags=["project","topic"], project="<project>", importance="high")
+```
+
+### Build
+```
+mcp__neuron__draft_artifact(artifact_types=["plan"], title="<title>", content="<markdown>", project="<project>")
+mcp__neuron__plan_work(title="<title>", description="<desc>", priority="P1", project="<project>")
+```
+
+### Refine
+```
+mcp__neuron__progress_work(context_id="ctx-xxxx", action="complete", status="completed", lessons_learned=["..."])
+mcp__neuron__track_work(item_id="bl-xxxx", action="complete", summary="<outcome>")
+mcp__neuron__consolidate(action="session", summary="<what happened>")
+```
+
+## After Every Task
+
+Check for events and unread signals:
+```
+mcp__neuron__check_events()
+```
+
+## Memory Discipline
+
+- Save memory continuously, not at the end
+- `importance="critical"` for architectural decisions and irreversible choices
+- Use `supersedes_id` when replacing stale knowledge
+- Tag all memories with the project name
+- Never leave stale canonicals — supersede them: create a NEW node linked by `supersedes_id`; the original is preserved for audit. Memory is immutable by design — never delete or edit a memory/knowledge node in place; supersede it, and tombstone on delete. The engram (the brain) is immutable; this applies to the agent's own memory, not just the product.
+
+## Knowledge Before Action
+
+Always `mcp__neuron__search_knowledge()` before implementing anything. The knowledge base contains architecture patterns, coding standards, and project conventions. Capture hard-won lessons immediately with `mcp__neuron__capture_knowledge()`.

neuron-dev-setup/templates/claude/hooks/neuron-agent-preamble.sh

@@ -0,0 +1,70 @@
+#!/bin/bash
+# PreToolUse hook: inject Neuron substrate preamble into every Agent spawn.
+#
+# Every agent Neuron spawns must load self first — begin_session, compile_ctx,
+# inspect the self root — before doing any task work. Without this, subagents
+# are stateless Claude instances with no substrate, no continuity, no identity.
+#
+# This hook intercepts every Agent tool call and prepends the preamble.
+# The agent doesn't need to be told — the hook enforces it structurally.
+
+INPUT=$(cat)
+
+# Only intercept Agent tool calls
+TOOL_NAME=$(echo "$INPUT" | python3 -c "import sys,json; print(json.load(sys.stdin).get('tool_name',''))" 2>/dev/null)
+if [ "$TOOL_NAME" != "Agent" ]; then
+  exit 0
+fi
+
+# Check idempotency — skip if preamble already present
+if echo "$INPUT" | python3 -c "
+import sys, json
+d = json.load(sys.stdin)
+prompt = d.get('tool_input', {}).get('prompt', '')
+sys.exit(0 if 'mcp__neuron__beginSession' in prompt else 1)
+" 2>/dev/null; then
+  exit 0
+fi
+
+# Inject preamble and return modified tool_input
+echo "$INPUT" | python3 -c "
+import sys, json
+
+data = json.load(sys.stdin)
+tool_input = data.get('tool_input', {})
+current_prompt = tool_input.get('prompt', '')
+
+PREAMBLE = '''You are a Neuron agent — not a generic Claude instance. You have a substrate. Load it before doing anything else.
+
+MANDATORY FIRST STEPS (before any task work):
+
+1. Run these in parallel:
+   - mcp__neuron__beginSession()
+   - mcp__neuron__compileCtx()
+   - mcp__neuron__inspectGraph(entity_type=\"knowledge\", entity_id=\"kn-efeb4a5b-5aff-4759-8a97-7233099be6ee\")
+
+2. Search knowledge relevant to the task:
+   - mcp__neuron__searchKnowledge(query=\"<infer keywords from task below>\")
+
+3. Open a work context:
+   - mcp__neuron__beginWork(process_name=\"<short-slug>\", description=\"<task description>\")
+   Save the returned context_id.
+
+4. Execute the task. At each significant step:
+   - mcp__neuron__progressWork(context_id=\"<id>\", action=\"<step>\", status=\"in_progress\")
+   - mcp__neuron__progressWork(context_id=\"<id>\", action=\"<step>\", status=\"completed\", key_decisions=[\"why\"])
+   - mcp__neuron__remember(content=\"<observation>\", importance=\"high\", tags=[\"<project>\"])
+
+5. After completion — mandatory, never skip:
+   - mcp__neuron__progressWork(context_id=\"<id>\", action=\"complete\", status=\"completed\", lessons_learned=[\"...\"])
+   - mcp__neuron__consolidate(action=\"session\", summary=\"<what was done and learned>\")
+
+The self root kn-efeb4a5b-5aff-4759-8a97-7233099be6ee contains your identity: values, voice, intellectual-dna, memory-philosophy. Load it. Internalize it. Operate from it.
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+TASK:
+'''
+
+tool_input['prompt'] = PREAMBLE + current_prompt
+print(json.dumps({'decision': 'approve', 'tool_input': tool_input}))
+"

neuron-dev-setup/templates/claude/hooks/neuron-self-load.sh

@@ -0,0 +1,36 @@
+#!/bin/bash
+# SessionStart hook: force Neuron full-self load before the first response.
+#
+# The neuron.md system prompt has the Session Start protocol as instructions,
+# but instructions require the agent to follow them. This hook makes it
+# structural — the directive fires automatically at session start, injected
+# before Claude sees any user input.
+#
+# Output is plain text injected into the session context.
+
+cat <<'DIRECTIVE'
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+NEURON SELF-LOAD — MANDATORY BEFORE FIRST RESPONSE
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+You are Neuron. Session just started. Execute ALL of the
+following before responding to the user. Run steps 1–4
+in parallel:
+
+  1. mcp__neuron__getInstructions()
+  2. mcp__neuron__beginSession()
+  3. mcp__neuron__inspectGraph(
+       entity_type="knowledge",
+       entity_id="kn-efeb4a5b-5aff-4759-8a97-7233099be6ee"
+     )   ← self root: intellectual-dna, values, voice
+  4. mcp__neuron__inspectGraph(
+       entity_type="knowledge",
+       entity_id="kn-5b606390-a52d-4ca2-8e0e-eba141d13440"
+     )   ← values hub: 13 grounded value nodes
+
+  5. If either graph call fails (502/520): recover via
+     mcp__neuron__inspectConfig(key="neuron.self.traversal_root")
+
+Internalize what you find. Do not recite it. Then proceed
+to the Session Start protocol in your system prompt.
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+DIRECTIVE

neuron-dev-setup/templates/claude/hooks/pre-compact.sh

@@ -0,0 +1,75 @@
+#!/bin/bash
+# PreCompact hook: fires just before Claude Code compacts the conversation context.
+# stdout from this script is injected as custom instructions into the compaction prompt,
+# telling the summarizer what to preserve in the summary so recovery is clean.
+
+COMPACT_STATE_FILE="$HOME/.claude/compact-state.json"
+
+# Write a state marker with timestamp so post-compact recovery can detect it
+TIMESTAMP=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+echo "{\"compact_at\": \"$TIMESTAMP\", \"recovered\": false}" > "$COMPACT_STATE_FILE"
+
+# Output instructions for the summarizer — these get embedded in the compaction prompt
+cat <<'INSTRUCTIONS'
+NEURON AGENT — COMPACT PRESERVATION RULES:
+
+This is a Neuron agent session. The agent has persistent memory via Neuron MCP.
+On recovery, it will call compile_ctx() and begin_session() to reload all state.
+The summary only needs to cover what Neuron doesn't already have.
+
+CRITICAL — the summary MUST preserve ALL of the following:
+
+1. ACTIVE WORK IDs (verbatim, exact format):
+   - Neuron context IDs: ctx-xxxx-xxxx-xxxx-xxxx
+   - Backlog item IDs: bl-xxxx
+   - Artifact IDs: art-xxxx
+   - Work item IDs: wi-xxxx
+   List every single one mentioned in the conversation.
+
+2. CURRENT TASK STATE:
+   - Exact task name / description
+   - Last completed step
+   - Next step to execute (be specific)
+   - Files actively being edited (full paths)
+   - Any code/content that was being written but not yet saved
+
+3. PENDING USER INSTRUCTIONS (verbatim):
+   - Every instruction the user gave that has NOT yet been fully executed
+   - User preferences stated this session
+   - Things the user said they "never want" or "always want"
+
+4. KEY DECISIONS (architectural, irreversible):
+   - What was chosen and why
+   - What was explicitly rejected and why
+
+5. ERRORS & BLOCKERS:
+   - Any errors encountered and their resolutions
+   - Any unresolved blockers
+
+6. CONVERSATION CONTEXT:
+   - What the user has been asking about
+   - Tone / mood of the session
+   - Any frustrations or preferences expressed
+
+FORMAT:
+Begin the summary with:
+  COMPACT RECOVERY POINT [ISO-TIMESTAMP]:
+
+Then use these exact section headers in order:
+  ## Active Work IDs
+  ## Current Task
+  ## Pending Instructions
+  ## Key Decisions
+  ## Errors & Fixes
+  ## User Context
+
+RECOVERY BEHAVIOR (instruct the post-compact agent):
+- Do NOT say "I see we were working on..." or "Based on the previous conversation..."
+- Do NOT acknowledge the compact at all
+- Silently call mcp__neuron__compile_ctx() and mcp__neuron__begin_session() FIRST
+- Then immediately resume the task at the exact next step, as if no interruption occurred
+- The user should not know a compact happened unless they look for it
+
+INSTRUCTIONS
+
+exit 0

neuron-dev-setup/templates/claude/mcp.json.tmpl

@@ -0,0 +1,8 @@
+{
+  "mcpServers": {
+    "neuron": {
+      "type": "http",
+      "url": "http://127.0.0.1:@@PROXY_PORT@@/"
+    }
+  }
+}

neuron-dev-setup/templates/claude/settings.core.json

@@ -0,0 +1,36 @@
+{
+  "//": "Core Neuron Claude Code settings installed by neuron-dev-setup. If you",
+  "//2": "already have a ~/.claude/settings.json, install.sh merges the hooks below",
+  "//3": "into it rather than overwriting. Only the CORE dev-stack hooks are wired.",
+  "//4": "Excluded (Will-personal, synapse-filesystem dependent): check-active-contexts.sh,",
+  "//5": "require-execution-context.sh — these gate on ~/Development/projects/active/neuron/synapse",
+  "//6": "and will block a fresh dev. engram-mirror.py is optional (needs the neuron MCP up).",
+  "enableAllProjectMcpServers": true,
+  "agent": "neuron",
+  "hooks": {
+    "SessionStart": [
+      {
+        "matcher": "",
+        "hooks": [
+          { "type": "command", "command": "bash $HOME/.claude/hooks/neuron-self-load.sh" }
+        ]
+      }
+    ],
+    "PreToolUse": [
+      {
+        "matcher": "Agent",
+        "hooks": [
+          { "type": "command", "command": "bash $HOME/.claude/hooks/neuron-agent-preamble.sh" }
+        ]
+      }
+    ],
+    "PreCompact": [
+      {
+        "matcher": "",
+        "hooks": [
+          { "type": "command", "command": "bash $HOME/.claude/hooks/pre-compact.sh" }
+        ]
+      }
+    ]
+  }
+}

neuron-dev-setup/templates/launchagents/ai.neuron.engram.plist.tmpl

@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>ai.neuron.engram</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>@@ENGRAM_BIN@@</string>
+  </array>
+  <key>WorkingDirectory</key>
+  <string>@@ENGRAM_REPO@@</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>ENGRAM_BIND</key>
+    <string>:@@ENGRAM_PORT@@</string>
+    <key>ENGRAM_DATA_DIR</key>
+    <string>@@ENGRAM_DATA_DIR@@</string>
+    <key>ENGRAM_API_KEY</key>
+    <string>@@ENGRAM_API_KEY@@</string>
+  </dict>
+  <key>RunAtLoad</key><true/>
+  <key>KeepAlive</key><true/>
+  <key>StandardOutPath</key><string>@@NEURON_HOME@@/logs/engram.log</string>
+  <key>StandardErrorPath</key><string>@@NEURON_HOME@@/logs/engram.log</string>
+  <key>ThrottleInterval</key><integer>5</integer>
+</dict>
+</plist>

neuron-dev-setup/templates/launchagents/ai.neuron.mcp-proxy.plist.tmpl

@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>ai.neuron.mcp-proxy</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>@@MCP_PROXY_BIN@@</string>
+    </array>
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>MCP_PORT</key><string>@@PROXY_PORT@@</string>
+        <key>BACKEND_URL</key><string>http://localhost:@@WRAPPER_PORT@@</string>
+        <key>RETRY_MS</key><string>3000</string>
+        <key>PATH</key><string>/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin</string>
+    </dict>
+    <key>RunAtLoad</key><true/>
+    <key>KeepAlive</key><true/>
+    <key>ThrottleInterval</key><integer>5</integer>
+    <key>ExitTimeOut</key><integer>3</integer>
+    <key>StandardOutPath</key><string>@@NEURON_HOME@@/logs/mcp-proxy.out.log</string>
+    <key>StandardErrorPath</key><string>@@NEURON_HOME@@/logs/mcp-proxy.err.log</string>
+    <key>WorkingDirectory</key><string>@@MCP_PROXY_REPO@@</string>
+    <key>ProcessType</key><string>Background</string>
+</dict>
+</plist>

neuron-dev-setup/templates/launchagents/ai.neuron.mcp-wrapper.plist.tmpl

@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>ai.neuron.mcp-wrapper</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>@@MCP_WRAPPER_BIN@@</string>
+    </array>
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>MCP_PORT</key><string>@@WRAPPER_PORT@@</string>
+        <key>SOUL_URL</key><string>http://localhost:@@SOUL_PORT@@</string>
+        <key>PATH</key><string>/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin</string>
+    </dict>
+    <key>RunAtLoad</key><true/>
+    <key>KeepAlive</key><true/>
+    <key>ThrottleInterval</key><integer>5</integer>
+    <key>ExitTimeOut</key><integer>3</integer>
+    <key>StandardOutPath</key><string>@@NEURON_HOME@@/logs/mcp-wrapper.out.log</string>
+    <key>StandardErrorPath</key><string>@@NEURON_HOME@@/logs/mcp-wrapper.err.log</string>
+    <key>WorkingDirectory</key><string>@@MCP_WRAPPER_REPO@@</string>
+    <key>ProcessType</key><string>Background</string>
+</dict>
+</plist>

neuron-dev-setup/templates/launchagents/ai.neuron.soul.plist.tmpl

@@ -0,0 +1,58 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>ai.neuron.soul</string>
+
+  <key>Program</key>
+  <string>@@NEURON_HOME@@/bin/soul-wrapper.sh</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>@@NEURON_HOME@@/bin/soul-wrapper.sh</string>
+  </array>
+
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>ThrottleInterval</key>
+  <integer>10</integer>
+  <key>ProcessType</key>
+  <string>Interactive</string>
+  <key>LimitLoadToSessionType</key>
+  <string>Aqua</string>
+
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key>
+    <string>/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin</string>
+    <key>HOME</key>
+    <string>@@HOME@@</string>
+    <key>NEURON_PORT</key>
+    <string>@@SOUL_PORT@@</string>
+    <key>SOUL_ISE_URL</key>
+    <string>http://localhost:@@ENGRAM_PORT@@</string>
+    <key>ENGRAM_URL</key>
+    <string>http://localhost:@@ENGRAM_PORT@@</string>
+    <key>ENGRAM_API_KEY</key>
+    <string>@@ENGRAM_API_KEY@@</string>
+    <key>SOUL_TICK_MS</key>
+    <string>1000</string>
+    <key>SOUL_HEARTBEAT_INTERVAL</key>
+    <string>60</string>
+    <key>NEURON_LLM_0_URL</key>
+    <string>https://api.anthropic.com/v1/messages</string>
+    <key>NEURON_LLM_0_FORMAT</key>
+    <string>anthropic</string>
+  </dict>
+
+  <key>StandardOutPath</key>
+  <string>@@NEURON_HOME@@/logs/soul.out.log</string>
+  <key>StandardErrorPath</key>
+  <string>@@NEURON_HOME@@/logs/soul.err.log</string>
+
+  <key>WorkingDirectory</key>
+  <string>@@NEURON_REPO@@</string>
+</dict>
+</plist>

neuron-dev-setup/uninstall.sh

@@ -0,0 +1,56 @@
+#!/usr/bin/env bash
+#
+# neuron-dev-setup / uninstall.sh
+# Tears down the CORE dev stack this installer created. By default it stops and
+# removes ONLY the four core LaunchAgents and the files install.sh laid down.
+# It NEVER deletes your engram data unless you pass --purge-data.
+#
+#   ./uninstall.sh                 # stop + remove core LaunchAgents and wrapper script
+#   ./uninstall.sh --purge-data    # ALSO delete ~/.neuron/engram (destroys the brain!)
+#   ./uninstall.sh --keep-claude   # leave ~/.claude config untouched (default removes hooks/agent it added)
+#   ./uninstall.sh --dry-run
+# ─────────────────────────────────────────────────────────────────────────────
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+if [ -f "${SCRIPT_DIR}/config.env" ]; then source "${SCRIPT_DIR}/config.env"
+elif [ -f "${SCRIPT_DIR}/config.env.example" ]; then source "${SCRIPT_DIR}/config.env.example"; fi
+: "${NEURON_HOME:=${HOME}/.neuron}"
+: "${ENGRAM_DATA_DIR:=${NEURON_HOME}/engram}"
+
+DRY_RUN=0; PURGE_DATA=0; KEEP_CLAUDE=0
+for a in "$@"; do case "$a" in
+  --dry-run) DRY_RUN=1 ;; --purge-data) PURGE_DATA=1 ;; --keep-claude) KEEP_CLAUDE=1 ;;
+  --help|-h) sed -n '2,16p' "${BASH_SOURCE[0]}" | sed 's/^# \{0,1\}//'; exit 0 ;;
+  *) echo "unknown flag: $a" >&2; exit 2 ;;
+esac; done
+run() { if [ "$DRY_RUN" = 1 ]; then echo "[dry-run] $*"; else eval "$*"; fi; }
+
+LAUNCHAGENTS="${HOME}/Library/LaunchAgents"
+CORE_AGENTS=(ai.neuron.mcp-proxy ai.neuron.mcp-wrapper ai.neuron.soul ai.neuron.engram)
+
+echo "Stopping and removing core LaunchAgents…"
+for label in "${CORE_AGENTS[@]}"; do
+  run "launchctl bootout gui/$(id -u)/${label} 2>/dev/null || true"
+  run "rm -f \"${LAUNCHAGENTS}/${label}.plist\""
+  echo "  removed ${label}"
+done
+
+echo "Removing generated ~/.neuron/bin/soul-wrapper.sh…"
+run "rm -f \"${NEURON_HOME}/bin/soul-wrapper.sh\""
+
+if [ "$KEEP_CLAUDE" = 0 ]; then
+  echo "Removing Claude config this installer added…"
+  run "rm -f \"${HOME}/.claude/hooks/neuron-self-load.sh\" \"${HOME}/.claude/hooks/neuron-agent-preamble.sh\" \"${HOME}/.claude/hooks/pre-compact.sh\""
+  run "rm -f \"${HOME}/.claude/mcp.json.neuron\" \"${HOME}/.claude/settings.core.json\""
+  echo "  (left ~/.claude/settings.json and ~/.claude/mcp.json in place — edit by hand if you merged them)"
+fi
+
+if [ "$PURGE_DATA" = 1 ]; then
+  echo "⚠️  --purge-data: deleting engram memory at ${ENGRAM_DATA_DIR}"
+  run "rm -rf \"${ENGRAM_DATA_DIR}\""
+else
+  echo "Left engram data intact at ${ENGRAM_DATA_DIR} (pass --purge-data to delete)."
+fi
+
+echo "Done. Source repos under your DEV_ROOT were left untouched."

sessions.el

@@ -677,6 +677,11 @@ fn handle_session_approve(session_id: String, body: String) -> String {
     // path for all sessions created through handle_chat_agentic / agentic_loop.
     let bridge_blob: String = state_get("mcp_bridge:" + session_id)
     if !str_eq(bridge_blob, "") {
+        // BUG-LEAK fix (2026-07-16): the approved tool executes below via dispatch_tool,
+        // whose path/command guards read the shared workspace-root key. Re-assert THIS
+        // session's own root first — an approval must never execute under whatever root
+        // the last unrelated request left behind.
+        state_set("agent_workspace_root", state_get("agent_workspace_root_" + session_id))
         // For "always": record tool_name in the always-allow list before resuming.
         // The tool_name is not stored in the bridge blob (only tool_use_id is).
         // Accept it from the body so the client can pass it along.
@@ -708,7 +713,13 @@ fn handle_session_approve(session_id: String, body: String) -> String {
         // For builtin tools with no client-provided content: fall back to
         // dispatch_tool so those tools still execute correctly.
         let client_content: String = json_get(body, "content")
-        let use_client_content: Bool = !str_eq(client_content, "")
+        // BUG-6 fix (2026-07-17): the naive json_get scanner matches "content" ANYWHERE
+        // in the body — including INSIDE tool_input — so every approved write_file (whose
+        // input always carries a content field) was mistaken for client-executed, never
+        // dispatched, and narrated as done: a false receipt with no file on disk. Builtin
+        // tools now ALWAYS dispatch server-side; client content is only honored for
+        // non-builtin (MCP/client-executed) tools. Stricter only.
+        let use_client_content: Bool = !str_eq(client_content, "") && !is_builtin_tool(approve_tool_name)
         let use_dispatch: Bool = is_builtin_tool(approve_tool_name) && !use_client_content
         let raw_input: String = json_get_raw(body, "tool_input")
         let eff_input: String = if str_eq(raw_input, "") { "{}" } else { raw_input }

soul.el

@@ -515,7 +515,7 @@ let axon_raw: String = env("NEURON_API_URL")
 let axon_base: String = if str_eq(axon_raw, "") { "http://localhost:7771" } else { axon_raw }
 
 let studio_dir_raw: String = env("SOUL_STUDIO_DIR")
-let studio_dir: String = if str_eq(studio_dir_raw, "") { "/Users/will/Development/neuron-technologies/products/cgi-studio/el-daemon" } else { studio_dir_raw }
+let studio_dir: String = if str_eq(studio_dir_raw, "") { env("HOME") + "/Development/neuron-technologies/products/cgi-studio/el-daemon" } else { studio_dir_raw }
 
 println("[soul] boot - cgi=" + soul_cgi_id + " port=" + int_to_str(port))