V33: first live Neural API e2e pipeline — real primals through biomeOS routing

Discovery evolution: multi-probe fallback (lifecycle.status → health.check +
capabilities.list), BearDog Format E, Songbird Format F, semantic aliases,
base capability injection. 19 discovery tests.

New exp083: 10-check Neural API e2e (Blake3, SHA3-256, ChaCha20 roundtrip,
Songbird, capability listing) validated against live BearDog v0.9 + Songbird
v0.2.1 + biomeOS neural-api + ToadStool compute dispatch (RTX 4060).

Made-with: Cursor

Author: southgate

CHANGELOG.md

@@ -5,6 +5,43 @@ All notable changes to ludoSpring are documented in this file.
 Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 This project does not use SemVer — versions are session-sequential (V1–V32.2).
 
+## [V33] — 2026-03-29
+
+### Added — Neural API E2E Pipeline
+
+- **exp083_neural_api_e2e**: 10-check validation of full biomeOS Neural API pipeline
+  - Blake3 + SHA3-256 hashing via `capability.call` → BearDog
+  - ChaCha20-Poly1305 encrypt/decrypt roundtrip through Neural API routing
+  - Songbird network primal reachability via Neural API
+  - Capability listing verification (crypto, network domains)
+  - Sub-200ms latency assertion for routed crypto calls
+- **barracuda discovery evolution**: multi-probe fallback (`lifecycle.status` → `health.check` + `capabilities.list`)
+  - Format E: BearDog `provided_capabilities` (type + methods objects)
+  - Format F: Songbird flat capability arrays
+  - Semantic alias generation (`crypto` → `crypto.hash`, `crypto.encrypt`, `crypto.sign`)
+  - Auto-injection of `system.ping`, `health.check`, `health.liveness` for responsive primals
+  - 4 new unit tests for new formats (discovery tests 15→19)
+- **esotericWebb Neural API wiring**: `PrimalBridge.neural_api` field, `neural_api_call()` method,
+  `resilient_call()` fallback to `capability.call` when direct domain client absent
+  - `resolve_neural_api_socket()` in niche.rs now consumed by bridge `discover()`
+  - 322 esotericWebb tests pass with zero regressions
+
+### Validated — Live Primal E2E
+
+- BearDog v0.9.0 server on Unix socket (real Blake3, SHA3-256, ChaCha20-Poly1305, Ed25519)
+- Songbird v0.2.1 server on Unix socket (network discovery, federation)
+- biomeOS neural-api with 16 registered capabilities routing to live primals
+- ToadStool compute dispatch through Neural API (RTX 4060 detected, DRM mode)
+- exp042 9/9 against live BearDog + Songbird (first real-primal run)
+- exp083 10/10 full Neural API pipeline validation
+
+### Test counts
+
+- barracuda lib: 343 (discovery 19)
+- metalForge/forge: 26
+- esotericWebb: 322
+- Experiments: 83 (82 structural + exp083 live)
+
 ## [V32.2] — 2026-03-29
 
 ### Added

Cargo.lock

@@ -95,6 +95,7 @@ members = [
     "experiments/exp080_diablo_loot",
     "experiments/exp081_procedural_generation",
     "experiments/exp082_symphony_pipeline",
+    "experiments/exp083_neural_api_e2e",
 ]
 
 [workspace.package]

Cargo.toml

@@ -3,7 +3,7 @@
 An ecoPrimals Spring. Treats game design with the same rigor that wetSpring treats bioinformatics and hotSpring treats nuclear physics: validated models, reproducible experiments, GPU-accelerated computation where it matters.
 
 **Date:** March 29, 2026
-**Version:** V32.2 (82 experiments, 674 barracuda tests + 26 forge + 47 Python parity + 3 doctests, 19 proptest + 11 IPC integration)
+**Version:** V33 (83 experiments, 343 barracuda lib + 26 forge + 322 esotericWebb, Neural API e2e validated with live primals)
 **License:** AGPL-3.0-or-later (scyBorg triple: AGPL + ORC + CC-BY-SA-4.0)
 **MSRV:** 1.87 (edition 2024)
 **barraCuda:** v0.3.7 (standalone, default-features = false — CPU-only default, GPU opt-in)

