migrate stage build to native elc; chat restores from localStorage on return

Build pipeline
- build-stage.sh replaces the old in-Dockerfile bootstrap.py path. Host
  pre-compiles src/*.el into dist/main.c via the canonical native elc at
  foundation/el/dist/platform/elc and applies the stub-decl sed before
  docker buildx runs.
- Dockerfile.stage drops bootstrap.py + python3 from the builder stage
  and just runs cc on the host-supplied dist/main.c.
- Pre-rendered HTML shells under /srv/landing/ are now chowned to the
  landing user so the El page-builder's fs_write at startup can rewrite
  them — without that, post-COPY edits never reach the served HTML and
  the served page stays as the stale build-time fallback.

Chat restore
- session.verified + session.verifiedAt persist through localStorage so
  a return visit within 24h skips the Turnstile gate and lands directly
  in the restored conversation.
- restoreOrGreet() is the single source of truth for what shows up in
  the message pane after the gate clears: replays prior messages with
  skipSave, else drops the canned hello once and remembers it.
- applyVerifiedDom() hides the gate / reveals the chat row, called both
  from the verified-on-load path (DOMContentLoaded if loading, else
  immediate) and from the Turnstile callback.
- neuronDemoReset clears verified + verifiedAt so the gate returns next
  open.

Extracted JS assets (src/assets/js/*.js + manifest.json) and the
extract-js.py helper land here too — they match what the new build-stage
flow produces and removes the inline <script> blobs from the served HTML.

runtime/el_runtime.c

@@ -4840,6 +4840,43 @@ el_val_t engram_scan_nodes_json(el_val_t limit, el_val_t offset) {
     return el_wrap_str(b.buf);
 }
 
+/* engram_scan_nodes_by_type_json — filter by node_type before paginating.
+ * Empty / NULL type_v falls back to the unfiltered scan (existing behaviour).
+ * Result is JSON array, salience-sorted, transparent layers skipped. */
+el_val_t engram_scan_nodes_by_type_json(el_val_t type_v, el_val_t limit, el_val_t offset) {
+    const char* type_filter = EL_CSTR(type_v);
+    if (!type_filter || !*type_filter) {
+        return engram_scan_nodes_json(limit, offset);
+    }
+    EngramStore* g = engram_get();
+    int64_t lim = (int64_t)limit; if (lim <= 0) lim = 100;
+    int64_t off = (int64_t)offset; if (off < 0) off = 0;
+    JsonBuf b; jb_init(&b);
+    jb_putc(&b, '[');
+    if (g->node_count == 0) { jb_putc(&b, ']'); return el_wrap_str(b.buf); }
+    int64_t* idx = malloc((size_t)g->node_count * sizeof(int64_t));
+    if (!idx) { jb_putc(&b, ']'); return el_wrap_str(b.buf); }
+    int64_t live = 0;
+    for (int64_t i = 0; i < g->node_count; i++) {
+        if (engram_layer_is_transparent(g->nodes[i].layer_id)) continue;
+        const char* nt = g->nodes[i].node_type;
+        if (!nt || strcmp(nt, type_filter) != 0) continue;
+        idx[live++] = i;
+    }
+    engram_sort_indices_by_salience(idx, live, g->nodes);
+    int64_t end = off + lim;
+    if (end > live) end = live;
+    int first = 1;
+    for (int64_t i = off; i < end; i++) {
+        if (!first) jb_putc(&b, ',');
+        engram_emit_node_json(&b, &g->nodes[idx[i]]);
+        first = 0;
+    }
+    free(idx);
+    jb_putc(&b, ']');
+    return el_wrap_str(b.buf);
+}
+
 el_val_t engram_neighbors_json(el_val_t node_id, el_val_t max_depth, el_val_t direction) {
     /* Re-implement here directly so we serialize without going through
      * the ElList path. Walks BFS to max_depth, emits {node, edge, hops}