initial: import DOLPHIN baseline 2026-04-21 from dolphinng5_predict working tree

Includes core prod + GREEN/BLUE subsystems:
- prod/ (BLUE harness, configs, scripts, docs)
- nautilus_dolphin/ (GREEN Nautilus-native impl + dvae/ preserved)
- adaptive_exit/ (AEM engine + models/bucket_assignments.pkl)
- Observability/ (EsoF advisor, TUI, dashboards)
- external_factors/ (EsoF producer)
- mc_forewarning_qlabs_fork/ (MC regime/envelope)

Excludes runtime caches, logs, backups, and reproducible artifacts per .gitignore.

prod/_hz_push.py

@@ -0,0 +1,94 @@
+"""Shared Hazelcast push utility for ExF/EsoF live daemons.
+ULTRA-PERFORMANT: Zero-allocation fast path, minimal logging.
+"""
+import json
+import logging
+import time
+from datetime import datetime, timezone
+from typing import Any, Dict, Optional, Tuple
+
+# Module-level logger
+logger = logging.getLogger(__name__)
+
+# Pre-compute level check for speed
+_LOG_DEBUG = logger.isEnabledFor(logging.DEBUG)
+_LOG_INFO = logger.isEnabledFor(logging.INFO)
+_LOG_WARNING = logger.isEnabledFor(logging.WARNING)
+
+# Constants
+HZ_CLUSTER   = "dolphin"
+HZ_MEMBER    = "localhost:5701"
+HZ_MAP_NAME  = "DOLPHIN_FEATURES"
+MAX_CONNECT_RETRIES = 3
+CONNECT_RETRY_DELAY = 1.0
+
+# Pre-allocate timestamp format string cache
+_TS_FORMAT = "%Y-%m-%dT%H:%M:%S.%f"
+
+
+def make_hz_client(max_retries: int = MAX_CONNECT_RETRIES, retry_delay: float = CONNECT_RETRY_DELAY):
+    """Create and return a connected HazelcastClient with retry logic."""
+    import hazelcast
+    
+    last_error = None
+    for attempt in range(1, max_retries + 1):
+        try:
+            client = hazelcast.HazelcastClient(
+                cluster_name=HZ_CLUSTER,
+                cluster_members=[HZ_MEMBER],
+                connection_timeout=5.0,
+            )
+            if _LOG_INFO:
+                logger.info("HZ connected (attempt %d)", attempt)
+            return client
+        except Exception as e:
+            last_error = e
+            if _LOG_WARNING:
+                logger.warning("HZ connect attempt %d/%d failed", attempt, max_retries)
+            if attempt < max_retries:
+                time.sleep(retry_delay * attempt)
+    
+    raise last_error
+
+
+def hz_push(imap_key: str, data: Dict[str, Any], client) -> bool:
+    """
+    Serialise `data` to JSON and put it on DOLPHIN_FEATURES[imap_key].
+    ZERO-ALLOCATION FAST PATH: No logging on success, minimal work.
+    Returns True on success, False on error.
+    """
+    try:
+        # Inline dict copy and timestamp to avoid function calls
+        payload = {
+            **data,
+            "_pushed_at": datetime.now(timezone.utc).isoformat(),
+            "_push_seq": int(time.time() * 1000)
+        }
+        
+        # Single call chain - no intermediates
+        client.get_map(HZ_MAP_NAME).blocking().put(imap_key, json.dumps(payload))
+        
+        if _LOG_DEBUG:
+            logger.debug("HZ push ok [%s]", imap_key)
+        return True
+    
+    except Exception as e:
+        # Only log errors - success path is silent
+        if _LOG_WARNING:
+            logger.warning("HZ push fail [%s]: %s", imap_key, type(e).__name__)
+        return False
+
+
+def hz_push_fast(imap_key: str, data: Dict[str, Any], client, _ts: datetime = None) -> bool:
+    """
+    ULTRA-FAST VARIANT: Pre-computed timestamp for batch operations.
+    Caller provides timestamp to avoid repeated datetime.now() calls.
+    """
+    try:
+        payload = data.copy()
+        payload["_pushed_at"] = _ts.isoformat() if _ts else datetime.now(timezone.utc).isoformat()
+        
+        client.get_map(HZ_MAP_NAME).blocking().put(imap_key, json.dumps(payload))
+        return True
+    except Exception:
+        return False