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.

nautilus_dolphin/tests/test_strategy_registration.py

@@ -0,0 +1,204 @@
+"""Tests for Strategy Registration.
+
+Uses proper Nautilus initialization pattern from test_0_nautilus_bootstrap.py
+"""
+
+import pytest
+from unittest.mock import Mock, patch
+
+
+class TestDolphinStrategyConfig:
+    """Test DolphinStrategyConfig initialization."""
+    
+    def test_default_config(self):
+        """Test default strategy configuration values."""
+        from nautilus_dolphin.nautilus.strategy_registration import DolphinStrategyConfig
+        
+        config = DolphinStrategyConfig()
+        
+        assert config.venue == "BINANCE_FUTURES"
+        assert config.irp_alignment_min == 0.45
+        assert config.momentum_magnitude_min == 0.000075
+        assert config.excluded_assets == ['TUSDUSDT', 'USDCUSDT']
+        assert config.min_leverage == 0.5
+        assert config.max_leverage == 5.0
+        assert config.leverage_convexity == 3.0
+        assert config.capital_fraction == 0.20
+        assert config.tp_bps == 99
+        assert config.max_hold_bars == 120
+        assert config.max_concurrent_positions == 10
+        assert config.daily_loss_limit_pct == 10.0
+        assert config.acb_enabled is True
+    
+    def test_custom_config(self):
+        """Test custom strategy configuration."""
+        from nautilus_dolphin.nautilus.strategy_registration import DolphinStrategyConfig
+        
+        config = DolphinStrategyConfig(
+            venue="BINANCE_SPOT",
+            max_leverage=3.0,
+            acb_enabled=False,
+            tp_bps=150
+        )
+        
+        assert config.venue == "BINANCE_SPOT"
+        assert config.max_leverage == 3.0
+        assert config.acb_enabled is False
+        assert config.tp_bps == 150
+    
+    def test_to_dict(self):
+        """Test conversion to dictionary."""
+        from nautilus_dolphin.nautilus.strategy_registration import DolphinStrategyConfig
+        
+        config = DolphinStrategyConfig(max_leverage=3.0)
+        config_dict = config.to_dict()
+        
+        assert config_dict['venue'] == "BINANCE_FUTURES"
+        assert config_dict['max_leverage'] == 3.0
+        assert 'acb_enabled' in config_dict
+
+
+class TestStrategyConfigCreation:
+    """Test creation of Nautilus ImportableStrategyConfig."""
+    
+    def test_create_strategy_config(self):
+        """Test creating ImportableStrategyConfig."""
+        from nautilus_dolphin.nautilus.strategy_registration import (
+            DolphinStrategyConfig, create_strategy_config
+        )
+        
+        config = DolphinStrategyConfig(max_leverage=3.0)
+        strategy_config = create_strategy_config(config)
+        
+        assert strategy_config is not None
+        assert strategy_config.strategy_path == 'nautilus_dolphin.nautilus.strategy:DolphinExecutionStrategy'
+        assert strategy_config.config_path == 'nautilus_dolphin.nautilus.strategy:DolphinExecutionStrategy'
+    
+    def test_create_strategy_config_content(self):
+        """Test creating ImportableStrategyConfig has correct content."""
+        from nautilus_dolphin.nautilus.strategy_registration import (
+            DolphinStrategyConfig, create_strategy_config
+        )
+        
+        config = DolphinStrategyConfig(max_leverage=3.0)
+        strategy_config = create_strategy_config(config)
+        
+        assert strategy_config.config['max_leverage'] == 3.0
+        assert strategy_config.strategy_path == 'nautilus_dolphin.nautilus.strategy:DolphinExecutionStrategy'
+    
+    def test_create_default_strategy_config(self):
+        """Test creating default strategy config."""
+        from nautilus_dolphin.nautilus.strategy_registration import create_default_strategy_config
+        
+        strategy_config = create_default_strategy_config()
+        
+        assert strategy_config is not None
+        assert strategy_config.strategy_path == 'nautilus_dolphin.nautilus.strategy:DolphinExecutionStrategy'
+
+
+class TestStrategyRegistry:
+    """Test StrategyRegistry for managing multiple strategies."""
+    
+    def test_register_single_strategy(self):
+        """Test registering a single strategy."""
+        from nautilus_dolphin.nautilus.strategy_registration import (
+            StrategyRegistry, DolphinStrategyConfig
+        )
+        
+        registry = StrategyRegistry()
+        config = DolphinStrategyConfig()
+        
+        strategy_config = registry.register("dolphin_001", config)
+        
+        assert strategy_config is not None
+        assert len(registry.get_configs()) == 1
+        assert registry.get_config("dolphin_001") == config
+    
+    def test_register_multiple_strategies(self):
+        """Test registering multiple strategies."""
+        from nautilus_dolphin.nautilus.strategy_registration import (
+            StrategyRegistry, DolphinStrategyConfig
+        )
+        
+        registry = StrategyRegistry()
+        
+        config1 = DolphinStrategyConfig(max_leverage=3.0)
+        config2 = DolphinStrategyConfig(max_leverage=5.0)
+        
+        registry.register("dolphin_3x", config1)
+        registry.register("dolphin_5x", config2)
+        
+        assert len(registry.get_configs()) == 2
+        assert registry.get_config("dolphin_3x").max_leverage == 3.0
+        assert registry.get_config("dolphin_5x").max_leverage == 5.0
+    
+    def test_create_backtest_strategies_default(self):
+        """Test creating backtest strategies with default config."""
+        from nautilus_dolphin.nautilus.strategy_registration import StrategyRegistry
+        
+        registry = StrategyRegistry()
+        configs = registry.create_backtest_strategies()
+        
+        assert len(configs) == 1
+    
+    def test_create_backtest_strategies_variations(self):
+        """Test creating backtest strategies with parameter variations."""
+        from nautilus_dolphin.nautilus.strategy_registration import StrategyRegistry
+        
+        registry = StrategyRegistry()
+        
+        variations = [
+            {'max_leverage': 3.0, 'tp_bps': 50},
+            {'max_leverage': 5.0, 'tp_bps': 99},
+        ]
+        
+        configs = registry.create_backtest_strategies(variations)
+        
+        assert len(configs) == 2
+
+
+class TestStrategyConfigFromDict:
+    """Test creating strategy config from dictionary."""
+    
+    def test_create_from_dict(self):
+        """Test creating strategy config from dictionary."""
+        from nautilus_dolphin.nautilus.strategy_registration import (
+            create_strategy_configs_from_dict
+        )
+        
+        config_dict = {
+            'venue': 'BINANCE_FUTURES',
+            'max_leverage': 3.0,
+            'acb_enabled': False,
+            'custom_param': 'value'  # Extra param goes to extra_config
+        }
+        
+        strategy_config = create_strategy_configs_from_dict(config_dict)
+        
+        assert strategy_config is not None
+        # Check that extra params are in the config dict
+        assert strategy_config.config.get('custom_param') == 'value'
+
+
+class TestStrategyIntegrationWithLauncher:
+    """Test strategy integration with launcher."""
+    
+    def test_launcher_with_strategy_config(self):
+        """Test launcher accepts strategy configuration."""
+        from nautilus_dolphin.nautilus.launcher import NautilusDolphinLauncher
+        
+        launcher_config = {
+            'venue': 'BINANCE_FUTURES',
+            'environment': 'BACKTEST',
+            'trader_id': 'TEST-001',
+            'strategy': {
+                'venue': 'BINANCE_FUTURES',
+                'max_leverage': 3.0,
+                'acb_enabled': True,
+            }
+        }
+        
+        launcher = NautilusDolphinLauncher(launcher_config)
+        
+        assert 'strategy' in launcher.config
+        assert launcher.config['strategy']['max_leverage'] == 3.0