S203b: LD-04 persistent connections + LD-05 socket separation

Fix primalSpring audit findings:
- LD-04: Evolve HTTP to keep-alive loop, NDJSON to skip blank lines.
  Multi-step dispatch sequences no longer get broken pipe.
- LD-05: Separate JSON-RPC (compute.sock) and tarpc (compute-tarpc.sock)
  sockets. Resolves internal bind collision and clears namespace for barraCuda.
+7 tests. All quality gates green.

Made-with: Cursor

Author: westgate

CHANGELOG.md

@@ -7,6 +7,36 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased] - April 12, 2026 (Sessions 43-203)
 
+### Session S203b (Apr 12, 2026) — primalSpring LD-04/LD-05: Persistent Connections + Socket Separation
+
+#### LD-04: UDS/TCP Persistent Connection (Blocking)
+- EVOLVED: HTTP mode from single-shot (`Connection: close`, return) to HTTP/1.1 keep-alive loop
+- EVOLVED: NDJSON mode — empty lines between requests now skipped (previously broke connection)
+- FIXED: Multi-step dispatch sequences (submit → status → result) no longer get broken pipe
+- ADDED: `handle_http_keepalive_unix` / `handle_http_keepalive_tcp` — keep-alive loop respecting `Connection` header
+- ADDED: `handle_ndjson_unix` / `handle_ndjson_tcp` — extracted persistent NDJSON handlers
+- Files: `connection/unix.rs`, `connection/tcp.rs`
+
+#### LD-05: Socket Namespace Separation
+- FIXED: JSON-RPC and tarpc no longer bind the same `compute.sock` (race condition: tarpc overwrote JSON-RPC socket)
+- SEPARATED: JSON-RPC primary → `compute.sock`, tarpc secondary → `compute-tarpc.sock`
+- ADDED: `tarpc_socket_filename_for_family()` in `unibin/format.rs` for family-scoped tarpc socket names
+- UPDATED: Shutdown cleanup handles both socket files
+- Files: `unibin/mod.rs`, `unibin/format.rs`
+
+#### Tests
+- ADDED: `test_tcp_http_keepalive_multi_request` — two HTTP requests on one TCP connection
+- ADDED: `test_unix_http_keepalive_multi_request` — two HTTP requests on one UDS connection
+- ADDED: `test_ndjson_with_blank_lines_between_requests` — blank lines between NDJSON requests
+- ADDED: `test_ndjson_unix_persistent_multi_request` — three NDJSON requests on one UDS connection
+- ADDED: `tarpc_socket_filename_for_family_*` — 3 socket naming tests
+
+#### Quality Gates
+- `cargo fmt`: PASS
+- `cargo clippy --workspace --all-targets`: PASS (0 warnings)
+- `cargo doc --workspace --no-deps`: PASS (0 warnings)
+- `cargo test --workspace`: PASS (0 failures)
+
 ### Session S203 (Apr 12, 2026) — Composition Elevation Sprint + Deep Debt Execution
 
 #### Dispatch Wire Contract Standardization (Blocking Composition)

DEBT.md

@@ -62,6 +62,31 @@ stable in Rust. Cannot resolve until Rust stabilizes this feature. The `#[async_
 dependency is pure Rust (proc-macro) and zero-overhead at runtime for non-dyn paths.
 **Not actionable** — resolves when Rust stabilizes the feature. Markers are accurate documentation.
 
+### D-UDS-SINGLE-SHOT — RESOLVED S203
+**Crate**: `server` | **Audit**: LD-04 (primalSpring downstream)
+HTTP mode in `pure_jsonrpc/connection/unix.rs` and `tcp.rs` was single-shot:
+processed one request, wrote `Connection: close`, and returned. Multi-step
+dispatch sequences (submit → status → result) got broken pipe on second call.
+**Fix**: Evolved to HTTP/1.1 keep-alive loop — server reads subsequent HTTP
+requests on the same connection until client sends `Connection: close` or EOF.
+NDJSON mode also fixed: empty lines between requests now skipped (previously
+broke the connection). +7 tests covering keep-alive and NDJSON persistence.
+Files: `connection/unix.rs`, `connection/tcp.rs`, `connection/tests.rs`.
+
+### D-SOCKET-NAMESPACE-COLLISION — RESOLVED S203
+**Crate**: `server` | **Audit**: LD-05 (primalSpring downstream)
+JSON-RPC and tarpc servers both bound the same `compute.sock` — tarpc's
+`serve_unix` removed JSON-RPC's socket file and re-bound, orphaning the
+JSON-RPC listener. Clients connecting to `compute.sock` would reach the
+tarpc binary framing, not JSON-RPC.
+**Fix**: Separated socket paths: JSON-RPC primary on `compute.sock`,
+tarpc secondary on `compute-tarpc.sock`. New `tarpc_socket_filename_for_family`
+helper generates family-scoped tarpc socket names. Cleanup at shutdown handles
+both sockets. This also resolves the barraCuda namespace conflict: toadStool
+claims `compute.sock` / `compute-tarpc.sock`, leaving `compute-math.sock`
+available for barraCuda.
+Files: `unibin/mod.rs`, `unibin/format.rs`.
+
 ## S203 Resolved Debt (Deep Audit & Evolution Execution)
 
 ### D-RUSTIX-DISPLAY-038 — RESOLVED S203

crates/server/src/pure_jsonrpc/connection/tcp.rs

@@ -41,10 +41,11 @@ pub async fn serve_tcp(handler: Arc<JsonRpcHandler>, listener: TcpListener) -> S
     }
 }
 
-/// Handle a single TCP connection.
+/// Handle a single TCP connection with persistent keep-alive.
 ///
-/// Supports both HTTP (single request-response) and persistent NDJSON sessions
-/// per `PRIMAL_IPC_PROTOCOL.md`.
+/// Supports both HTTP/1.1 keep-alive and persistent NDJSON sessions per
+/// `PRIMAL_IPC_PROTOCOL.md`. Multi-step dispatch sequences (submit → status →
+/// result) and health checks reuse the same connection without reconnecting.
 pub(crate) async fn handle_tcp_connection(
     handler: Arc<JsonRpcHandler>,
     stream: TcpStream,
@@ -53,42 +54,93 @@ pub(crate) async fn handle_tcp_connection(
     let mut reader = BufReader::new(reader);
 
     let mut first_line = String::new();
-    reader
+    let n = reader
         .read_line(&mut first_line)
         .await
         .map_err(|e| ServerError::Network(e.to_string()))?;
+    if n == 0 {
+        return Ok(());
+    }
 
     if first_line.starts_with("POST")
         || first_line.starts_with("GET")
         || first_line.starts_with("HTTP")
     {
-        let (_headers, body) = read_http_request_continuation_tcp(&mut reader).await?;
-        let response_body = process_request(&handler, &body).await?;
-        write_http_response_tcp(&mut writer, &response_body).await?;
-        return Ok(());
+        return handle_http_keepalive_tcp(handler, &mut reader, &mut writer, first_line).await;
     }
 
-    // NDJSON session: process first line, then loop for subsequent lines
-    let mut line = first_line;
+    handle_ndjson_tcp(handler, &mut reader, &mut writer, first_line).await
+}
+
+/// HTTP/1.1 keep-alive loop for TCP connections.
+async fn handle_http_keepalive_tcp(
+    handler: Arc<JsonRpcHandler>,
+    reader: &mut BufReader<tokio::net::tcp::OwnedReadHalf>,
+    writer: &mut tokio::net::tcp::OwnedWriteHalf,
+    first_request_line: String,
+) -> ServerResult<()> {
+    let mut request_line = first_request_line;
     loop {
-        let trimmed = line.trim();
-        if trimmed.is_empty() {
+        let (headers, body) = read_http_request_continuation_tcp(reader).await?;
+        let response_body = process_request(&handler, &body).await?;
+
+        let client_wants_close = headers
+            .get("connection")
+            .is_some_and(|v| v.eq_ignore_ascii_case("close"));
+
+        write_http_response_tcp(writer, &response_body, client_wants_close).await?;
+
+        if client_wants_close {
             break;
         }
 
-        let response_body = process_request(&handler, trimmed.as_bytes()).await?;
-        writer
-            .write_all(&response_body)
-            .await
-            .map_err(|e| ServerError::Network(e.to_string()))?;
-        writer
-            .write_all(b"\n")
-            .await
-            .map_err(|e| ServerError::Network(e.to_string()))?;
-        writer
-            .flush()
+        request_line.clear();
+        let n = reader
+            .read_line(&mut request_line)
             .await
             .map_err(|e| ServerError::Network(e.to_string()))?;
+        if n == 0 {
+            break;
+        }
+        let trimmed = request_line.trim();
+        if trimmed.is_empty() {
+            continue;
+        }
+        if !trimmed.starts_with("POST")
+            && !trimmed.starts_with("GET")
+            && !trimmed.starts_with("HTTP")
+        {
+            break;
+        }
+    }
+    Ok(())
+}
+
+/// NDJSON persistent session for TCP connections.
+async fn handle_ndjson_tcp(
+    handler: Arc<JsonRpcHandler>,
+    reader: &mut BufReader<tokio::net::tcp::OwnedReadHalf>,
+    writer: &mut tokio::net::tcp::OwnedWriteHalf,
+    first_line: String,
+) -> ServerResult<()> {
+    let mut line = first_line;
+    loop {
+        let trimmed = line.trim();
+        if !trimmed.is_empty() {
+            let response_body = process_request(&handler, trimmed.as_bytes()).await?;
+            writer
+                .write_all(&response_body)
+                .await
+                .map_err(|e| ServerError::Network(e.to_string()))?;
+            writer
+                .write_all(b"\n")
+                .await
+                .map_err(|e| ServerError::Network(e.to_string()))?;
+            writer
+                .flush()
+                .await
+                .map_err(|e| ServerError::Network(e.to_string()))?;
+        }
 
         line.clear();
         let n = reader
@@ -99,7 +151,6 @@ pub(crate) async fn handle_tcp_connection(
             break;
         }
     }
-
     Ok(())
 }
 
@@ -140,12 +191,18 @@ async fn read_http_request_continuation_tcp(
 async fn write_http_response_tcp(
     writer: &mut tokio::net::tcp::OwnedWriteHalf,
     body: &[u8],
+    closing: bool,
 ) -> ServerResult<()> {
+    let conn_header = if closing {
+        "Connection: close"
+    } else {
+        "Connection: keep-alive"
+    };
     let header = format!(
         "HTTP/1.1 200 OK\r\n\
          Content-Type: application/json\r\n\
          Content-Length: {}\r\n\
-         Connection: close\r\n\
+         {conn_header}\r\n\
          \r\n",
         body.len()
     );

crates/server/src/pure_jsonrpc/connection/tests.rs

@@ -221,6 +221,170 @@ async fn test_serve_unix_accepts_http_post() {
     assert!(response.contains("test-conn-1.0.0"));
 }
 
+#[tokio::test]
+async fn test_tcp_http_keepalive_multi_request() {
+    let handler = Arc::new(test_handler());
+    let listener = TcpListener::bind("127.0.0.1:0").await.expect("bind");
+    let addr = listener.local_addr().expect("addr");
+
+    let server_handler = Arc::clone(&handler);
+    let _server = tokio::spawn(async move {
+        let (stream, _) = listener.accept().await.expect("accept");
+        handle_tcp_connection(server_handler, stream).await.expect("ok");
+    });
+
+    let mut client = TcpStream::connect(addr).await.expect("connect");
+
+    // First request (keep-alive default)
+    let body1 = r#"{"jsonrpc":"2.0","method":"toadstool.health","id":1}"#;
+    let http1 = format!(
+        "POST /rpc HTTP/1.1\r\nContent-Type: application/json\r\nContent-Length: {}\r\n\r\n{}",
+        body1.len(),
+        body1
+    );
+    client.write_all(http1.as_bytes()).await.expect("write1");
+
+    let mut buf = vec![0u8; 4096];
+    let n = client.read(&mut buf).await.expect("read1");
+    let resp1 = String::from_utf8_lossy(&buf[..n]);
+    assert!(resp1.contains("HTTP/1.1 200 OK"), "first response ok");
+    assert!(
+        resp1.contains("Connection: keep-alive"),
+        "keep-alive header present"
+    );
+    assert!(resp1.contains("healthy"), "first response has health data");
+
+    // Second request on same connection (Connection: close to end)
+    let body2 = r#"{"jsonrpc":"2.0","method":"toadstool.version","id":2}"#;
+    let http2 = format!(
+        "POST /rpc HTTP/1.1\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
+        body2.len(),
+        body2
+    );
+    client.write_all(http2.as_bytes()).await.expect("write2");
+
+    let mut buf2 = Vec::new();
+    client.read_to_end(&mut buf2).await.expect("read2");
+    let resp2 = String::from_utf8_lossy(&buf2);
+    assert!(resp2.contains("HTTP/1.1 200 OK"), "second response ok");
+    assert!(
+        resp2.contains("Connection: close"),
+        "close header on final response"
+    );
+}
+
+#[tokio::test]
+async fn test_unix_http_keepalive_multi_request() {
+    let handler = Arc::new(test_handler());
+    let dir = tempfile::tempdir().expect("tempdir");
+    let socket_path = dir.path().join("keepalive.sock");
+
+    let server_handler = Arc::clone(&handler);
+    let sock_path = socket_path.clone();
+    let _server = tokio::spawn(async move {
+        serve_unix(server_handler, sock_path).await.expect("serve");
+    });
+
+    let mut stream = await_unix_socket(&socket_path).await;
+
+    // First request (keep-alive)
+    let body1 = r#"{"jsonrpc":"2.0","method":"toadstool.health","id":1}"#;
+    let http1 = format!(
+        "POST /rpc HTTP/1.1\r\nContent-Type: application/json\r\nContent-Length: {}\r\n\r\n{}",
+        body1.len(),
+        body1
+    );
+    stream.write_all(http1.as_bytes()).await.expect("write1");
+
+    let mut buf = vec![0u8; 4096];
+    let n = stream.read(&mut buf).await.expect("read1");
+    let resp1 = String::from_utf8_lossy(&buf[..n]);
+    assert!(resp1.contains("Connection: keep-alive"));
+
+    // Second request on same connection
+    let body2 = r#"{"jsonrpc":"2.0","method":"toadstool.version","id":2}"#;
+    let http2 = format!(
+        "POST /rpc HTTP/1.1\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
+        body2.len(),
+        body2
+    );
+    stream.write_all(http2.as_bytes()).await.expect("write2");
+
+    let mut buf2 = Vec::new();
+    stream.read_to_end(&mut buf2).await.expect("read2");
+    let resp2 = String::from_utf8_lossy(&buf2);
+    assert!(resp2.contains("HTTP/1.1 200 OK"));
+    assert!(resp2.contains("Connection: close"));
+}
+
+#[tokio::test]
+async fn test_ndjson_with_blank_lines_between_requests() {
+    let handler = Arc::new(test_handler());
+    let listener = TcpListener::bind("127.0.0.1:0").await.expect("bind");
+    let addr = listener.local_addr().expect("addr");
+
+    let server_handler = Arc::clone(&handler);
+    let _server = tokio::spawn(async move {
+        let (stream, _) = listener.accept().await.expect("accept");
+        handle_tcp_connection(server_handler, stream).await.expect("ok");
+    });
+
+    let mut client = TcpStream::connect(addr).await.expect("connect");
+
+    // Send two NDJSON requests with a blank line between them
+    let requests = concat!(
+        "{\"jsonrpc\":\"2.0\",\"method\":\"toadstool.health\",\"id\":1}\n",
+        "\n",
+        "{\"jsonrpc\":\"2.0\",\"method\":\"toadstool.version\",\"id\":2}\n",
+    );
+    client.write_all(requests.as_bytes()).await.expect("write");
+    client.shutdown().await.ok();
+
+    let mut buf = Vec::new();
+    client.read_to_end(&mut buf).await.expect("read");
+    let text = String::from_utf8_lossy(&buf);
+    let responses: Vec<&str> = text.lines().collect();
+    assert!(
+        responses.len() >= 2,
+        "expected 2 responses, got {}: {text}",
+        responses.len()
+    );
+
+    let r1: serde_json::Value = serde_json::from_str(responses[0]).expect("json1");
+    assert!(r1["result"]["healthy"].as_bool().is_some());
+    let r2: serde_json::Value = serde_json::from_str(responses[1]).expect("json2");
+    assert!(r2["result"]["version"].as_str().is_some());
+}
+
+#[tokio::test]
+async fn test_ndjson_unix_persistent_multi_request() {
+    let handler = Arc::new(test_handler());
+    let dir = tempfile::tempdir().expect("tempdir");
+    let socket_path = dir.path().join("ndjson-multi.sock");
+
+    let server_handler = Arc::clone(&handler);
+    let sock_path = socket_path.clone();
+    let _server = tokio::spawn(async move {
+        serve_unix(server_handler, sock_path).await.expect("serve");
+    });
+
+    let mut stream = await_unix_socket(&socket_path).await;
+
+    // Send three requests on the same connection
+    let r1 = b"{\"jsonrpc\":\"2.0\",\"method\":\"toadstool.health\",\"id\":1}\n";
+    let r2 = b"{\"jsonrpc\":\"2.0\",\"method\":\"toadstool.version\",\"id\":2}\n";
+    let r3 = b"{\"jsonrpc\":\"2.0\",\"method\":\"toadstool.health\",\"id\":3}\n";
+    stream.write_all(r1).await.expect("w1");
+    stream.write_all(r2).await.expect("w2");
+    stream.write_all(r3).await.expect("w3");
+    stream.shutdown().await.ok();
+
+    let mut buf = Vec::new();
+    stream.read_to_end(&mut buf).await.expect("read");
+    let text = String::from_utf8_lossy(&buf);
+    assert_eq!(text.lines().count(), 3, "expected 3 responses: {text}");
+}
+
 #[tokio::test]
 async fn test_process_request_partial_json() {
     let handler = test_handler();