wip model CP storage/loading,

models are aware of current position
fix kill stale procc task

web/clean_dashboard.py

@@ -239,8 +239,18 @@ class CleanTradingDashboard:
         self._cached_live_balance: float = 0.0
         
         # ENHANCED: Model control toggles - separate inference and training
+        # Initialize with defaults, will be updated from orchestrator's persisted state
         self.dqn_inference_enabled = True  # Default: enabled
         self.dqn_training_enabled = True   # Default: enabled
+        self.cnn_inference_enabled = True
+        self.cnn_training_enabled = True
+        self.cob_rl_inference_enabled = True  # Default: enabled
+        self.cob_rl_training_enabled = True   # Default: enabled
+        self.decision_fusion_inference_enabled = True  # Default: enabled
+        self.decision_fusion_training_enabled = True   # Default: enabled
+        
+        # Load persisted UI state from orchestrator
+        self._sync_ui_state_from_orchestrator()
         
         # Trading mode and cold start settings from config
         from core.config import get_config
@@ -254,8 +264,6 @@ class CleanTradingDashboard:
         self.cold_start_enabled = config.get('cold_start', {}).get('enabled', True)
         
         logger.info(f"Dashboard initialized - Trading Mode: {'LIVE' if self.trading_mode_live else 'SIM'}, Cold Start: {'ON' if self.cold_start_enabled else 'OFF'}")
-        self.cnn_inference_enabled = True
-        self.cnn_training_enabled = True
         
         # Leverage management - adjustable x1 to x100
         self.current_leverage = 50  # Default x50 leverage
@@ -1145,12 +1153,12 @@ class CleanTradingDashboard:
                     for model_name in ["dqn", "cnn", "cob_rl", "decision_fusion"]:
                         toggle_states[model_name] = self.orchestrator.get_model_toggle_state(model_name)
                 else:
-                    # Fallback to dashboard state
+                    # Fallback to dashboard state - use actual dashboard state variables
                     toggle_states = {
                         "dqn": {"inference_enabled": self.dqn_inference_enabled, "training_enabled": self.dqn_training_enabled},
                         "cnn": {"inference_enabled": self.cnn_inference_enabled, "training_enabled": self.cnn_training_enabled},
-                        "cob_rl": {"inference_enabled": True, "training_enabled": True},
-                        "decision_fusion": {"inference_enabled": True, "training_enabled": True}
+                        "cob_rl": {"inference_enabled": self.cob_rl_inference_enabled, "training_enabled": self.cob_rl_training_enabled},
+                        "decision_fusion": {"inference_enabled": self.decision_fusion_inference_enabled, "training_enabled": self.decision_fusion_training_enabled}
                     }
                 # Now using slow-interval-component (10s) - no batching needed
                 
@@ -1330,6 +1338,8 @@ class CleanTradingDashboard:
             if self.orchestrator:
                 enabled = bool(value and len(value) > 0)  # Convert list to boolean
                 self.orchestrator.set_model_toggle_state("dqn", inference_enabled=enabled)
+                # Update dashboard state variable
+                self.dqn_inference_enabled = enabled
                 logger.info(f"DQN inference toggle: {enabled}")
             return value
 
@@ -1342,6 +1352,8 @@ class CleanTradingDashboard:
             if self.orchestrator:
                 enabled = bool(value and len(value) > 0)  # Convert list to boolean
                 self.orchestrator.set_model_toggle_state("dqn", training_enabled=enabled)
+                # Update dashboard state variable
+                self.dqn_training_enabled = enabled
                 logger.info(f"DQN training toggle: {enabled}")
             return value
 
@@ -1354,6 +1366,8 @@ class CleanTradingDashboard:
             if self.orchestrator:
                 enabled = bool(value and len(value) > 0)  # Convert list to boolean
                 self.orchestrator.set_model_toggle_state("cnn", inference_enabled=enabled)
+                # Update dashboard state variable
+                self.cnn_inference_enabled = enabled
                 logger.info(f"CNN inference toggle: {enabled}")
             return value
 
@@ -1366,6 +1380,8 @@ class CleanTradingDashboard:
             if self.orchestrator:
                 enabled = bool(value and len(value) > 0)  # Convert list to boolean
                 self.orchestrator.set_model_toggle_state("cnn", training_enabled=enabled)
+                # Update dashboard state variable
+                self.cnn_training_enabled = enabled
                 logger.info(f"CNN training toggle: {enabled}")
             return value
 
@@ -1378,6 +1394,8 @@ class CleanTradingDashboard:
             if self.orchestrator:
                 enabled = bool(value and len(value) > 0)  # Convert list to boolean
                 self.orchestrator.set_model_toggle_state("cob_rl", inference_enabled=enabled)
+                # Update dashboard state variable
+                self.cob_rl_inference_enabled = enabled
                 logger.info(f"COB RL inference toggle: {enabled}")
             return value
 