README.md

@@ -88,18 +88,16 @@ pub fn discovery_dirs() -> Vec<PathBuf> {
         .collect()
 }
 
-/// Probe a Unix socket to check if it hosts a JSON-RPC primal.
-///
-/// Sends `lifecycle.status` and parses the response for name and capabilities.
-pub fn probe_socket(path: &Path) -> Option<PrimalEndpoint> {
+/// Send a single JSON-RPC request on a fresh connection and return the parsed response.
+fn rpc_probe(path: &Path, method: &str) -> Option<serde_json::Value> {
     let stream = UnixStream::connect(path).ok()?;
     let probe = Duration::from_millis(crate::tolerances::PROBE_TIMEOUT_MS);
     stream.set_read_timeout(Some(probe)).ok()?;
     stream.set_write_timeout(Some(probe)).ok()?;
 
     let request = serde_json::json!({
         "jsonrpc": "2.0",
-        "method": "lifecycle.status",
+        "method": method,
         "id": 1
     });
 
@@ -113,7 +111,28 @@ pub fn probe_socket(path: &Path) -> Option<PrimalEndpoint> {
     let mut response = String::new();
     reader.read_line(&mut response).ok()?;
 
-    let parsed: serde_json::Value = serde_json::from_str(&response).ok()?;
+    serde_json::from_str(&response).ok()
+}
+
+/// Probe a Unix socket to check if it hosts a JSON-RPC primal.
+///
+/// Tries `lifecycle.status` first (biomeOS standard), then falls back to
+/// `health.check` + `capabilities.list` (BearDog/Songbird convention).
+/// Any responsive primal also gets `health.check` and `system.ping`
+/// auto-registered since reachability implies ping-ability.
+pub fn probe_socket(path: &Path) -> Option<PrimalEndpoint> {
+    // Strategy 1: lifecycle.status (biomeOS standard — name + capabilities in one call)
+    if let Some(ep) = probe_lifecycle_status(path) {
+        return Some(ep);
+    }
+
+    // Strategy 2: health.check for identity, capabilities.list for capabilities
+    probe_health_then_capabilities(path)
+}
+
+/// Try `lifecycle.status` — the original biomeOS-standard probe.
+fn probe_lifecycle_status(path: &Path) -> Option<PrimalEndpoint> {
+    let parsed = rpc_probe(path, "lifecycle.status")?;
     let result = parsed.get("result")?;
 
     let name = result
@@ -122,7 +141,8 @@ pub fn probe_socket(path: &Path) -> Option<PrimalEndpoint> {
         .unwrap_or("unknown")
         .to_owned();
 
-    let capabilities = extract_capabilities(result);
+    let mut capabilities = extract_capabilities(result);
+    inject_base_capabilities(&mut capabilities);
 
     Some(PrimalEndpoint {
         socket: path.to_owned(),
@@ -131,6 +151,132 @@ pub fn probe_socket(path: &Path) -> Option<PrimalEndpoint> {
     })
 }
 
+/// Fallback probe: `health.check` for primal name, `capabilities.list` for capabilities.
+fn probe_health_then_capabilities(path: &Path) -> Option<PrimalEndpoint> {
+    let health = rpc_probe(path, "health.check")?;
+    let health_result = health.get("result")?;
+
+    let name = health_result
+        .get("primal")
+        .or_else(|| health_result.get("name"))
+        .and_then(serde_json::Value::as_str)
+        .unwrap_or("unknown")
+        .to_owned();
+
+    let mut capabilities = Vec::new();
+
+    if let Some(caps_resp) = rpc_probe(path, "capabilities.list") {
+        if let Some(result) = caps_resp.get("result") {
+            capabilities = extract_capabilities_from_any(result);
+        }
+    }
+
+    inject_base_capabilities(&mut capabilities);
+
+    Some(PrimalEndpoint {
+        socket: path.to_owned(),
+        name,
+        capabilities,
+    })
+}
+
+/// Extract capabilities from any known primal response format.
+///
+/// Handles 6 formats observed across the ecosystem:
+///
+/// - **Format A**: Flat string array `["cap1", "cap2"]`
+/// - **Format B**: Object array with `name` `[{"name": "cap1"}]`
+/// - **Format C**: Nested wrapper `{"capabilities": [...]}`
+/// - **Format D**: Double-nested `{"capabilities": {"capabilities": [...]}}`
+/// - **Format E**: BearDog `provided_capabilities` `[{"type": "crypto", "methods": [...]}]`
+/// - **Format F**: Top-level flat array (Songbird)
+fn extract_capabilities_from_any(value: &serde_json::Value) -> Vec<String> {
+    // Format F: top-level array (Songbird capabilities.list returns a direct array)
+    if let Some(arr) = value.as_array() {
+        return extract_from_array(arr);
+    }
+
+    let mut caps = Vec::new();
+
+    // Format E: BearDog provided_capabilities
+    if let Some(provided) = value
+        .get("provided_capabilities")
+        .and_then(serde_json::Value::as_array)
+    {
+        for entry in provided {
+            if let Some(cap_type) = entry.get("type").and_then(serde_json::Value::as_str) {
+                caps.push(cap_type.to_owned());
+                if let Some(methods) = entry.get("methods").and_then(serde_json::Value::as_array) {
+                    for m in methods {
+                        if let Some(method_name) = m.as_str() {
+                            caps.push(format!("{cap_type}.{method_name}"));
+                        }
+                    }
+                }
+            }
+        }
+        if !caps.is_empty() {
+            generate_semantic_aliases(&mut caps);
+            return caps;
+        }
+    }
+
+    // Formats A-D: delegate to existing extractor
+    let extracted = extract_capabilities(value);
+    if !extracted.is_empty() {
+        return extracted;
+    }
+
+    caps
+}
+
+/// Generate well-known semantic aliases from capability types.
+///
+/// When a primal advertises `crypto` with method-level capabilities like
+/// `crypto.blake3_hash`, also register `crypto.hash` since the primal
+/// likely implements the generic hash dispatcher.
+fn generate_semantic_aliases(caps: &mut Vec<String>) {
+    let has = |name: &str, list: &[String]| list.iter().any(|c| c == name);
+
+    let snapshot = caps.clone();
+    let mut additions = Vec::new();
+
+    if has("crypto", &snapshot) && !has("crypto.hash", &snapshot) {
+        additions.push("crypto.hash".to_owned());
+    }
+    if has("crypto", &snapshot) && !has("crypto.encrypt", &snapshot) {
+        if has("crypto.chacha20_poly1305_encrypt", &snapshot) {
+            additions.push("crypto.encrypt".to_owned());
+        }
+    }
+    if has("crypto", &snapshot) && !has("crypto.decrypt", &snapshot) {
+        if has("crypto.chacha20_poly1305_decrypt", &snapshot) {
+            additions.push("crypto.decrypt".to_owned());
+        }
+    }
+    if has("crypto", &snapshot) && !has("crypto.sign", &snapshot) {
+        if has("crypto.sign_ed25519", &snapshot) {
+            additions.push("crypto.sign".to_owned());
+        }
+    }
+    if has("crypto", &snapshot) && !has("crypto.verify", &snapshot) {
+        if has("crypto.verify_ed25519", &snapshot) {
+            additions.push("crypto.verify".to_owned());
+        }
+    }
+
+    caps.extend(additions);
+}
+
+/// Auto-register base capabilities for any responsive primal.
+fn inject_base_capabilities(caps: &mut Vec<String>) {
+    for base in ["system.ping", "health.check", "health.liveness"] {
+        if !caps.iter().any(|c| c == base) {
+            caps.push(base.to_owned());
+        }
+    }
+}
+
 /// Extract capabilities from a `lifecycle.status` or `capability.list` response.
 ///
 /// Handles all 4 formats observed across the ecosystem (airSpring v0.8.7,
@@ -400,6 +546,71 @@ mod tests {
         assert_eq!(caps, vec!["valid", "also_valid"]);
     }
 
+    #[test]
+    fn extract_format_e_beardog_provided_capabilities() {
+        let result = serde_json::json!({
+            "provided_capabilities": [
+                {
+                    "type": "crypto",
+                    "version": "1.0",
+                    "methods": ["blake3_hash", "hmac_sha256", "chacha20_poly1305_encrypt",
+                                "chacha20_poly1305_decrypt", "sign_ed25519", "verify_ed25519"]
+                },
+                {
+                    "type": "security",
+                    "methods": ["evaluate", "lineage"]
+                }
+            ]
+        });
+        let caps = extract_capabilities_from_any(&result);
+        assert!(caps.contains(&"crypto".to_owned()));
+        assert!(caps.contains(&"crypto.blake3_hash".to_owned()));
+        assert!(caps.contains(&"crypto.hash".to_owned()), "semantic alias");
+        assert!(caps.contains(&"crypto.encrypt".to_owned()), "semantic alias");
+        assert!(caps.contains(&"crypto.sign".to_owned()), "semantic alias");
+        assert!(caps.contains(&"security".to_owned()));
+        assert!(caps.contains(&"security.evaluate".to_owned()));
+    }
+
+    #[test]
+    fn extract_format_f_songbird_flat_array() {
+        let result = serde_json::json!([
+            "network.discovery",
+            "network.federation",
+            "ipc.jsonrpc",
+            "crypto.delegate"
+        ]);
+        let caps = extract_capabilities_from_any(&result);
+        assert_eq!(
+            caps,
+            vec![
+                "network.discovery",
+                "network.federation",
+                "ipc.jsonrpc",
+                "crypto.delegate"
+            ]
+        );
+    }
+
+    #[test]
+    fn inject_base_capabilities_adds_ping() {
+        let mut caps = vec!["crypto".to_owned()];
+        inject_base_capabilities(&mut caps);
+        assert!(caps.contains(&"system.ping".to_owned()));
+        assert!(caps.contains(&"health.check".to_owned()));
+        assert!(caps.contains(&"health.liveness".to_owned()));
+    }
+
+    #[test]
+    fn inject_base_capabilities_does_not_duplicate() {
+        let mut caps = vec!["system.ping".to_owned(), "health.check".to_owned()];
+        inject_base_capabilities(&mut caps);
+        assert_eq!(
+            caps.iter().filter(|c| c.as_str() == "system.ping").count(),
+            1
+        );
+    }
+
     // ── Proptest fuzz (airSpring v0.8.7 pattern) ────────────────────
 
     mod proptest_fuzz {

barracuda/src/ipc/discovery.rs

@@ -288,6 +288,16 @@ Core types: `barracuda/src/game/rpgpt/` (56 unit tests)
 - Plane transitions preserve complete world state with verified condition mapping
 - Round-trip (Dialogue->Tactical->Dialogue) demonstrates ruleset-agnostic state preservation
 
+### Track 25: Neural API End-to-End Pipeline (V33)
+
+First live e2e validation against real primal processes through biomeOS Neural API routing.
+
+| # | Package | Checks | Status | Reference | What it proves |
+|---|---------|--------|--------|-----------|----------------|
+| 083 | `ludospring-exp083` | 10 | PASS (live) | biomeOS capability_registry.toml | Neural API socket discovery, Blake3/SHA3-256 hash through `capability.call`, ChaCha20-Poly1305 encrypt/decrypt roundtrip, Songbird reachability, capability listing verification, sub-200ms routed latency |
+
+**Requires live primals**: BearDog server, Songbird server, biomeOS neural-api. Not structural — talks to real processes.
+
 ### metalForge Dispatch (Capability-Based Routing)
 
 | Binary | Checks | Status | Modules Validated |

experiments/README.md

@@ -0,0 +1,22 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+[package]
+name = "ludospring-exp083"
+version = "0.1.0"
+edition.workspace = true
+rust-version.workspace = true
+license.workspace = true
+publish = false
+
+[[bin]]
+name = "exp083_neural_api_e2e"
+path = "src/main.rs"
+
+[dependencies]
+ludospring-barracuda = { path = "../../barracuda", features = ["ipc"] }
+serde_json = "1"
+serde = { version = "1", features = ["derive"] }
+base64 = "0.22"
+
+[lints]
+workspace = true