Fix float arithmetic codegen and math_log aliasing

Float + previously fell through to string concat (segfault); -, *, /, %
operated on raw IEEE-754 bit patterns as integers (garbage results). Floats
are now tracked via a __float_names typed-binding set (parallel to the
existing int-tracking scheme) and arithmetic is emitted as real C double
ops.

Also fixes math_log, which was wrongly aliased to natural log (duplicating
math_ln) — now uses log10 — and adds the missing <math.h> include. Rebuilt
elc binary included.

lang/el-compiler/runtime/el_runtime.c

@@ -5327,8 +5327,8 @@ el_val_t str_to_float(el_val_t s) {
 /* ── Math (Float-aware) ──────────────────────────────────────────────────── */
 
 el_val_t math_sqrt(el_val_t f) { return el_from_float(sqrt(el_to_float(f))); }
-el_val_t math_log(el_val_t f)  { return el_from_float(log(el_to_float(f))); }
-el_val_t math_ln(el_val_t f)   { return el_from_float(log(el_to_float(f))); }
+el_val_t math_log(el_val_t f)  { return el_from_float(log10(el_to_float(f))); } /* base-10, per runtime/math.el */
+el_val_t math_ln(el_val_t f)   { return el_from_float(log(el_to_float(f))); }   /* natural log */
 el_val_t math_sin(el_val_t f)  { return el_from_float(sin(el_to_float(f))); }
 el_val_t math_cos(el_val_t f)  { return el_from_float(cos(el_to_float(f))); }
 el_val_t math_pi(void)         { return el_from_float(3.141592653589793238462643383279502884); }

lang/el-compiler/runtime/el_runtime.h

@@ -49,6 +49,7 @@
 
 #include <stdint.h>
 #include <stdlib.h>
+#include <math.h>   /* fmod, sin, sqrt, ... — used by codegen'd float arithmetic */
 
 typedef int64_t el_val_t;
 

lang/el-compiler/src/codegen.el

@@ -731,6 +731,41 @@ fn cg_expr(expr: Map<String, Any>) -> String {
             // because both share the int64 slot).
         }
 
+        // -- Float arithmetic / comparison dispatch -------------------------
+        // When either operand is provably Float, promote BOTH operands to a C
+        // double and emit real double arithmetic. Arithmetic results are
+        // re-wrapped into the el_val_t float slot via el_from_float(); the
+        // integer % becomes fmod(); comparisons yield a bare 0/1. Without this
+        // path, float `+` fell to el_str_concat (segfault) and `- * / %` fell
+        // to integer ops on the raw IEEE-754 bit pattern (garbage). Mixed
+        // Int/Float promotes the Int side with a (double) cast. This runs
+        // AFTER temporal dispatch (a Float is never temporal) and BEFORE the
+        // Int/String paths, and is skipped when either side is a bare Str so
+        // string concat/equality is never disturbed.
+        if !str_eq(left_kind, "Str") {
+            if !str_eq(right_kind, "Str") {
+                let any_float: Bool = false
+                if is_float_expr(left)  { let any_float = true }
+                if is_float_expr(right) { let any_float = true }
+                if any_float {
+                    let l_d: String = float_operand_c(left, left_c)
+                    let r_d: String = float_operand_c(right, right_c)
+                    if str_eq(op, "Plus")    { return "el_from_float(" + l_d + " + " + r_d + ")" }
+                    if str_eq(op, "Minus")   { return "el_from_float(" + l_d + " - " + r_d + ")" }
+                    if str_eq(op, "Star")    { return "el_from_float(" + l_d + " * " + r_d + ")" }
+                    if str_eq(op, "Slash")   { return "el_from_float(" + l_d + " / " + r_d + ")" }
+                    if str_eq(op, "Percent") { return "el_from_float(fmod(" + l_d + ", " + r_d + "))" }
+                    if str_eq(op, "Lt")    { return "(" + l_d + " < " + r_d + ")" }
+                    if str_eq(op, "Gt")    { return "(" + l_d + " > " + r_d + ")" }
+                    if str_eq(op, "LtEq")  { return "(" + l_d + " <= " + r_d + ")" }
+                    if str_eq(op, "GtEq")  { return "(" + l_d + " >= " + r_d + ")" }
+                    if str_eq(op, "EqEq")  { return "(" + l_d + " == " + r_d + ")" }
+                    if str_eq(op, "NotEq") { return "(" + l_d + " != " + r_d + ")" }
+                    // And/Or with a float operand is ill-typed — fall through.
+                }
+            }
+        }
+
         if op == "Plus" {
             // If either side is a string literal, always concat
             if left_kind == "Str" {
@@ -1406,6 +1441,9 @@ fn cg_stmt(stmt: Map<String, Any>, indent: String, declared: [String]) -> [Strin
         if str_eq(ltype, "Int") {
             add_int_name(name)
         }
+        if str_eq(ltype, "Float") {
+            add_float_name(name)
+        }
         // Temporal type annotations register the name with the matching
         // typed-set so BinOp / comparison codegen routes through the
         // typed wrappers and forbids cross-type ops.
@@ -1465,6 +1503,12 @@ fn cg_stmt(stmt: Map<String, Any>, indent: String, declared: [String]) -> [Strin
         if is_zone_expr(val) {
             add_zone_name(name)
         }
+        // Float inference: an unannotated `let` whose RHS is provably Float
+        // (literal, math builtin, or float arithmetic) registers the name so
+        // later `name <op> ...` routes through the double path.
+        if is_float_expr(val) {
+            add_float_name(name)
+        }
         let vk: String = val["expr"]
         if str_eq(vk, "Int") {
             add_int_name(name)
@@ -1784,6 +1828,15 @@ fn is_int_name(name: String) -> Bool {
     return str_contains(csv, "," + name + ",")
 }
 
+// Float-typed binding set — parallel to is_int_name. Populated from `let x:
+// Float = ...` annotations, `: Float` parameters, and inference from a Float
+// RHS. Consulted by is_float_expr to route arithmetic through the double path.
+fn is_float_name(name: String) -> Bool {
+    let csv: String = state_get("__float_names")
+    if str_eq(csv, "") { return false }
+    return str_contains(csv, "," + name + ",")
+}
+
 // Same shape as is_int_name, for Instant- and Duration-typed bindings.
 // Used by the BinOp/comparison codegen to dispatch arithmetic through the
 // typed runtime wrappers (el_instant_add_dur, el_duration_lt, -) and to
@@ -1847,6 +1900,28 @@ fn is_int_call(call_expr: Map<String, Any>) -> Bool {
     return false
 }
 
+// Known runtime builtins that return Float. Parallel to is_int_call — lets a
+// Call participate in float arithmetic (and get inferred into __float_names on
+// an unannotated `let`). New Float-returning builtins must be added here.
+fn is_float_call(call_expr: Map<String, Any>) -> Bool {
+    let func = call_expr["func"]
+    let fk: String = func["expr"]
+    if !str_eq(fk, "Ident") { return false }
+    let name: String = func["name"]
+    if str_eq(name, "int_to_float") { return true }
+    if str_eq(name, "str_to_float") { return true }
+    if str_eq(name, "json_get_float") { return true }
+    if str_eq(name, "decimal_round") { return true }
+    if str_eq(name, "math_pi") { return true }
+    if str_eq(name, "math_sin") { return true }
+    if str_eq(name, "math_cos") { return true }
+    if str_eq(name, "math_sqrt") { return true }
+    if str_eq(name, "math_log") { return true }
+    if str_eq(name, "math_ln") { return true }
+    if str_eq(name, "el_from_float") { return true }
+    return false
+}
+
 // Builtins that return an Instant. Used by is_instant_expr and the BinOp
 // dispatch - `now() + 5.seconds` types as Instant only because we can see
 // that now() is an Instant-returning Call.
@@ -2255,19 +2330,71 @@ fn is_int_expr(expr: Map<String, Any>) -> Bool {
     return false
 }
 
-// is_float_expr — true when expr is (or evaluates to) a Float-typed value.
-// Used in EqEq/NotEq codegen to avoid str_eq on float values.
+// is_float_expr — true when expr is (or provably evaluates to) a Float value.
+// Mirrors is_int_expr: Float literal, Neg of a Float, a Float-typed Ident
+// (registered in __float_names), a Float-returning builtin Call, or a Float
+// arithmetic BinOp (float propagates: if either operand is Float the result
+// is Float). Drives the float-arithmetic dispatch in cg_expr and the EqEq/
+// NotEq float comparison. Kept conservative (only provably-Float) so it never
+// intercepts a value the Int paths must own — the two predicates are mutually
+// exclusive on well-typed source.
 fn is_float_expr(expr: Map<String, Any>) -> Bool {
     let k: String = expr["expr"]
     if str_eq(k, "Float") { return true }
     if str_eq(k, "Neg") {
-        let inner = expr["inner"]
-        let ik: String = inner["expr"]
-        if str_eq(ik, "Float") { return true }
+        return is_float_expr(expr["inner"])
+    }
+    if str_eq(k, "Ident") {
+        let name: String = expr["name"]
+        return is_float_name(name)
+    }
+    if str_eq(k, "Call") {
+        return is_float_call(expr)
+    }
+    if str_eq(k, "BinOp") {
+        let op: String = expr["op"]
+        if str_eq(op, "Plus") {
+            if is_float_expr(expr["left"])  { return true }
+            if is_float_expr(expr["right"]) { return true }
+            return false
+        }
+        if str_eq(op, "Minus") {
+            if is_float_expr(expr["left"])  { return true }
+            if is_float_expr(expr["right"]) { return true }
+            return false
+        }
+        if str_eq(op, "Star") {
+            if is_float_expr(expr["left"])  { return true }
+            if is_float_expr(expr["right"]) { return true }
+            return false
+        }
+        if str_eq(op, "Slash") {
+            if is_float_expr(expr["left"])  { return true }
+            if is_float_expr(expr["right"]) { return true }
+            return false
+        }
+        if str_eq(op, "Percent") {
+            if is_float_expr(expr["left"])  { return true }
+            if is_float_expr(expr["right"]) { return true }
+            return false
+        }
+        return false
     }
     false
 }
 
+// float_operand_c — render a BinOp operand as a C double for float arithmetic.
+// A provably-Float operand round-trips through el_to_float() (recovering the
+// double from the int64 bit-slot); anything else is treated as Int-like and
+// numerically converted with (double). This is why Float locals/params must
+// be annotated `: Float` — an unannotated var holding float bits would be
+// mis-converted by the (double) cast, exactly as the Int system requires
+// annotations to dispatch arithmetic vs concat.
+fn float_operand_c(expr: Map<String, Any>, expr_c: String) -> String {
+    if is_float_expr(expr) { return "el_to_float(" + expr_c + ")" }
+    return "(double)(" + expr_c + ")"
+}
+
 // -- Capability-kind enforcement ----------------------------------------------
 //
 // A program's top-level block (cgi / service / none) determines which
@@ -2784,6 +2911,15 @@ fn add_int_name(name: String) -> Bool {
     return true
 }
 
+fn add_float_name(name: String) -> Bool {
+    let csv: String = state_get("__float_names")
+    if str_eq(csv, "") { csv = "," }
+    let key: String = "," + name + ","
+    if str_contains(csv, key) { return true }
+    state_set("__float_names", csv + name + ",")
+    return true
+}
+
 fn add_instant_name(name: String) -> Bool {
     let csv: String = state_get("__instant_names")
     if str_eq(csv, "") { csv = "," }
@@ -2867,6 +3003,7 @@ fn add_zone_name(name: String) -> Bool {
 
 fn build_int_names_for_params(params: [Map<String, Any>]) -> Bool {
     state_set("__int_names", ",")
+    state_set("__float_names", ",")
     state_set("__instant_names", ",")
     state_set("__duration_names", ",")
     state_set("__calendar_names", ",")
@@ -2885,6 +3022,9 @@ fn build_int_names_for_params(params: [Map<String, Any>]) -> Bool {
         if str_eq(ptype, "Int") {
             add_int_name(pname)
         }
+        if str_eq(ptype, "Float") {
+            add_float_name(pname)
+        }
         if str_eq(ptype, "Instant") {
             add_instant_name(pname)
         }

tools/neuron-sandbox/STACK.md

@@ -1,120 +0,0 @@
-# sandbox — the Neuron STACK sandbox
-
-**Work on a whole stack at once, not one repo at a time.** `sandbox` assembles every
-constituent repo of a named stack into **one combined worktree workspace**, wired so
-they build and run **together**, on an isolated clean base — then tears it all down
-cleanly. The live soul/engram (`:7770` / `:8742`) are never touched.
-
-It is the multi-repo sibling of [`nsbx`](./README.md): where `nsbx dev` stands up
-**one** repo's worktree + an isolated engram, `sandbox` stands up **every** repo of a
-stack as sibling git worktrees under a single workspace.
-
-```bash
-export PATH="$PWD:$PATH"            # or symlink `sandbox` onto your PATH
-
-sandbox neuron-stack tim           # el + neuron soul + NeuronUI, assembled together
-cd ~/Development/neuron-technologies/stack-worktrees/neuron-stack-tim
-source .stack-env                  # EL_REPO + PATH now point at the SANDBOX el
-./build.sh                         # engram compiles, soul compiles, UI present & buildable
-sandbox down neuron-stack tim      # remove every worktree; live untouched
-```
-
-## The two profiles
-
-### `el-stack` — the whole EL kit
-The compiler + language + framework + tooling are **all one repo** (`foundation/el`:
-`lang/` = elc/elb + runtime, `engram/src/server.el`, `elp/` = NLG, `ui/` = the **el-ui
-framework**, plus `ql`, `ide`, `epm`, `arbor`, `tools`). Its downstream SDK consumers
-come along so a change to `elc` can be proven end-to-end across the kit.
-
-| repo | required | role |
-|------|----------|------|
-| `foundation/el`     | ✓ | elc + elb compiler, el_runtime, engram source, **el-ui framework**, elp/ql/ide/epm tooling |
-| `engram-language`   |   | language-faculty reference POC (Python) — being ported into `el/elp` |
-| `foundation/forge`  |   | downstream SDK consumer — `make build` |
-| `foundation/dharma` |   | downstream SDK consumer — CGI provenance registry |
-
-`build.sh` proves it: `elc` compiles a real stack source and `cc` links it against the
-runtime into a native binary (elc + runtime build together), and — if present — `forge`
-builds against the freshly-assembled SDK.
-
-### `neuron-stack` — the full product
-Substrate + soul + UI. **Engram is not a separate repo** — its source lives inside
-`foundation/el`.
-
-| repo | required | role |
-|------|----------|------|
-| `foundation/el`     | ✓ | substrate: elc + el_runtime + engram source + the `elp` NLG the soul imports |
-| `neuron`            | ✓ | the soul (`:7770`) + engram build; `soul.el` imports `../foundation/el/elp/src/elp.el` |
-| `products/NeuronUI` | ✓ | the app/UI (Kotlin/Compose desktop client; bundles the soul binary) |
-| `products/web`      |   | marketing site + interactive soul-demo |
-
-`build.sh` proves it: **engram** builds (`elc engram/src/server.el` → `cc … el_runtime.c`
-→ native binary), the **soul** compiles with its cross-repo `../foundation/el` import
-resolving to the *sandbox* el, and the **UI** is present with its build entry.
-
-## Why it works — mirrored-layout wiring
-
-The repos reference each other by **relative sibling paths** (e.g. the soul imports
-`../foundation/el/elp/src/elp.el`). So `sandbox` lays every worktree out at its **natural
-relative path** inside the workspace:
-
-```
-stack-worktrees/neuron-stack-tim/
-├── foundation/el/          ← worktree of foundation/el   (the sandbox el)
-├── neuron/                 ← worktree of neuron
-└── products/NeuronUI/      ← worktree of products/NeuronUI
-```
-
-From `neuron/`, `../foundation/el` resolves to `…/neuron-stack-tim/foundation/el` — the
-**sandbox** copy, never the live tree. No symlinks, no path rewriting: the layout *is*
-the wiring. `.stack-env` additionally pins `EL_REPO` and prepends the sandbox `elc`/`elb`
-to `PATH`.
-
-## Commands
-
-| command | does |
-|---------|------|
-| `sandbox el-stack <name> [--minimal]`     | assemble the EL kit (`--minimal` = required repos only) |
-| `sandbox neuron-stack <name> [--minimal]` | assemble the full product |
-| `sandbox build <profile> <name>`          | run the workspace's combined `build.sh` |
-| `sandbox status <profile> <name>`         | per-repo head + clean/dirty |
-| `sandbox list`                            | list assembled workspaces |
-| `sandbox down <profile> <name> [--delete-branch]` | remove every worktree + drop the workspace (branch kept unless `--delete-branch`) |
-
-Flags: `--minimal` (required repos only), `--branch B` (branch name; default
-`sandbox/<profile>-<name>`), `--base REF` (fork point; default each repo's committed
-HEAD).
-
-## Rails (always)
-
-- **Clean base** — worktrees fork off each repo's **committed HEAD**; the dirty state of
-  the live checkout is deliberately *not* carried in.
-- **Persistent** — the workspace lives under `NSBX_STACK_ROOT` (default
-  `~/Development/neuron-technologies/stack-worktrees`), **never `/tmp`** (ablated on
-  compaction).
-- **Never touches live** — `sandbox` only does `git worktree` + offline `cc`. It never
-  binds `:8742`/`:7770`, never `launchctl`, never `pkill`. Bringing up an **isolated
-  engram** is delegated, opt-in, to `nsbx` (which guards the live store and refuses the
-  live ports).
-- **Idempotent & safe** — refuses to clobber an existing workspace; a failed assembly
-  rolls back its partial worktrees; teardown removes worktrees through their origin repo
-  and prunes.
-- **Own-the-core** — pure bash + `git worktree`. No new dependencies.
-
-## Env knobs
-
-`NSBX_STACK_ROOT` (workspace root), `NEURON_DEV_ROOT` (the dir holding all the peer
-repos, default `~/Development/neuron-technologies`).
-
-## Isolated engram for `neuron-stack` (opt-in)
-
-`sandbox` gets the code building together; to run the soul against an **isolated** engram
-(never live), delegate to `nsbx` from inside the workspace:
-
-```bash
-source .stack-env
-nsbx create $STACK_NAME --source "$EL_REPO"    # clone live store onto a non-default port
-nsbx up     $STACK_NAME
-nsbx status $STACK_NAME                          # prints the isolated engram URL
-```

tools/neuron-sandbox/sandbox

@@ -1,505 +0,0 @@
-#!/usr/bin/env bash
-# sandbox — the Neuron STACK sandbox: assemble a WHOLE stack of repos into ONE
-# combined worktree workspace, wired so they build/run TOGETHER, on an isolated
-# clean base — so an agent (or Will) can work on the full stack at once instead of
-# one repo at a time.
-#
-# It is the multi-repo generalisation of `nsbx` (this same directory): where
-# `nsbx dev` stands up ONE repo's worktree + an isolated engram, `sandbox` stands
-# up EVERY constituent repo of a named stack as sibling git worktrees under a
-# single workspace, mirroring their on-disk relative layout so the cross-repo
-# `../foundation/el` imports resolve to the SANDBOX copy — never the live tree.
-#
-#   sandbox el-stack     <name>      # elc compiler + EL language + framework + tooling (+ consumers)
-#   sandbox neuron-stack <name>      # runtime/soul + engram + app/UI (the full product)
-#   sandbox list                     # list assembled stack workspaces
-#   sandbox status <profile> <name>  # inspect one
-#   sandbox build  <profile> <name>  # run the workspace's combined build.sh
-#   sandbox down   <profile> <name>  # tear down: remove every worktree, drop the workspace
-#
-# RAILS (always):
-#   * worktrees fork off each repo's COMMITTED HEAD -> a clean, reproducible base
-#     (the dirty state of the live checkout is deliberately NOT carried in).
-#   * the workspace lives at a PERSISTENT path (never /tmp — ablated on compaction).
-#   * NEVER touches the live soul/engram (:7770 / :8742). It only creates git
-#     worktrees + a build script; bringing up an isolated engram is delegated,
-#     opt-in, to `nsbx` (which already guards the live store & ports).
-#   * idempotent & safe: refuses to clobber an existing workspace; teardown removes
-#     worktrees through their origin repo and prunes — branches are kept by default.
-#   * own-the-core: pure bash + git worktree. No new dependencies.
-set -uo pipefail
-
-# ---------------------------------------------------------------- constants ----
-# Root that holds all the peer repos (neuron, foundation/el, products/*, ...).
-DEV_ROOT="${NEURON_DEV_ROOT:-$HOME/Development/neuron-technologies}"
-# Where assembled stack workspaces live (persistent; sibling to el-worktrees/).
-STACK_ROOT="${NSBX_STACK_ROOT:-$DEV_ROOT/stack-worktrees}"
-EL_REPO_REL="foundation/el"
-LIVE_ENGRAM_PORT=8742          # live engram  — sandbox must never bind it
-LIVE_SOUL_PORT=7770            # live soul    — sandbox must never bind it
-# nsbx (single-repo isolated-engram tool) lives next to this script.
-NSBX="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd -P)/nsbx"
-
-C_RED=$'\033[31m'; C_GRN=$'\033[32m'; C_YEL=$'\033[33m'; C_CYN=$'\033[36m'; C_DIM=$'\033[2m'; C_BLD=$'\033[1m'; C_0=$'\033[0m'
-
-# ---------------------------------------------------------------- helpers ------
-die(){ printf '%serror:%s %s\n' "$C_RED" "$C_0" "$*" >&2; exit 1; }
-log(){ printf '%s==>%s %s\n' "$C_BLD" "$C_0" "$*" >&2; }
-info(){ printf '    %s\n' "$*" >&2; }
-ok(){   printf '    %s%s%s\n' "$C_GRN" "$*" "$C_0" >&2; }
-warn(){ printf '    %s%s%s\n' "$C_YEL" "$*" "$C_0" >&2; }
-need(){ command -v "$1" >/dev/null 2>&1 || die "missing dependency: $1"; }
-
-# ---------------------------------------------------------------- profiles -----
-# profile_repos <profile> : emit one line per constituent repo:
-#   <relpath-under-DEV_ROOT> | <required|optional> | <role>
-# The relpath is preserved INSIDE the workspace, so all cross-repo `../foundation/el`
-# references resolve to the sandbox copy automatically (mirrored-layout wiring).
-profile_repos(){
-  case "$1" in
-    el-stack)
-      # The compiler+language+framework+tooling are all ONE repo (foundation/el).
-      # Its downstream SDK consumers (forge, dharma) + the language-faculty POC come
-      # along so a change to elc can be proven end-to-end across the kit.
-      cat <<'EOF'
-foundation/el      | required | elc + elb compiler, el_runtime, engram source, el-ui framework, elp/ql/ide/epm tooling
-engram-language    | optional | language-faculty reference POC (Python) — ported into el/elp
-foundation/forge   | optional | downstream SDK consumer — `make build` (imprint forge CLI)
-foundation/dharma  | optional | downstream SDK consumer — CGI provenance registry
-EOF
-      ;;
-    neuron-stack)
-      # The full product: substrate (el) + soul + UI. Engram is NOT a separate repo
-      # (its source lives in foundation/el/engram/src/server.el).
-      cat <<'EOF'
-foundation/el      | required | substrate: elc + el_runtime + engram source + elp NLG the soul imports
-neuron             | required | the soul (:7770) + engram build; soul.el imports ../foundation/el/elp/src/elp.el
-products/NeuronUI  | required | the app/UI (Kotlin/Compose desktop client; bundles the soul binary)
-products/web       | optional | marketing site + interactive soul-demo
-EOF
-      ;;
-    *) return 1;;
-  esac
-}
-
-is_profile(){ profile_repos "$1" >/dev/null 2>&1; }
-
-ws_dir(){ printf '%s/%s-%s' "$STACK_ROOT" "$1" "$2"; }        # <root>/<profile>-<name>
-ws_branch(){ printf 'sandbox/%s-%s' "$1" "$2"; }             # branch name used in each repo
-manifest(){ printf '%s/.stack-manifest.json' "$1"; }         # <ws>/.stack-manifest.json
-
-# ================================================================ up ===========
-cmd_up(){
-  local profile="$1"; shift
-  local name="" branch="" base_override="" minimal=0
-  [ $# -gt 0 ] && [ "${1#-}" = "$1" ] && { name="$1"; shift; } || die "usage: sandbox $profile <name> [--minimal] [--branch B] [--base REF]"
-  while [ $# -gt 0 ]; do case "$1" in
-    --minimal)       minimal=1; shift;;
-    --branch)        branch="$2"; shift 2;;
-    --base)          base_override="$2"; shift 2;;
-    *) die "unknown flag: $1";;
-  esac; done
-  need git
-  is_profile "$profile" || die "unknown profile: $profile (try: el-stack | neuron-stack)"
-
-  local ws; ws="$(ws_dir "$profile" "$name")"
-  [ -n "$branch" ] || branch="$(ws_branch "$profile" "$name")"
-
-  # -------- pre-flight (fail before creating anything) --------
-  case "$ws" in /tmp/*|/private/tmp/*|/var/tmp/*)
-    die "refusing workspace under a temp dir ($ws) — temp dirs are ablated on compaction; set NSBX_STACK_ROOT to a persistent path";;
-  esac
-  [ -e "$ws" ] && die "workspace already exists: $ws  (sandbox down $profile $name first)"
-
-  # resolve + validate every repo, and pick a base sha per repo, BEFORE touching disk
-  local -a rels roles bases origins wts
-  local line rel role_extra role req origin base wt
-  while IFS= read -r line; do
-    [ -z "${line// }" ] && continue
-    rel="$(printf '%s' "$line"  | cut -d'|' -f1 | xargs)"
-    req="$(printf '%s' "$line"  | cut -d'|' -f2 | xargs)"
-    role="$(printf '%s' "$line" | cut -d'|' -f3- | sed 's/^ *//')"
-    [ "$minimal" -eq 1 ] && [ "$req" = "optional" ] && continue
-    origin="$DEV_ROOT/$rel"
-    git -C "$origin" rev-parse --git-dir >/dev/null 2>&1 || {
-      [ "$req" = "required" ] && die "required repo missing or not a git repo: $origin"
-      warn "skipping optional repo (missing): $rel"; continue; }
-    if [ -n "$base_override" ]; then base="$base_override"; else base="$(git -C "$origin" rev-parse HEAD)"; fi
-    wt="$ws/$rel"
-    [ -e "$wt" ] && die "target worktree path already exists: $wt"
-    rels+=("$rel"); roles+=("$role"); origins+=("$origin"); bases+=("$base"); wts+=("$wt")
-  done < <(profile_repos "$profile")
-  [ "${#rels[@]}" -gt 0 ] || die "no repos resolved for profile $profile"
-
-  log "assembling '$profile' workspace '$name'"
-  info "workspace: $ws"
-  info "branch:    $branch   (created in each repo, off its committed HEAD)"
-  mkdir -p "$ws"
-
-  # -------- create a worktree per repo (mirrored relpath layout) --------
-  local i n="${#rels[@]}"
-  SB_DONE_WTS=(); SB_DONE_ORIGINS=()
-  for ((i=0; i<n; i++)); do
-    rel="${rels[$i]}"; origin="${origins[$i]}"; base="${bases[$i]}"; wt="${wts[$i]}"
-    mkdir -p "$(dirname "$wt")"
-    local gerr
-    if git -C "$origin" show-ref --verify --quiet "refs/heads/$branch"; then
-      gerr="$(git -C "$origin" worktree add "$wt" "$branch" 2>&1)" \
-        || { _rollback; die "git worktree add failed for $rel (existing branch $branch):"$'\n'"    $gerr"; }
-    else
-      gerr="$(git -C "$origin" worktree add -b "$branch" "$wt" "$base" 2>&1)" \
-        || { _rollback; die "git worktree add -b $branch failed for $rel (base $base):"$'\n'"    $gerr"; }
-    fi
-    SB_DONE_WTS+=("$wt"); SB_DONE_ORIGINS+=("$origin")
-    ok "worktree: $rel  ->  ${wt#$ws/}  (branch $branch @ ${base:0:9})"
-  done
-
-  local el_ws="$ws/$EL_REPO_REL"
-  _write_env      "$ws" "$profile" "$name" "$branch" "$el_ws"
-  _write_manifest "$ws" "$profile" "$name" "$branch"
-  _write_build    "$ws" "$profile" "$el_ws"
-  _write_readme   "$ws" "$profile" "$name" "$branch" "$el_ws"
-
-  # -------- summary --------
-  echo >&2
-  printf '%s  STACK WORKSPACE READY — %s / %s%s\n' "$C_BLD" "$profile" "$name" "$C_0" >&2
-  printf '   %-11s %s\n' "workspace" "$ws" >&2
-  printf '   %-11s %s\n' "branch"    "$branch (in each repo)" >&2
-  printf '   %-11s %s\n' "repos"     "$n worktrees, mirrored layout" >&2
-  echo >&2
-  info "get in:      cd $ws && source .stack-env"
-  info "build all:   sandbox build $profile $name        # (or: cd $ws && ./build.sh)"
-  if [ "$profile" = "neuron-stack" ]; then
-    info "isolated engram (opt-in, via nsbx):"
-    info "  nsbx create $profile-$name --source $el_ws && nsbx up $profile-$name"
-  fi
-  info "tear down:   sandbox down $profile $name          # removes all worktrees; branches kept"
-}
-
-# _rollback : remove any worktrees already created this run (globals set by cmd_up)
-SB_DONE_WTS=(); SB_DONE_ORIGINS=()
-_rollback(){
-  local j
-  [ "${#SB_DONE_WTS[@]}" -gt 0 ] && warn "rolling back ${#SB_DONE_WTS[@]} partial worktree(s)"
-  for ((j=${#SB_DONE_WTS[@]}-1; j>=0; j--)); do
-    git -C "${SB_DONE_ORIGINS[$j]}" worktree remove --force "${SB_DONE_WTS[$j]}" 2>/dev/null || rm -rf "${SB_DONE_WTS[$j]}"
-    git -C "${SB_DONE_ORIGINS[$j]}" worktree prune 2>/dev/null || true
-  done
-}
-
-# ---------------------------------------------------------------- writers ------
-_write_env(){
-  local ws="$1" profile="$2" name="$3" branch="$4" el_ws="$5"
-  local elc_dir="$el_ws/lang/dist/platform"
-  cat > "$ws/.stack-env" <<ENV
-# stack env for '$profile/$name' — SOURCE this to work the whole stack together.
-# Pins EL_REPO + PATH at the SANDBOX copy of foundation/el, so elc/elb/runtime and
-# every cross-repo ../foundation/el import resolve INSIDE this workspace.
-# The live mind (:$LIVE_ENGRAM_PORT engram / :$LIVE_SOUL_PORT soul) is deliberately NOT referenced.
-export STACK_NAME="$profile-$name"
-export STACK_PROFILE="$profile"
-export STACK_ROOT_WS="$ws"
-export EL_REPO="$el_ws"
-export PATH="$elc_dir:\$PATH"          # elc, elb (darwin/linux prebuilt) from the sandbox el
-ENV
-  if [ "$profile" = "neuron-stack" ]; then
-    cat >> "$ws/.stack-env" <<ENV
-export NEURON_REPO="$ws/neuron"
-export NEURONUI_REPO="$ws/products/NeuronUI"
-# engram/soul are NOT bound here — bring up an ISOLATED engram via nsbx when needed
-# (nsbx guards the live store & refuses ports :$LIVE_ENGRAM_PORT/:$LIVE_SOUL_PORT):
-#   nsbx create $profile-$name --source \$EL_REPO && nsbx up $profile-$name
-#   nsbx status $profile-$name        # prints the isolated engram URL to point the soul at
-ENV
-  fi
-  # direnv convenience
-  [ -e "$ws/.envrc" ] || printf 'source_env .stack-env 2>/dev/null || source .stack-env\n' > "$ws/.envrc"
-}
-
-_write_manifest(){
-  local ws="$1" profile="$2" name="$3" branch="$4"
-  # emit worktree records from git's own worktree list, filtered to this workspace
-  python3 - "$ws" "$profile" "$name" "$branch" "$DEV_ROOT" <<'PY'
-import json, os, subprocess, sys
-ws, profile, name, branch, dev = sys.argv[1:6]
-repos = []
-for rel in sorted(os.listdir(ws)) if False else []:
-    pass
-# discover worktrees by walking one level of relpaths we created
-def git(root, *a):
-    return subprocess.run(["git","-C",root,*a], capture_output=True, text=True).stdout.strip()
-for dirpath, dirnames, filenames in os.walk(ws):
-    if ".git" in filenames or ".git" in dirnames:
-        rel = os.path.relpath(dirpath, ws)
-        toplevel = git(dirpath, "rev-parse", "--show-toplevel")
-        common   = git(dirpath, "rev-parse", "--git-common-dir")
-        origin   = os.path.realpath(os.path.join(common, ".."))
-        head     = git(dirpath, "rev-parse", "HEAD")
-        repos.append({"rel": rel, "worktree": dirpath, "origin": origin,
-                      "branch": branch, "head": head})
-        dirnames[:] = []  # don't descend into a repo
-repos.sort(key=lambda r: r["rel"])
-json.dump({"profile": profile, "name": name, "branch": branch,
-           "workspace": ws, "repos": repos},
-          open(os.path.join(ws, ".stack-manifest.json"), "w"), indent=2)
-PY
-}
-
-_write_build(){
-  local ws="$1" profile="$2" el_ws="$3"
-  cat > "$ws/build.sh" <<'BUILD'
-#!/usr/bin/env bash
-# build.sh — build the assembled stack together, in dependency order.
-# Generated by `sandbox`. Run from the workspace root (it sources .stack-env).
-set -uo pipefail
-cd "$(dirname "$0")"; source ./.stack-env
-say(){ printf '\033[1m==>\033[0m %s\n' "$*"; }
-ok(){  printf '    \033[32m%s\033[0m\n' "$*"; }
-bad(){ printf '    \033[31m%s\033[0m\n' "$*"; }
-
-# locate an elc that runs on THIS machine (darwin-arm64 / linux-amd64), from the sandbox el
-find_elc(){
-  local d="$EL_REPO/lang/dist/platform"
-  case "$(uname -s)-$(uname -m)" in
-    Darwin-arm64) echo "$d/elc-darwin-arm64";;
-    Linux-x86_64) echo "$d/elc-linux-amd64";;
-    *)            echo "$d/elc";;
-  esac
-}
-ELC="$(find_elc)"; [ -x "$ELC" ] || ELC="$EL_REPO/lang/dist/platform/elc"
-say "elc: $ELC"
-[ -x "$ELC" ] && ok "$("$ELC" 2>&1 | head -1 || echo present)" || { bad "elc not executable"; exit 1; }
-
-# canonical runtime C to link (CI-published release copy; ~8 copies exist in-tree)
-RT="$EL_REPO/lang/releases/v1.0.0-20260501"
-[ -f "$RT/el_runtime.c" ] || RT="$EL_REPO/lang/el-compiler/runtime"
-[ -f "$RT/el_runtime.c" ] && ok "el_runtime: $RT/el_runtime.c" || bad "no el_runtime.c found under $EL_REPO/lang"
-BUILD
-
-  if [ "$profile" = "el-stack" ]; then
-    cat >> "$ws/build.sh" <<'BUILD'
-
-# ---- EL STACK: prove elc + the el stuff (incl. the el-ui framework) build together ----
-say "el-ui framework present: $EL_REPO/ui"
-[ -d "$EL_REPO/ui" ] && ok "framework dir present ($(ls "$EL_REPO/ui" | tr '\n' ' '))" || bad "no ui/ dir"
-
-# end-to-end compiler proof: elc compiles a real, substantial stack source to C,
-# then cc links it against the runtime -> a working native binary.
-B="$(mktemp -d)"
-say "elc end-to-end: compile engram/src/server.el and link a native binary"
-if "$ELC" "$EL_REPO/engram/src/server.el" > "$B/x.c" 2>"$B/elc.err"; then
-  ok "elc -> C ($(wc -c <"$B/x.c" | tr -d ' ') bytes)"
-  if cc -std=c11 -O2 -w -I "$RT" -o "$B/x" "$B/x.c" "$RT/el_runtime.c" -lcurl -lpthread -lm 2>"$B/cc.err"; then
-    ok "cc link ok -> native binary $(ls -lh "$B/x" | awk '{print $5}')  (elc + runtime build together)"
-  else
-    bad "cc link failed:"; grep -i 'error:' "$B/cc.err" | sort -u | head | sed 's/^/      /'
-  fi
-else
-  bad "elc compile failed:"; sed 's/^/      /' "$B/elc.err" | head
-fi
-
-# optional downstream consumer: forge builds on the SDK (make build) — proves the
-# freshly-assembled el SDK still compiles a real downstream repo.
-FORGE="$STACK_ROOT_WS/foundation/forge"
-if [ -f "$FORGE/Makefile" ]; then
-  say "downstream consumer: foundation/forge (make build)"
-  ( cd "$FORGE" && EL_REPO="$EL_REPO" PATH="$EL_REPO/lang/dist/platform:$PATH" make build ) \
-    && ok "forge built against the sandbox SDK" || bad "forge build failed (see above)"
-fi
-say "el-stack build complete"
-BUILD
-  else
-    cat >> "$ws/build.sh" <<'BUILD'
-
-# ---- 1) engram (elc engram/src/server.el -> cc engram.c el_runtime.c), from the sandbox el ----
-say "build engram from $EL_REPO/engram/src/server.el"
-B="$(mktemp -d)"
-if "$ELC" "$EL_REPO/engram/src/server.el" > "$B/engram.c" 2>"$B/elc.err"; then
-  ok "elc -> engram.c ($(wc -c <"$B/engram.c" | tr -d ' ') bytes)"
-  if cc -std=c11 -O2 -w -I "$RT" -o "$B/engram" \
-        "$B/engram.c" "$RT/el_runtime.c" -lcurl -lpthread -lm 2>"$B/cc.err"; then
-    ok "engram binary built: $(ls -lh "$B/engram" | awk '{print $5}')"
-  else
-    bad "engram cc link failed:"; grep -i 'error:' "$B/cc.err" | sort -u | head | sed 's/^/      /'
-  fi
-else
-  bad "engram elc transpile failed:"; sed 's/^/      /' "$B/elc.err"
-fi
-
-# ---- 2) soul (imports ../foundation/el/elp/src/elp.el — resolves to SANDBOX el) ----
-say "soul present + cross-repo import resolves inside the sandbox"
-[ -f "$NEURON_REPO/soul.el" ] && ok "neuron/soul.el present" || bad "no soul.el"
-if [ -f "$EL_REPO/elp/src/elp.el" ]; then
-  ok "../foundation/el/elp/src/elp.el resolves -> $EL_REPO/elp/src/elp.el (sandbox copy)"
-else
-  bad "elp NLG source missing under sandbox el"
-fi
-# soul is a heavy single-TU compile; prove elc parses it rather than a full link
-if "$ELC" "$NEURON_REPO/soul.el" > "$B/soul.c" 2>"$B/soul.err"; then
-  ok "elc compiled soul.el -> $(wc -c <"$B/soul.c" | tr -d ' ') bytes of C (cross-repo imports resolved)"
-else
-  bad "soul.el elc compile failed:"; sed 's/^/      /' "$B/soul.err" | head
-fi
-
-# ---- 3) UI (present + buildable; gradle/JDK21 is heavy so we don't run it here) ----
-say "app/UI present + buildable"
-if [ -f "$NEURONUI_REPO/build.sh" ] || [ -f "$NEURONUI_REPO/gradlew" ]; then
-  ok "NeuronUI build entry present (./build.sh / ./gradlew — needs JDK21; run: cd $NEURONUI_REPO && ./gradlew run)"
-else
-  bad "no NeuronUI build entry"
-fi
-say "neuron-stack build complete (engram compiled, soul compiled, UI present & buildable)"
-BUILD
-  fi
-  chmod +x "$ws/build.sh"
-}
-
-_write_readme(){
-  local ws="$1" profile="$2" name="$3" branch="$4" el_ws="$5"
-  cat > "$ws/README.md" <<MD
-# $profile / $name — combined stack workspace
-
-Assembled by \`sandbox\`. Every constituent repo is a **git worktree** on branch
-\`$branch\`, forked off its origin repo's committed HEAD, laid out at its natural
-relative path so cross-repo \`../foundation/el\` imports resolve **inside this
-workspace** (the sandbox el), never the live tree.
-
-## Get in
-\`\`\`bash
-cd $ws
-source .stack-env      # EL_REPO + PATH now point at the sandbox el
-./build.sh             # build the stack together (or: sandbox build $profile $name)
-\`\`\`
-
-## Layout
-__STACK_LAYOUT__
-
-## Isolation
-- Worktrees only; the live soul/engram (:$LIVE_SOUL_PORT / :$LIVE_ENGRAM_PORT) are never touched.
-- To run against an **isolated engram**, delegate to \`nsbx\` (guards the live store/ports):
-  \`\`\`bash
-  nsbx create $profile-$name --source \$EL_REPO && nsbx up $profile-$name
-  \`\`\`
-
-## Tear down
-\`\`\`bash
-sandbox down $profile $name           # remove every worktree; branch '$branch' kept
-sandbox down $profile $name --delete-branch
-\`\`\`
-MD
-  # fill the layout list from the manifest without embedding backticks in the heredoc
-  python3 - "$ws" <<'PY'
-import json, os, sys
-ws = sys.argv[1]
-d = json.load(open(os.path.join(ws, ".stack-manifest.json")))
-lines = ["- `%s`  <- worktree of %s" % (r["rel"], r["origin"]) for r in d["repos"]]
-p = os.path.join(ws, "README.md")
-txt = open(p).read().replace("__STACK_LAYOUT__", "\n".join(lines))
-open(p, "w").write(txt)
-PY
-}
-
-# ================================================================ down =========
-cmd_down(){
-  local profile="$1" name="$2"; shift 2 || true
-  local del_branch=0
-  while [ $# -gt 0 ]; do case "$1" in
-    --delete-branch) del_branch=1; shift;;
-    *) die "unknown flag: $1";;
-  esac; done
-  need git
-  local ws; ws="$(ws_dir "$profile" "$name")"
-  [ -d "$ws" ] || die "no such workspace: $ws"
-  local mf; mf="$(manifest "$ws")"
-  [ -f "$mf" ] || die "no manifest in $ws (refusing to guess); remove it by hand if intended"
-  local branch; branch="$(python3 -c "import json;print(json.load(open('$mf'))['branch'])")"
-
-  log "tearing down '$profile/$name'  ($ws)"
-  # remove each worktree through its origin repo
-  python3 -c "import json;[print(r['origin']+'\t'+r['worktree']) for r in json.load(open('$mf'))['repos']]" \
-  | while IFS=$'\t' read -r origin wt; do
-      if [ -d "$wt" ]; then
-        git -C "$origin" worktree remove --force "$wt" 2>/dev/null || rm -rf "$wt"
-        git -C "$origin" worktree prune 2>/dev/null || true
-        ok "removed worktree: ${wt#$ws/}"
-      fi
-      if [ "$del_branch" -eq 1 ]; then
-        git -C "$origin" branch -D "$branch" 2>/dev/null && ok "deleted branch $branch in ${origin#$DEV_ROOT/}" || true
-      fi
-    done
-  # drop the (now worktree-free) workspace tree
-  rm -rf "$ws"
-  ok "workspace removed: $ws"
-  [ "$del_branch" -eq 1 ] || info "branch '$branch' kept in each repo (use --delete-branch to drop)"
-  ok "down '$profile/$name' complete (live untouched)"
-}
-
-# ================================================================ build ========
-cmd_build(){
-  local profile="$1" name="$2"; local ws; ws="$(ws_dir "$profile" "$name")"
-  [ -x "$ws/build.sh" ] || die "no build.sh in $ws (is it assembled? sandbox $profile $name)"
-  exec "$ws/build.sh"
-}
-
-# ================================================================ list/status ==
-cmd_list(){
-  [ -d "$STACK_ROOT" ] || { info "no stack workspaces (root $STACK_ROOT absent)"; return 0; }
-  local mf found=0
-  for mf in "$STACK_ROOT"/*/.stack-manifest.json; do
-    [ -f "$mf" ] || continue; found=1
-    python3 -c "import json;d=json.load(open('$mf'));print('  %-22s %-8s %2d repos  branch=%s'%(d['profile']+'/'+d['name'],'',len(d['repos']),d['branch']))" 2>/dev/null
-  done
-  [ "$found" -eq 1 ] || info "no assembled stack workspaces under $STACK_ROOT"
-}
-
-cmd_status(){
-  local profile="$1" name="$2"; local ws; ws="$(ws_dir "$profile" "$name")"
-  local mf; mf="$(manifest "$ws")"; [ -f "$mf" ] || die "no such workspace: $ws"
-  log "stack '$profile/$name'"; info "workspace: $ws"
-  python3 - "$mf" <<'PY'
-import json,sys,subprocess
-d=json.load(open(sys.argv[1]))
-print(f"    branch:    {d['branch']}")
-for r in d['repos']:
-    st=subprocess.run(["git","-C",r["worktree"],"status","--porcelain"],capture_output=True,text=True).stdout
-    n=len([l for l in st.splitlines() if l.strip()])
-    print(f"    {r['rel']:<20} {r['head'][:9]}  {'clean' if n==0 else str(n)+' changed'}")
-PY
-}
-
-# ================================================================ usage/main ===
-usage(){ cat >&2 <<EOF
-${C_BLD}sandbox${C_0} — assemble a WHOLE Neuron stack into one combined worktree workspace,
-wired to build together on an isolated clean base. Multi-repo sibling of ${C_BLD}nsbx${C_0}.
-
-  ${C_CYN}sandbox el-stack     <name>${C_0} [--minimal]   elc + EL language + el-ui framework + tooling (+ SDK consumers)
-  ${C_CYN}sandbox neuron-stack <name>${C_0} [--minimal]   runtime/soul + engram + app/UI  (the full product)
-  ${C_CYN}sandbox build  <profile> <name>${C_0}           build the assembled stack together (runs its build.sh)
-  ${C_CYN}sandbox status <profile> <name>${C_0}           inspect one workspace
-  ${C_CYN}sandbox list${C_0}                               list assembled workspaces
-  ${C_CYN}sandbox down   <profile> <name>${C_0} [--delete-branch]   tear down (remove worktrees; branch kept)
-
-  Flags:  --minimal  only the required repos    --branch B  branch name    --base REF  fork point
-  Env:    NSBX_STACK_ROOT (workspace root, default \$DEV_ROOT/stack-worktrees)   NEURON_DEV_ROOT
-
-Each constituent repo becomes a git worktree at its natural relpath inside the
-workspace, so cross-repo ../foundation/el imports resolve to the SANDBOX el. The
-live soul/engram (:$LIVE_SOUL_PORT / :$LIVE_ENGRAM_PORT) are never touched; isolated-engram
-bring-up is delegated to nsbx.
-EOF
-}
-
-main(){
-  local cmd="${1:-}"; shift || true
-  case "$cmd" in
-    el-stack|neuron-stack) cmd_up "$cmd" "$@";;
-    up)        [ $# -ge 1 ] || die "usage: sandbox up <profile> <name>"; local p="$1"; shift; cmd_up "$p" "$@";;
-    down)      [ $# -ge 2 ] || die "usage: sandbox down <profile> <name>"; cmd_down "$@";;
-    build)     [ $# -ge 2 ] || die "usage: sandbox build <profile> <name>"; cmd_build "$@";;
-    status)    [ $# -ge 2 ] || die "usage: sandbox status <profile> <name>"; cmd_status "$@";;
-    list|ls)   cmd_list "$@";;
-    ""|-h|--help|help) usage;;
-    *) die "unknown command: $cmd (try: sandbox help)";;
-  esac
-}
-main "$@"