@@ -1390,6 +1408,8 @@ class CleanTradingDashboard:
             if self.orchestrator:
                 enabled = bool(value and len(value) > 0)  # Convert list to boolean
                 self.orchestrator.set_model_toggle_state("cob_rl", training_enabled=enabled)
+                # Update dashboard state variable
+                self.cob_rl_training_enabled = enabled
                 logger.info(f"COB RL training toggle: {enabled}")
             return value
 
@@ -1402,6 +1422,8 @@ class CleanTradingDashboard:
             if self.orchestrator:
                 enabled = bool(value and len(value) > 0)  # Convert list to boolean
                 self.orchestrator.set_model_toggle_state("decision_fusion", inference_enabled=enabled)
+                # Update dashboard state variable
+                self.decision_fusion_inference_enabled = enabled
                 logger.info(f"Decision Fusion inference toggle: {enabled}")
             return value
 
@@ -1414,6 +1436,8 @@ class CleanTradingDashboard:
             if self.orchestrator:
                 enabled = bool(value and len(value) > 0)  # Convert list to boolean
                 self.orchestrator.set_model_toggle_state("decision_fusion", training_enabled=enabled)
+                # Update dashboard state variable
+                self.decision_fusion_training_enabled = enabled
                 logger.info(f"Decision Fusion training toggle: {enabled}")
             return value
             """Update cold start training mode"""
@@ -3378,13 +3402,13 @@ class CleanTradingDashboard:
                 except Exception as e:
                     logger.debug(f"Error getting orchestrator model statistics: {e}")
             
-            # Ensure toggle_states are available
+            # Ensure toggle_states are available - use dashboard state variables as fallback
             if toggle_states is None:
                 toggle_states = {
-                    "dqn": {"inference_enabled": True, "training_enabled": True},
-                    "cnn": {"inference_enabled": True, "training_enabled": True},
-                    "cob_rl": {"inference_enabled": True, "training_enabled": True},
-                    "decision_fusion": {"inference_enabled": True, "training_enabled": True}
+                    "dqn": {"inference_enabled": self.dqn_inference_enabled, "training_enabled": self.dqn_training_enabled},
+                    "cnn": {"inference_enabled": self.cnn_inference_enabled, "training_enabled": self.cnn_training_enabled},
+                    "cob_rl": {"inference_enabled": self.cob_rl_inference_enabled, "training_enabled": self.cob_rl_training_enabled},
+                    "decision_fusion": {"inference_enabled": self.decision_fusion_inference_enabled, "training_enabled": self.decision_fusion_training_enabled}
                 }
             
             # Helper function to safely calculate improvement percentage
@@ -8275,6 +8299,37 @@ class CleanTradingDashboard:
         except Exception as e:
             logger.error(f"Error handling trading decision: {e}")
     
+    def _sync_ui_state_from_orchestrator(self):
+        """Sync dashboard UI state with orchestrator's persisted state"""
+        try:
+            if self.orchestrator and hasattr(self.orchestrator, 'model_toggle_states'):
+                # Get persisted states from orchestrator
+                toggle_states = self.orchestrator.model_toggle_states
+                
+                # Update dashboard state variables for all models
+                if 'dqn' in toggle_states:
+                    self.dqn_inference_enabled = toggle_states['dqn'].get('inference_enabled', True)
+                    self.dqn_training_enabled = toggle_states['dqn'].get('training_enabled', True)
+                
+                if 'cnn' in toggle_states:
+                    self.cnn_inference_enabled = toggle_states['cnn'].get('inference_enabled', True)
+                    self.cnn_training_enabled = toggle_states['cnn'].get('training_enabled', True)
+                
+                # Add COB RL and Decision Fusion state sync
+                if 'cob_rl' in toggle_states:
+                    self.cob_rl_inference_enabled = toggle_states['cob_rl'].get('inference_enabled', True)
+                    self.cob_rl_training_enabled = toggle_states['cob_rl'].get('training_enabled', True)
+                
+                if 'decision_fusion' in toggle_states:
+                    self.decision_fusion_inference_enabled = toggle_states['decision_fusion'].get('inference_enabled', True)
+                    self.decision_fusion_training_enabled = toggle_states['decision_fusion'].get('training_enabled', True)
+                
+                logger.info(f"✅ UI state synced from orchestrator: DQN(inf:{self.dqn_inference_enabled}, train:{self.dqn_training_enabled}), CNN(inf:{self.cnn_inference_enabled}, train:{self.cnn_training_enabled}), COB_RL(inf:{getattr(self, 'cob_rl_inference_enabled', True)}, train:{getattr(self, 'cob_rl_training_enabled', True)}), Decision_Fusion(inf:{getattr(self, 'decision_fusion_inference_enabled', True)}, train:{getattr(self, 'decision_fusion_training_enabled', True)})")
+            else:
+                logger.debug("Orchestrator not available for UI state sync, using defaults")
+        except Exception as e:
+            logger.error(f"Error syncing UI state from orchestrator: {e}")
+    
     def _initialize_streaming(self):
         """Initialize data streaming"""
         try: