diff --git "a/app.py" "b/app.py"
--- "a/app.py"
+++ "b/app.py"
@@ -19,6 +19,7 @@ import streamlit as st
 import streamlit_vertical_slider as svs
 from pydub import AudioSegment
 from scipy.signal import butter, sosfilt
+from gradio_client import Client as GradioClient
 # Removed st.session_state alias - using st.session_state directly
 
 # WordPress API base URL
@@ -84,6 +85,67 @@ except KeyError:
     st.error("BEARER_TOKEN environment variable is not set.")
     st.stop()
 
+# =============================================================================
+# HUGGING FACE SPACE CONFIGURATION for MusicGen
+# =============================================================================
+# Get HF Space token from environment variables or Streamlit secrets
+try:
+    # Try Streamlit secrets first (for Streamlit Cloud deployment)
+    HF_SPACE_TOKEN = st.secrets.get("HF_SPACE_TOKEN", None)
+except:
+    # Fall back to environment variable
+    HF_SPACE_TOKEN = os.environ.get("HF_SPACE_TOKEN", None)
+
+# Your MusicGen Space URL
+MUSICGEN_SPACE = "Healthydater/musicgen"
+
+# MusicGen client will be initialized on-demand (lazy loading)
+# This avoids timeout issues when the Space is sleeping at startup
+musicgen_client = None
+# =============================================================================
+
+def get_musicgen_client_with_retry(max_retries=3, retry_delay=120):
+    """
+    Initialize or get the MusicGen Space client with retry logic.
+    This handles cold starts by retrying with delays.
+
+    Args:
+        max_retries: Number of connection attempts
+        retry_delay: Seconds to wait between retries (default: 120s = 2 minutes)
+
+    Returns:
+        GradioClient instance or None if all retries failed
+    """
+    global musicgen_client
+
+    # If client already initialized, return it
+    if musicgen_client is not None:
+        return musicgen_client
+
+    # Try to initialize with retries
+    for attempt in range(1, max_retries + 1):
+        try:
+            print(f"Connecting to model (attempt {attempt}/{max_retries})...")
+
+            # Gradio Client automatically uses HF_TOKEN environment variable if set
+            client = GradioClient(MUSICGEN_SPACE)
+
+            print(f"✅ Connected to model successfully")
+            musicgen_client = client
+            return client
+
+        except Exception as e:
+            error_msg = str(e)
+            print(f"Connection attempt {attempt} failed: {error_msg}")
+
+            if attempt < max_retries:
+                print(f"Waiting {retry_delay}s before retry...")
+                time.sleep(retry_delay)
+            else:
+                print(f"❌ All connection attempts failed")
+                return None
+
+    return None
 
 page_bg_img = '''
 <style>
@@ -400,15 +462,89 @@ def use_download_credit(jwt_token, user_id, duration_type):
         print(f"Error using download credit: {e}")
         return False
 
+def get_video_credits(jwt_token):
+    """Get video credits from new video monetization system"""
+    if not jwt_token:
+        return None
+
+    try:
+        url = "https://songlabai.com/wp-json/video-api/v1/video-credits"
+        headers = {
+            'Authorization': f'Bearer {jwt_token}',
+            'Content-Type': 'application/json'
+        }
+
+        response = requests.get(url, headers=headers, timeout=10)
+
+        if response.status_code == 200:
+            return response.json()
+        else:
+            print(f"Failed to get video credits: HTTP {response.status_code}")
+            return None
+
+    except Exception as e:
+        print(f"Error getting video credits: {e}")
+        return None
+
+def check_video_eligibility(jwt_token):
+    """Check if user can generate videos"""
+    if not jwt_token:
+        return {'can_generate': False, 'reason': 'not_logged_in'}
+
+    try:
+        url = "https://songlabai.com/wp-json/video-api/v1/check-eligibility"
+        headers = {
+            'Authorization': f'Bearer {jwt_token}',
+            'Content-Type': 'application/json'
+        }
+
+        response = requests.post(url, headers=headers, timeout=10)
+
+        if response.status_code == 200:
+            return response.json()
+        else:
+            return {'can_generate': False, 'reason': 'api_error'}
+
+    except Exception as e:
+        print(f"Error checking video eligibility: {e}")
+        return {'can_generate': False, 'reason': 'exception'}
+
+def use_video_credit(jwt_token, generation_data):
+    """Deduct video credit after successful generation"""
+    if not jwt_token:
+        return False
+
+    try:
+        url = "https://songlabai.com/wp-json/video-api/v1/use-video-credit"
+        headers = {
+            'Authorization': f'Bearer {jwt_token}',
+            'Content-Type': 'application/json'
+        }
+
+        response = requests.post(url, headers=headers, json=generation_data, timeout=10)
+
+        if response.status_code == 200:
+            # Clear video credit cache
+            if "video_credits_cache" in st.session_state:
+                del st.session_state["video_credits_cache"]
+            return True
+        else:
+            print(f"Failed to use video credit: HTTP {response.status_code}")
+            return False
+
+    except Exception as e:
+        print(f"Error using video credit: {e}")
+        return False
+
 def get_current_subscription_status():
     """Get current user's credit-based status using new clean endpoints with caching"""
     # Check if we have cached data that's still fresh (last 30 seconds)
     cache_key = "subscription_status_cache"
     cache_time_key = "subscription_status_cache_time"
     current_time = time.time()
-    
-    if (cache_key in st.session_state and 
-        cache_time_key in st.session_state and 
+
+    if (cache_key in st.session_state and
+        cache_time_key in st.session_state and
         current_time - st.session_state[cache_time_key] < 30):
         print("Using cached subscription status")
         return st.session_state[cache_key]
@@ -649,8 +785,10 @@ def show_sidebar():
                 )
                 user_info = decoded_token.get('data', {}).get('user', {})
                 user_id = user_info.get('id')
-                
-                st.markdown(f"### 👋 Welcome, {user_info.get('display_name', 'User')}!")
+
+                # Get username (user_login) instead of display name
+                username = user_info.get('user_login') or user_info.get('user_nicename') or user_info.get('display_name') or 'User'
+                st.markdown(f"### 👋 Welcome, {username}!")
                 
                 # Get subscription status and usage information
                 subscription_status = get_current_subscription_status()
@@ -682,16 +820,17 @@ def show_sidebar():
                     # Get credit balances from the new system
                     credit_10s = subscription_status.get('tier1_credits', 0)
                     credit_20s = subscription_status.get('tier2_credits', 0)
-                    
-                    # Display generation status (always unlimited now)
-                    st.info("**Generation Status:** Unlimited for all users!")
+
+                    # Display what user can do across all tabs
                     st.markdown("#### 🎵 What You Can Do")
-                    st.markdown("- 🎵 **Generate Tracks:** ∞ (Unlimited)")
-                    st.markdown("- 🎤 **Generate Tracks with Vocals:** ∞ (Unlimited)")
+                    st.markdown("- 🎵 **Audio Tracks:** ∞ (Unlimited)")
+                    st.markdown("- 🎤 **Tracks with Vocals:** ∞ (Unlimited)")
+                    st.markdown("- 🎬 **Videos:** 2 Free Presets")
                     st.markdown("- 🎧 **Listen & Preview:** Always Free")
-                    
-                    # Display credit balances
-                    st.markdown("#### 💰 Download Credits")
+
+                    # Display audio download credit balances
+                    st.markdown("---")
+                    st.markdown("#### 💰 Audio Download Credits")
                     if credit_10s > 0 or credit_20s > 0:
                         st.markdown(f"- 🥉 **10-Second Downloads:** {credit_10s} credits")
                         st.markdown(f"- 🥇 **20-Second Downloads:** {credit_20s} credits")
@@ -699,36 +838,119 @@ def show_sidebar():
                         st.markdown("- 🥉 **10-Second Downloads:** 0 credits")
                         st.markdown("- 🥇 **20-Second Downloads:** 0 credits")
                         st.info("💡 Purchase credits below to download your tracks!")
-                    
-                    # Purchase buttons
-                    st.markdown("### 🛒 Buy Download Credits")
-                    st.markdown("**Download your generated tracks in high quality!**")
-                    
-                    col1, col2 = st.columns(2)
-                    
-                    with col1:
-                        st.markdown("#### 🥉 10-Second Pack")
-                        st.markdown("**$60** for 10-second downloads")
-                        if st.button("Buy 10s Credits", type="secondary", key="buy_10s"):
-                            # Create payment link for 10-second credits
-                            st.markdown("[🛒 Purchase 10-Second Credits](https://songlabai.com/checkout-10s/)")
-                            st.info("💡 You'll be redirected to secure checkout")
-                    
-                    with col2:
-                        st.markdown("#### 🥇 20-Second Pack")
-                        st.markdown("**$90** for 20-second downloads")
-                        if st.button("Buy 20s Credits", type="primary", key="buy_20s"):
-                            # Create payment link for 20-second credits
-                            st.markdown("[🛒 Purchase 20-Second Credits](https://songlabai.com/checkout-20s/)")
-                            st.info("💡 You'll be redirected to secure checkout")
-                    
-                    # Show credit usage info
-                    st.markdown("---")
-                    st.markdown("#### ℹ️ How It Works")
-                    st.markdown("- 🎵 Generate unlimited tracks for free")
-                    st.markdown("- 💰 Purchase credits only when you want to download")
-                    st.markdown("- 📱 Credits never expire")
-                    st.markdown("- 🎧 Preview all tracks before downloading")
+
+                    # Show video credits ONLY when on Commercial Ad tab
+                    if st.session_state.get('current_tab') == 'commercial_ad':
+                        st.markdown("---")
+                        st.markdown("#### 🎬 Video Generation Credits")
+
+                        try:
+                            video_credits = get_video_credits(st.session_state["jwt_token"])
+
+                            if video_credits:
+                                package_tier = video_credits.get('package_tier', 'free')
+                                remaining = int(video_credits.get('remaining_credits', 0))
+                                free_remaining = int(video_credits.get('free_generations_remaining', 0))
+
+                                if package_tier == 'free':
+                                    st.markdown(f"**Package:** Free Tier")
+                                    st.markdown(f"**Free Presets Remaining:** {free_remaining}/2")
+
+                                    # Buy credits button for free tier
+                                    st.link_button(
+                                        "🛒 Buy Video Credits",
+                                        "https://songlabai.com/video-pricing/",
+                                        type="primary",
+                                        use_container_width=True
+                                    )
+
+                                    if free_remaining == 0:
+                                        st.warning("🔒 Buy credits to generate more videos!")
+                                else:
+                                    package_names = {
+                                        'basic': 'Basic (5s)',
+                                        'advanced': 'Advanced (10s)',
+                                        'expert': 'Expert (15s)',
+                                        'custom_4': 'Custom (4 videos)',
+                                        'custom_12': 'Custom (12 videos)',
+                                        'custom_20': 'Custom (20 videos)'
+                                    }
+                                    st.markdown(f"**Package:** {package_names.get(package_tier, package_tier.title())}")
+                                    st.markdown(f"**Total Credits:** {remaining}")
+
+                                    # Show credits breakdown by FPS tier
+                                    available_fps_tiers = video_credits.get('available_fps_tiers', {})
+                                    if available_fps_tiers:
+                                        st.markdown("**Credits by FPS Tier:**")
+                                        for fps_tier_key in sorted(available_fps_tiers.keys(), key=lambda x: int(x)):
+                                            fps_tier = int(fps_tier_key)  # Convert string key to int
+                                            credit_count = available_fps_tiers[fps_tier_key]
+                                            if credit_count > 0:
+                                                if fps_tier == 8:
+                                                    st.markdown(f"  • Basic (8fps): {credit_count}")
+                                                elif fps_tier == 16:
+                                                    st.markdown(f"  • Standard (16fps): {credit_count}")
+                                                elif fps_tier == 24:
+                                                    st.markdown(f"  • HD (24fps): {credit_count}")
+
+                                    if free_remaining > 0:
+                                        st.markdown(f"**Free Presets:** {free_remaining}/2 remaining")
+
+                                    # Buy more credits button for paid tier users
+                                    st.link_button(
+                                        "🛒 Buy More Video Credits",
+                                        "https://songlabai.com/video-pricing/",
+                                        type="secondary",
+                                        use_container_width=True
+                                    )
+
+                                    if remaining == 0 and free_remaining == 0:
+                                        st.warning("🔒 You've used all your credits! Purchase more to continue.")
+
+                                # Video "How It Works" - only on video tab
+                                st.markdown("---")
+                                st.markdown("#### ℹ️ How Video Credits Work")
+                                st.markdown("- 🎬 2 free preset video generations")
+                                st.markdown("- 💳 Buy credits for custom videos & more generations")
+                                st.markdown("- 🎞️ **Each credit is tied to the FPS tier you purchased**")
+                                st.markdown("- 🔒 To use 24fps, buy credits with 24fps addon")
+                                st.markdown("- ⏱️ Choose 5s, 10s, or 15s videos based on package")
+                                st.markdown("- 📱 Credits never expire")
+
+                        except Exception as e:
+                            st.error(f"Error loading video credits: {str(e)}")
+
+                    # Audio track purchase buttons - only show on Track or Track Vocals tabs
+                    if st.session_state.get('current_tab') in ['track', 'track_vocals']:
+                        st.markdown("---")
+                        st.markdown("### 🛒 Buy Audio Download Credits")
+                        st.markdown("**Download your generated audio tracks in high quality!**")
+
+                        col1, col2 = st.columns(2)
+
+                        with col1:
+                            st.markdown("#### 🥉 10-Second Pack")
+                            st.markdown("**$60** for 10-second downloads")
+                            if st.button("Buy 10s Credits", type="secondary", key="buy_10s"):
+                                # Create payment link for 10-second credits
+                                st.markdown("[🛒 Purchase 10-Second Credits](https://songlabai.com/checkout-10s/)")
+                                st.info("💡 You'll be redirected to secure checkout")
+
+                        with col2:
+                            st.markdown("#### 🥇 20-Second Pack")
+                            st.markdown("**$90** for 20-second downloads")
+                            if st.button("Buy 20s Credits", type="primary", key="buy_20s"):
+                                # Create payment link for 20-second credits
+                                st.markdown("[🛒 Purchase 20-Second Credits](https://songlabai.com/checkout-20s/)")
+                                st.info("💡 You'll be redirected to secure checkout")
+
+                        # Audio "How It Works" - only on audio tabs
+                        st.markdown("---")
+                        st.markdown("#### ℹ️ How Audio Credits Work")
+                        st.markdown("- 🎵 Generate unlimited tracks for free")
+                        st.markdown("- 💰 Purchase credits only when you want to download")
+                        st.markdown("- 📱 Credits never expire")
+                        st.markdown("- 🎧 Preview all tracks before downloading")
                 
                 # Logout button
                 if st.button("Log Out", key="sidebar_logout"):
@@ -1367,32 +1589,40 @@ def save_track_with_robust_flag_setting(audio_data, sample_rate, metadata=None):
 # Function for admin-only notification
 def save_on_generation(audio_array, sample_rate, metadata=None):
     """
-    Save a track to the admin dashboard immediately after generation
-    
+    Save a track to the admin dashboard immediately after generation with error handling
+
     Parameters:
     audio_array: Audio data as numpy array
     sample_rate: Sample rate of the audio
     metadata: Optional track metadata dictionary
-    
+
     Returns:
     tuple: (file_url, file_id)
     """
     print("Automatically saving generated track for admin review")
-    
-    # Use the unified upload function with saved_by_user=False
-    success, file_url, file_id, message = unified_track_upload(
-        audio_data=audio_array,
-        sample_rate=sample_rate,
-        metadata=metadata,
-        saved_by_user=False  # Not saved by user, just for admin tracking
-    )
-    
-    if success:
-        print(f"Successfully saved track for admin: {file_url}, {file_id}")
-    else:
-        print(f"Failed to save track for admin: {message}")
-    
-    return file_url, file_id
+
+    try:
+        # Use the unified upload function with saved_by_user=False
+        success, file_url, file_id, message = unified_track_upload(
+            audio_data=audio_array,
+            sample_rate=sample_rate,
+            metadata=metadata,
+            saved_by_user=False  # Not saved by user, just for admin tracking
+        )
+
+        if success and file_id and file_id != "N/A":
+            print(f"Successfully saved track for admin: {file_url}, {file_id}")
+            return file_url, file_id
+        else:
+            print(f"Failed to save track for admin: {message}")
+            return "#", "N/A"
+
+    except Exception as e:
+        print(f"Exception during save_on_generation: {str(e)}")
+        # Check if it's a database connection error
+        if "database connection" in str(e).lower() or "Error establishing" in str(e):
+            print("Database connection error detected - track will still be playable")
+        return "#", "N/A"
 
 
 def display_download_button(audio_bytes, is_premium_user=False, has_exceeded_limit=False, location="main"):
@@ -1430,10 +1660,9 @@ def display_download_button(audio_bytes, is_premium_user=False, has_exceeded_lim
                    "[Buy Now](https://songlabai.com/orders/)", icon="ℹ️")
         
 
-@st.fragment
 def save_track_fragment(audio_bytes, metadata, location="generated"):
     """
-    Fragment for saving track to dashboard without causing full app rerun
+    Save track to dashboard - removed fragment to prevent conflicts
     """
     # Create a placeholder for status messages
     status_placeholder = st.empty()
@@ -1488,18 +1717,16 @@ def save_track_fragment(audio_bytes, metadata, location="generated"):
                     status_placeholder.error(f"❌ Failed to save track: {message}")
 
 
-@st.fragment
 def generate_button_fragment(button_text, key, generate_func, *args):
     """
-    Fragment for generate button to prevent full app reruns
+    Generate button - removed fragment to prevent conflicts
     """
     if st.button(button_text, key=key, type="primary"):
         generate_func(*args)
 
-@st.fragment
 def promo_code_fragment(promo_code, location="main"):
     """
-    Fragment for promo code handling to prevent full app rerun
+    Promo code handling - removed fragment to prevent conflicts
     """
     # Check for valid promo code
     if promo_code == "promosongtester" and not st.session_state.get('promo_code_applied', False):
@@ -1517,10 +1744,9 @@ def promo_code_fragment(promo_code, location="main"):
             st.session_state['promo_code_applied'] = False
             # Don't call smart_rerun here to avoid losing audio
 
-@st.fragment
 def display_audio_with_controls(audio_bytes, subscription_status, location="main"):
     """
-    Fragment to display audio player with download and save controls without causing full app reruns
+    Display audio player with download and save controls - removed fragment to prevent conflicts
     """
     if audio_bytes is None:
         return
@@ -1624,35 +1850,12 @@ def display_audio_with_controls(audio_bytes, subscription_status, location="main
                     st.markdown("[Buy Credits](https://songlabai.com/checkout-10s/)", unsafe_allow_html=True)
     
     with col2:
-        # Add Save to Dashboard button inline
-        if st.session_state.get("jwt_token"):
-            metadata = st.session_state.get('audio_metadata', {})
-            if st.button("💾 Save to Dashboard", key=f"save_{location}_btn"):
-                # Check if we have a track ID from generation
-                if 'current_track_id' in st.session_state and st.session_state['current_track_id']:
-                    track_id = st.session_state['current_track_id']
-                    
-                    # Simply update the saved_by_user flag for the existing track
-                    with st.spinner("💾 Saving track to your dashboard..."):
-                        print(f"Updating saved_by_user flag for existing track {track_id}")
-                        
-                        # Call the fix_saved_by_user_flag function to set the flag to 1
-                        success = fix_saved_by_user_flag(track_id)
-                        
-                        if success:
-                            st.success("✅ Track saved to your dashboard successfully!")
-                            st.info("Your track will be reviewed by our team. If approved, it will be published and you'll earn 70% of all sales revenue.")
-                        else:
-                            st.warning("⚠️ Failed to save track to dashboard. Please try again.")
-                else:
-                    st.info("⚠️ No track available to save")
-        else:
-            st.info("👤 **Log in** using the sidebar to save tracks to your dashboard")
+        # User dashboard saving removed - only admin auto-save is active
+        st.info("🎵 **Track automatically saved to admin dashboard for review**")
 
-@st.fragment
 def download_button_no_rerun(audio_bytes, subscription_status, location="main"):
     """
-    Download button without causing reruns - Updated for credit system
+    Download button without causing reruns - removed fragment to prevent conflicts
     """
     if audio_bytes is None:
         return
@@ -1807,31 +2010,6 @@ def display_audio_player(is_final=False):
                 else:
                     st.error("❌ Failed to restore audio")
                         
-def display_discount_timer():
-    """
-    Display a simplified discount message for iframe, main timer is on landing page
-    """
-    if 'discount_timer_start' not in st.session_state:
-        return
-    
-    # Calculate elapsed time
-    elapsed_time = time.time() - st.session_state.discount_timer_start
-    remaining_time = 300 - elapsed_time  # 300 seconds = 5 minutes
-    
-    # Only show message if there's time remaining
-    if remaining_time > 0:
-        # Show a simple message directing users to the banner
-        st.info("🔥 **FLASH SALE ACTIVE!** Check the banner at the top of the page for your 50% discount code!")
-        
-        # Clean minimal refresh to keep timer active (no rerun to avoid disrupting UX)
-        time.sleep(0.1)
-    
-    elif 'discount_timer_start' in st.session_state:
-        # Timer expired, clean up session state
-        if 'discount_code_revealed' in st.session_state:
-            del st.session_state.discount_code_revealed
-        del st.session_state.discount_timer_start
-
 def convert_audio_segment_to_float_array(audio_pydub):
     """
     Convert a pydub AudioSegment to a NumPy array of type float32.
@@ -2164,81 +2342,34 @@ def load_and_play_generated_audio(response, genre=None, energy_level=None, tempo
             'sample_rate': sample_rate
         }
         
+        # Auto-save to admin dashboard and get real track ID
+        print("Auto-saving track to admin dashboard...")
+        try:
+            file_url, file_id = save_on_generation(audio_array, sample_rate, st.session_state.audio_metadata)
+
+            if file_id and file_id != "N/A":
+                st.session_state['current_track_id'] = file_id
+                print(f"Successfully saved to admin dashboard with track ID: {file_id}")
+            else:
+                # Fallback to UUID if save fails
+                import uuid
+                temp_track_id = str(uuid.uuid4())
+                st.session_state['current_track_id'] = temp_track_id
+                print(f"Failed to save to admin dashboard, using temporary ID: {temp_track_id}")
+        except Exception as e:
+            print(f"Error saving to admin dashboard: {str(e)}")
+            # Fallback to UUID if save fails
+            import uuid
+            temp_track_id = str(uuid.uuid4())
+            st.session_state['current_track_id'] = temp_track_id
+            print(f"Exception occurred, using temporary ID: {temp_track_id}")
+
         # Schedule auto-save for background (prevents rerun)
         st.session_state['auto_save_audio_data'] = audio_array
         st.session_state['auto_save_sample_rate'] = sample_rate
         st.session_state['auto_save_metadata'] = st.session_state.audio_metadata.copy()
         
-        # Generate a temporary track ID for saving functionality
-        import uuid
-        temp_track_id = str(uuid.uuid4())
-        st.session_state['current_track_id'] = temp_track_id
-        print(f"Generated temporary track ID {temp_track_id} for dashboard saving")
-        
-        # Display the audio using a fragment to prevent full app reruns
-        display_audio_with_controls(st.session_state.audio_bytes, subscription_status, "generated")
-        
-        # Start discount timer after successful audio generation
-        if 'discount_timer_start' not in st.session_state:
-            st.session_state.discount_timer_start = time.time()
-            # Send message to parent window (landing page) to start timer - Multiple methods
-            st.components.v1.html("""
-            <script>
-            console.log('SongLabAI: Attempting to send audio_generated message to parent');
-            
-            function sendMessageToParent() {
-                const message = {
-                    type: 'audio_generated', 
-                    timestamp: Date.now(),
-                    source: 'streamlit_app',
-                    method: 'postMessage'
-                };
-                
-                try {
-                    // Method 1: Direct parent postMessage
-                    if (window.parent && window.parent !== window) {
-                        window.parent.postMessage(message, '*');
-                        console.log('SongLabAI: Message sent to parent via postMessage');
-                    }
-                    
-                    // Method 2: Top window postMessage
-                    if (window.top && window.top !== window) {
-                        window.top.postMessage(message, '*');
-                        console.log('SongLabAI: Message sent to top window via postMessage');
-                    }
-                    
-                    // Method 3: Try all parent frames
-                    let current = window;
-                    let level = 0;
-                    while (current.parent && current.parent !== current && level < 5) {
-                        current = current.parent;
-                        current.postMessage(message, '*');
-                        level++;
-                        console.log('SongLabAI: Message sent to parent level', level);
-                    }
-                    
-                    // Method 4: Set global flag that parent can check
-                    if (window.top) {
-                        window.top.songlab_audio_generated = Date.now();
-                        console.log('SongLabAI: Set global flag for parent to check');
-                    }
-                    
-                } catch (e) {
-                    console.error('SongLabAI: Error sending message:', e);
-                }
-            }
-            
-            // Send immediately
-            sendMessageToParent();
-            
-            // Also send after a delay in case iframe is still loading
-            setTimeout(sendMessageToParent, 1000);
-            setTimeout(sendMessageToParent, 3000);
-            </script>
-            """, height=0)
-        
-        # Display discount timer and offer
-        display_discount_timer()
+        # Audio display now handled by fragment - removed to prevent duplicate display
         
         print("Successfully displayed audio player without rerun-causing HTTP calls")
         
@@ -2360,47 +2491,17 @@ def generate_audio(genre, energy_level, tempo, description, duration):
                 st.warning("⚠️ Your subscription plan includes 30-second generation limit.")
                 st.info("💡 Upgrade to a commercial plan for extended duration tracks!")
                 duration = 30  # Force duration to 30 seconds for personal tiers
-                
-        # Check if server is ready with improved error handling
-        is_ready, status_code, error_msg = check_server_status()
-            
-        # If server is not ready, enter the waiting loop
-        if not is_ready:
-            if status_code == 503:
-                status_placeholder.warning(
-                    "🔄 **Server is starting up**\n\n"
-                    "The AI model is loading. This may take 1-2 minutes...\n"
-                    "Please wait while we prepare the audio generation service."
-                )
-            else:
-                status_placeholder.warning(
-                    "🔄 **Server status check**\n\n"
-                    f"Status: {error_msg}\n"
-                    "Attempting to initialize the server..."
-                )
-                
-            # Wait for server to warm up with progress display
-            server_ready = wait_for_server_warmup(
-                status_placeholder,
-                progress_placeholder,
-                subscription_info_placeholder,
-                stage_placeholder
-            )
-                
-            if not server_ready:
-                st.error(
-                    "❌ Server initialization timed out.\n\n"
-                    "Please try again later or consider upgrading to premium for more reliable access."
-                )
-                return None
-                    
-        # Clear warmup messages since the server is ready
+
+        # NOTE: Warmup check removed - Gradio Space client handles cold start automatically
+        # The first request to a sleeping Space will take longer (1-2 minutes) but will wake it up
+
+        # Clear any warmup UI placeholders
         for placeholder in [status_placeholder, progress_placeholder, subscription_info_placeholder, stage_placeholder]:
             placeholder.empty()
-                
+
         # Prepare generation request
         formatted_prompt = f"Genre: {genre}, Energy Level: {energy_level}, Tempo: {tempo}, Description: {description}"
-        
+
         payload = {
             "inputs": {
                 "prompt": formatted_prompt,
@@ -2412,84 +2513,122 @@ def generate_audio(genre, energy_level, tempo, description, duration):
                 "guidance_scale": 3.0
             }
         }
-        
+
         # Log what's being sent
         print(f"Sending generation request to: {API_URL}")
         print(f"Request payload: {json.dumps(payload)}")
-        
+
         # Make the generation request
-        with st.spinner("🎵 Generating your music... This may take a few moments."):
+        # Note: First request after model sleeps may take several minutes to wake up and load
+        with st.spinner("🎵 Generating your music... This may take a few moments (first request may take several minutes to load the model)."):
             try:
                 # Use appropriate timeout based on duration
                 timeout = max(120, duration * 4)  # Longer timeout for longer generations
                 print(f"Using timeout: {timeout}s")
-                
-                response = requests.post(
-                    API_URL, 
-                    headers=get_api_headers(), 
-                    json=payload, 
-                    timeout=timeout
+
+                # Get or initialize client with retry logic
+                # This handles cold starts gracefully
+                client = get_musicgen_client_with_retry(max_retries=3)
+
+                if client is None:
+                    st.error("❌ Service unavailable. Please try again later.")
+                    return None
+
+                result = client.predict(
+                    formatted_prompt,
+                    float(duration),
+                    1.0,  # temperature
+                    250,  # top_k
+                    0.0,  # top_p
+                    3.0,  # cfg_coef
+                    True,  # use_sampling
+                    18.0  # extend_stride
                 )
-                
-                print(f"Got response with status code: {response.status_code}")
-                
-                if response.status_code == 200:
-                    # Success! Show success message
-                    st.success("✨ Music generated successfully!")
-                    
-                    # Process and play the audio
-                    result = load_and_play_generated_audio(
-                        response=response,
-                        genre=genre,
-                        energy_level=energy_level,
-                        tempo=tempo,
-                        description=description,
-                        duration=duration,
-                        subscription_status=subscription_status
-                    )
-                    
-                    # Only update count if audio was successfully generated
-                    if result[0] is not None:
-                        # Update generation count on WordPress
-                        auth_headers = get_auth_headers()
-                        update_generation_url = "https://songlabai.com/wp-json/custom-api/v1/update-generation-count"
-                        requests.post(update_generation_url, headers=auth_headers)
-                    
-                    return response
-                else:
-                    # Handle error with detailed information
-                    try:
-                        error_data = response.json()
-                        if isinstance(error_data, dict) and "error" in error_data:
-                            error_message = error_data["error"]
-                        else:
-                            error_message = f"{response.status_code} {response.reason}"
-                    except:
-                        error_message = f"{response.status_code} {response.reason}"
-                        
-                    # Check if it's a server warmup issue that was missed
-                    if response.status_code == 503:
-                        st.error(
-                            f"❌ Server is still starting up. Please wait a few minutes and try again.\n\n"
-                            f"Error: {error_message}"
+
+                print(f"Got response from model")
+                print(f"DEBUG - Response type: {type(result)}")
+                print(f"DEBUG - Response value: {result if not isinstance(result, tuple) else f'tuple with {len(result)} elements'}")
+                if isinstance(result, tuple) and len(result) > 0:
+                    print(f"DEBUG - First element type: {type(result[0])}")
+                    print(f"DEBUG - First element value: {result[0] if not isinstance(result[0], (list, tuple, np.ndarray)) else f'{type(result[0]).__name__} of length {len(result[0])}'}")
+                if isinstance(result, tuple) and len(result) > 1:
+                    print(f"DEBUG - Second element type: {type(result[1])}")
+                    print(f"DEBUG - Second element value (first 200 chars): {str(result[1])[:200]}")
+
+                # Result is (audio_file_path, metadata_dict)
+                if isinstance(result, tuple) and len(result) == 2:
+                    audio_file_path, metadata = result
+
+                    # Check for error response
+                    if audio_file_path is None or (isinstance(metadata, dict) and "error" in metadata):
+                        error_msg = metadata.get("error", "Unknown error") if isinstance(metadata, dict) else "Generation failed"
+                        st.error(f"❌ {error_msg}")
+                        return None
+
+                    # audio_file_path is a string path to the audio file
+                    if isinstance(audio_file_path, str):
+                        # Load the audio file
+                        print(f"Loading audio from: {audio_file_path}")
+                        audio_array, sample_rate = sf.read(audio_file_path)
+                        print(f"Loaded audio: {len(audio_array)} samples at {sample_rate}Hz")
+
+                        # Convert Space response to match old endpoint format
+                        class MockResponse:
+                            def __init__(self, audio_data, sample_rate):
+                                self.status_code = 200
+                                # Convert to list if it's a numpy array
+                                if isinstance(audio_data, np.ndarray):
+                                    audio_list = audio_data.tolist()
+                                else:
+                                    audio_list = audio_data
+
+                                self._json_data = {
+                                    "generated_audio": audio_list,
+                                    "sample_rate": sample_rate
+                                }
+
+                            def json(self):
+                                return self._json_data
+
+                        response = MockResponse(audio_array, sample_rate)
+
+                        # Success! Show success message
+                        st.success("✨ Music generated successfully!")
+
+                        # Process and play the audio
+                        result = load_and_play_generated_audio(
+                            response=response,
+                            genre=genre,
+                            energy_level=energy_level,
+                            tempo=tempo,
+                            description=description,
+                            duration=duration,
+                            subscription_status=subscription_status
                         )
-                    else:
-                        st.error(f"❌ Failed to generate audio: {error_message}")
                     
-                    # Print detailed response for debugging
-                    print(f"Error response ({response.status_code}): {response.text[:500]}...")
+                        # Only update count if audio was successfully generated
+                        if result[0] is not None:
+                            # Update generation count on WordPress - with better error handling
+                            try:
+                                auth_headers = get_auth_headers()
+                                update_generation_url = "https://songlabai.com/wp-json/custom-api/v1/update-generation-count"
+                                response_update = requests.post(update_generation_url, headers=auth_headers, timeout=5)
+                                print(f"Generation count update response: {response_update.status_code}")
+                            except Exception as e:
+                                print(f"Failed to update generation count: {str(e)} - continuing anyway")
+
+                        return response
+                    else:
+                        st.error(f"❌ Unexpected response format from service")
+                        return None
+                else:
+                    st.error(f"❌ Unexpected response format from service")
                     return None
-                    
-            except requests.exceptions.Timeout:
-                print("Request timed out")
-                st.error(
-                    "❌ Request timed out.\n\n"
-                    "The server may be busy processing your request or other requests.\n"
-                    "Please try again with a shorter duration or try later."
-                )
-                return None
-            except requests.exceptions.RequestException as e:
+
+            except Exception as e:
+                import traceback
                 print(f"Request exception: {e}")
+                print(traceback.format_exc())
                 st.error(f"❌ Error connecting to the generation service: {str(e)}")
                 return None
                 
@@ -2731,74 +2870,39 @@ def load_and_play_generated_audio_lyrics(response, genre=None, energy_level=None
         # Display success message
         st.success("🎉 Track with vocals generated successfully!")
         
-        # Display the audio using a fragment to prevent full app reruns
-        display_audio_with_controls(audio_bytes, subscription_status, "vocals")
-        
-        # Start discount timer after successful audio generation
-        if 'discount_timer_start' not in st.session_state:
-            st.session_state.discount_timer_start = time.time()
-            # Send message to parent window (landing page) to start timer - Multiple methods
-            st.components.v1.html("""
-            <script>
-            console.log('SongLabAI: Attempting to send audio_generated message to parent');
-            
-            function sendMessageToParent() {
-                const message = {
-                    type: 'audio_generated', 
-                    timestamp: Date.now(),
-                    source: 'streamlit_app',
-                    method: 'postMessage'
-                };
-                
-                try {
-                    // Method 1: Direct parent postMessage
-                    if (window.parent && window.parent !== window) {
-                        window.parent.postMessage(message, '*');
-                        console.log('SongLabAI: Message sent to parent via postMessage');
-                    }
-                    
-                    // Method 2: Top window postMessage
-                    if (window.top && window.top !== window) {
-                        window.top.postMessage(message, '*');
-                        console.log('SongLabAI: Message sent to top window via postMessage');
-                    }
-                    
-                    // Method 3: Try all parent frames
-                    let current = window;
-                    let level = 0;
-                    while (current.parent && current.parent !== current && level < 5) {
-                        current = current.parent;
-                        current.postMessage(message, '*');
-                        level++;
-                        console.log('SongLabAI: Message sent to parent level', level);
-                    }
-                    
-                    // Method 4: Set global flag that parent can check
-                    if (window.top) {
-                        window.top.songlab_audio_generated = Date.now();
-                        console.log('SongLabAI: Set global flag for parent to check');
-                    }
-                    
-                } catch (e) {
-                    console.error('SongLabAI: Error sending message:', e);
-                }
-            }
-            
-            // Send immediately
-            sendMessageToParent();
-            
-            // Also send after a delay in case iframe is still loading
-            setTimeout(sendMessageToParent, 1000);
-            setTimeout(sendMessageToParent, 3000);
-            </script>
-            """, height=0)
-        
-        # Display discount timer and offer
-        display_discount_timer()
-        
+        # Auto-save lyrics track to admin dashboard and get real track ID
+        print("Auto-saving lyrics track to admin dashboard...")
+        try:
+            # Convert audio bytes to numpy array for save_on_generation
+            audio_buffer = io.BytesIO(audio_bytes)
+            with sf.SoundFile(audio_buffer) as f:
+                audio_array = f.read()
+                sample_rate = f.samplerate
+
+            file_url, file_id = save_on_generation(audio_array, sample_rate, st.session_state.audio_metadata)
+
+            if file_id and file_id != "N/A":
+                st.session_state['current_track_id'] = file_id
+                print(f"Successfully saved lyrics track to admin dashboard with ID: {file_id}")
+            else:
+                # Fallback to UUID if save fails
+                import uuid
+                temp_track_id = str(uuid.uuid4())
+                st.session_state['current_track_id'] = temp_track_id
+                print(f"Failed to save lyrics track to admin dashboard, using temporary ID: {temp_track_id}")
+        except Exception as e:
+            print(f"Error saving lyrics track to admin dashboard: {str(e)}")
+            # Fallback to UUID if save fails
+            import uuid
+            temp_track_id = str(uuid.uuid4())
+            st.session_state['current_track_id'] = temp_track_id
+            print(f"Exception occurred with lyrics track, using temporary ID: {temp_track_id}")
+
+        # Audio display now handled by fragment - removed to prevent duplicate display
+
         # Backup audio data (no HTTP requests, safe)
         backup_audio_data()
-        
+
         # Schedule auto-save for background execution (prevents rerun)
         if 'auto_save_pending' not in st.session_state:
             st.session_state['auto_save_pending'] = True
@@ -2864,7 +2968,11 @@ def update_generate_button_lyrics(genre, energy_level, tempo, description, durat
             st.info("👈 Please log in using the sidebar to generate tracks with vocals")
 
 
-# Call the sidebar function at the beginning of the app
+# Initialize current_tab if not set (defaults to track)
+if 'current_tab' not in st.session_state:
+    st.session_state['current_tab'] = 'track'
+
+# Call the sidebar function once at the beginning
 show_sidebar()
 
 # Restore audio data if it was lost during a rerun
@@ -2877,11 +2985,11 @@ show_audio_recovery_notification()
 st.title("Songlab AI")
 
 # Add tabs for different generation modes
-generation_tab1, generation_tab2 = st.tabs(["🎵 Track", "🎤 Track with Vocals"])
+generation_tab1, generation_tab2, generation_tab3 = st.tabs(["🎵 Track", "🎤 Track with Vocals", "🎬 Commercial Ad"])
 
 with generation_tab1:
     st.markdown("### Generate Track")
-    
+
     # Main UI components for normal music generation
     genres = [
         "Pop",
@@ -2910,9 +3018,14 @@ with generation_tab1:
         "Trance",
         "Dubstep",
     ]
-    genre = st.selectbox("Select Genre:", genres, key="normal_genre")
+
+    # Update current_tab when this widget is interacted with
+    def set_track_tab():
+        st.session_state['current_tab'] = 'track'
+
+    genre = st.selectbox("Select Genre:", genres, key="normal_genre", on_change=set_track_tab)
     energy_levels = ["Low", "Medium", "High"]
-    energy_level = st.radio("Energy Level:", energy_levels, horizontal=True, key="normal_energy")
+    energy_level = st.radio("Energy Level:", energy_levels, horizontal=True, key="normal_energy", on_change=set_track_tab)
     desc_col, button_col = st.columns([4, 1])
 
     with desc_col:
@@ -3003,16 +3116,26 @@ with generation_tab1:
         except Exception as e:
             print(f"Error checking for special admin in duration slider: {str(e)}")
         
-        # All users are limited to 30 seconds maximum
-        duration = st.slider(
-            "Duration (in seconds):",
-            min_value=15,
-            max_value=30,  # 30-second limit for all users
-            value=30,
-            step=1,
-            help="All music generation is limited to 30 seconds maximum.",
-            key="normal_duration"
-        )
+        # Apply the appropriate slider based on user type
+        if is_special_admin or (is_free_tier and not st.session_state.get('promo_code_applied', False)):
+            duration = st.slider(
+                "Duration (in seconds):",
+                min_value=15,
+                max_value=30,  # Restricted to 30 seconds for free tier and special admin
+                value=30,
+                step=1,
+                help="Free tier users are limited to 30-second generations. Upgrade to create longer tracks or use a promo code!",
+                key="normal_duration"
+            )
+        else:
+            duration = st.slider(
+                "Duration (in seconds):",
+                min_value=15,
+                max_value=140,
+                value=30,
+                step=1,
+                key="normal_duration"
+            )
 
     with promo_col:
         # Add the promo code text input
@@ -3023,12 +3146,23 @@ with generation_tab1:
         # Check for valid promo code - use fragment to avoid reruns
         promo_code_fragment(promo_code, "normal")
 
-    # Generate button for normal music
-    update_generate_button(genre, energy_level, tempo, confirmed_description, duration)
+    # Fragment for normal music generation to prevent full page reruns
+    @st.fragment
+    def normal_music_generation_fragment():
+        # Generate button for normal music
+        update_generate_button(genre, energy_level, tempo, confirmed_description, duration)
+
+        # Display audio player if audio exists (smooth appearance without full page reload)
+        if st.session_state.get('audio_bytes') and st.session_state.get('playing_state') == 'generated':
+            subscription_status = get_current_subscription_status()
+            display_audio_with_controls(st.session_state.audio_bytes, subscription_status, "generated")
+
+    # Run the fragment
+    normal_music_generation_fragment()
 
 with generation_tab2:
     st.markdown("### Generate Track with Vocals")
-    
+
     # Ensure session state is initialized for vocals
     initialize_audio_session_state()
     
@@ -3068,9 +3202,14 @@ with generation_tab2:
         "Trance",
         "Dubstep",
     ]
-    genre_lyrics = st.selectbox("Select Genre:", genres_lyrics, key="lyrics_genre")
+
+    # Update current_tab when this widget is interacted with
+    def set_track_vocals_tab():
+        st.session_state['current_tab'] = 'track_vocals'
+
+    genre_lyrics = st.selectbox("Select Genre:", genres_lyrics, key="lyrics_genre", on_change=set_track_vocals_tab)
     energy_levels_lyrics = ["Low", "Medium", "High"]
-    energy_level_lyrics = st.radio("Energy Level:", energy_levels_lyrics, horizontal=True, key="lyrics_energy")
+    energy_level_lyrics = st.radio("Energy Level:", energy_levels_lyrics, horizontal=True, key="lyrics_energy", on_change=set_track_vocals_tab)
     
     # Description and lyrics input
     desc_col_lyrics, button_col_lyrics = st.columns([4, 1])
@@ -3229,16 +3368,26 @@ with generation_tab2:
         except Exception as e:
             print(f"Error checking for special admin in duration slider: {str(e)}")
         
-        # All users are limited to 30 seconds maximum
-        duration_lyrics = st.slider(
-            "Duration (in seconds):",
-            min_value=15,
-            max_value=30,  # 30-second limit for all users
-            value=30,
-            step=1,
-            help="All music generation is limited to 30 seconds maximum.",
-            key="lyrics_duration"
-        )
+        # Apply the appropriate slider based on user type
+        if is_special_admin or (is_free_tier and not st.session_state.get('promo_code_applied', False)):
+            duration_lyrics = st.slider(
+                "Duration (in seconds):",
+                min_value=15,
+                max_value=30,  # Restricted to 30 seconds for free tier and special admin
+                value=30,
+                step=1,
+                help="Free tier users are limited to 30-second generations. Upgrade to create longer tracks or use a promo code!",
+                key="lyrics_duration"
+            )
+        else:
+            duration_lyrics = st.slider(
+                "Duration (in seconds):",
+                min_value=15,
+                max_value=140,
+                value=30,
+                step=1,
+                key="lyrics_duration"
+            )
 
     with promo_col_lyrics:
         # Add the promo code text input
@@ -3249,8 +3398,22 @@ with generation_tab2:
         # Check for valid promo code - use fragment to avoid reruns
         promo_code_fragment(promo_code_lyrics, "lyrics")
 
-    # Generate button for lyrics music
-    update_generate_button_lyrics(genre_lyrics, energy_level_lyrics, tempo_lyrics, confirmed_description_lyrics, duration_lyrics, confirmed_lyrics)
+    # Fragment for vocals generation to prevent full page reruns
+    @st.fragment
+    def vocals_generation_fragment():
+        # Generate button for lyrics music
+        update_generate_button_lyrics(genre_lyrics, energy_level_lyrics, tempo_lyrics, confirmed_description_lyrics, duration_lyrics, confirmed_lyrics)
+
+        # Display audio player if vocals audio exists (smooth appearance without full page reload)
+        if st.session_state.get('audio_bytes') and st.session_state.get('playing_state') == 'generated':
+            # Check if this is vocals audio by looking for lyrics in metadata
+            metadata = st.session_state.get('audio_metadata', {})
+            if metadata.get('generation_type') == 'lyrics':
+                subscription_status = get_current_subscription_status()
+                display_audio_with_controls(st.session_state.audio_bytes, subscription_status, "vocals")
+
+    # Run the fragment
+    vocals_generation_fragment()
 
 def get_wordpress_beats(jwt_token=None):
     """
@@ -3413,7 +3576,1388 @@ def load_wordpress_beat_for_processing(beat_url, beat_name):
         print(traceback.format_exc())
         return False, f"Error loading beat: {str(e)}"
 
-        
+
+# ============================================================================
+# GENERATION TAB 3: COMMERCIAL AD GENERATION
+# ============================================================================
+with generation_tab3:
+    st.markdown("### 🎬 Generate Commercial Ad / Video")
+    st.markdown("Create professional 10-second videos with optional jingles")
+
+    # Initialize session state for ad generation
+    if 'ad_jingle_bytes' not in st.session_state:
+        st.session_state.ad_jingle_bytes = None
+    if 'ad_video_path' not in st.session_state:
+        st.session_state.ad_video_path = None
+    if 'ad_final_video' not in st.session_state:
+        st.session_state.ad_final_video = None
+    if 'ad_uploaded_image' not in st.session_state:
+        st.session_state.ad_uploaded_image = None
+
+    # Generation Mode Selector
+    st.markdown("### 🎯 Select Generation Mode")
+
+    # Update current_tab when this widget is interacted with
+    def set_commercial_ad_tab():
+        st.session_state['current_tab'] = 'commercial_ad'
+
+    generation_mode = st.radio(
+        "Choose what you want to generate:",
+        ["🎬 Video Only (Text-to-Video)", "🖼️ Video Only (Image-to-Video)", "🎵 Jingle + Video"],
+        key="ad_generation_mode",
+        horizontal=False,
+        on_change=set_commercial_ad_tab
+    )
+
+    # Instructions based on mode
+    with st.expander("ℹ️ How It Works"):
+        if generation_mode == "🎬 Video Only (Text-to-Video)":
+            st.markdown("""
+            **Generate a 10-second video from text description:**
+
+            1. **📝 Describe your video** - Provide detailed prompt
+            2. **🎬 AI generates video** - Takes ~15 minutes
+            3. **⬇️ Download result** - Get your video file
+
+            **Tips:**
+            - Be specific about visuals, camera angles, and style
+            - Describe lighting, colors, and mood
+            - Generation takes ~15 minutes
+            """)
+        elif generation_mode == "🖼️ Video Only (Image-to-Video)":
+            st.markdown("""
+            **Animate a 10-second video from an image:**
+
+            1. **🖼️ Upload an image** - Your starting frame
+            2. **📝 Describe motion** - How should it animate
+            3. **🎬 AI generates video** - Takes ~15 minutes
+            4. **⬇️ Download result** - Get your video file
+
+            **Tips:**
+            - Use high-quality images (PNG, JPG)
+            - Describe camera movements and transitions
+            - Generation takes ~15 minutes
+            """)
+        else:  # Jingle + Video
+            st.markdown("""
+            **Create a complete 10-second ad with jingle and video:**
+
+            1. **🎵 Jingle Generation** - AI generates custom audio (10s)
+            2. **🎬 Video Generation** - Text-to-video OR image-to-video (10s)
+            3. **🎥 Combination** - Synchronized into final ad
+
+            **Tips:**
+            - Keep jingle and video themes aligned
+            - Total generation time: ~15-20 minutes
+            - Both jingle and video will be exactly 10 seconds
+            """)
+
+    st.markdown("---")
+
+    # Input Section - Changes based on mode
+    if generation_mode == "🎬 Video Only (Text-to-Video)":
+        st.markdown("### 📝 Video Settings")
+        ad_video_prompt = st.text_area(
+            "Video Description",
+            value=st.session_state.get('ad_video_prompt', ''),
+            placeholder="Sleek modern smartphone rotating on reflective black surface, studio lighting with blue gradient background, premium product photography, cinematic 4k",
+            height=150,
+            help="Describe the visual content, camera angles, lighting, and style",
+            key="ad_video_description"
+        )
+        ad_video_mode = "text_to_video"
+        ad_jingle_prompt = None
+        ad_jingle_lyrics = ""
+
+    elif generation_mode == "🖼️ Video Only (Image-to-Video)":
+        st.markdown("### 🖼️ Upload Starting Image")
+        uploaded_image = st.file_uploader(
+            "Choose an image file (PNG, JPG, JPEG)",
+            type=["png", "jpg", "jpeg"],
+            key="ad_image_uploader",
+            help="This image will be the first frame of your video"
+        )
+
+        if uploaded_image:
+            st.image(uploaded_image, caption="Uploaded Image", use_column_width=True)
+            # Save to session state as base64
+            image_bytes = uploaded_image.read()
+            st.session_state.ad_uploaded_image = base64.b64encode(image_bytes).decode('utf-8')
+
+        st.markdown("### 📝 Animation Prompt")
+        ad_video_prompt = st.text_area(
+            "Describe the motion/animation",
+            value=st.session_state.get('ad_video_prompt', ''),
+            placeholder="Camera slowly zooms in while the product gently rotates, dramatic lighting shift from left to right",
+            height=120,
+            help="Describe camera movements, object motion, and transitions",
+            key="ad_video_description"
+        )
+        ad_video_mode = "image_to_video"
+        ad_jingle_prompt = None
+        ad_jingle_lyrics = ""
+
+    else:  # Jingle + Video mode
+        st.markdown("### 🎵 Jingle Settings")
+        ad_jingle_prompt = st.text_area(
+            "Jingle Description",
+            value=st.session_state.get('ad_jingle_prompt', ''),
+            placeholder="Upbeat pop jingle, catchy melody, modern production, energetic and positive",
+            height=100,
+            help="Describe the musical style, mood, and characteristics",
+            key="ad_jingle_description"
+        )
+
+        ad_jingle_lyrics = st.text_area(
+            "Jingle Lyrics or Slogan (Optional)",
+            value=st.session_state.get('ad_lyrics', ''),
+            placeholder="Enter your brand slogan, product name, tagline, or catchy phrases you want sung in the jingle (e.g., 'Fresh coffee, every morning', 'The future is here', 'Just do it')",
+            height=80,
+            help="Add lyrics, slogans, or brand messages to make your jingle memorable. Leave empty for an instrumental-only jingle.",
+            key="ad_jingle_lyrics_input"
+        )
+
+        st.markdown("### 🎬 Video Settings")
+
+        # Choose text-to-video or image-to-video for the jingle+video mode
+        video_sub_mode = st.radio(
+            "Video generation method:",
+            ["Text-to-Video", "Image-to-Video"],
+            key="jingle_video_submode",
+            horizontal=True
+        )
+
+        if video_sub_mode == "Image-to-Video":
+            uploaded_image = st.file_uploader(
+                "Upload starting image (PNG, JPG, JPEG)",
+                type=["png", "jpg", "jpeg"],
+                key="ad_image_uploader_jingle",
+                help="This image will be the first frame"
+            )
+            if uploaded_image:
+                col_img1, col_img2 = st.columns([1, 2])
+                with col_img1:
+                    st.image(uploaded_image, caption="Uploaded Image", use_column_width=True)
+                image_bytes = uploaded_image.read()
+                st.session_state.ad_uploaded_image = base64.b64encode(image_bytes).decode('utf-8')
+            ad_video_mode = "image_to_video"
+        else:
+            ad_video_mode = "text_to_video"
+
+        ad_video_prompt = st.text_area(
+            "Video Description / Animation",
+            value=st.session_state.get('ad_video_prompt', ''),
+            placeholder="Sleek modern smartphone rotating on reflective surface, studio lighting, cinematic 4k" if video_sub_mode == "Text-to-Video" else "Camera zooms in while product rotates, dramatic lighting",
+            height=100,
+            help="Describe visuals (text-to-video) or motion/animation (image-to-video)",
+            key="ad_video_description"
+        )
+
+    st.markdown("---")
+
+    # Example Prompts Section
+    if generation_mode == "🎵 Jingle + Video":
+        st.markdown("### 💡 Example Commercial Ads")
+
+        EXAMPLE_COMMERCIAL_ADS = {
+            "Select an example...": {"jingle": "", "lyrics": "", "video": ""},
+            "Luxury Car Launch": {
+                "jingle": "cinematic orchestral, powerful strings, epic drums, sophisticated and premium, rising crescendo",
+                "lyrics": "Drive the future, feel the power, elegance in motion, every hour",
+                "video": "Sleek black luxury sedan driving through mountain roads at golden hour, dramatic low angle shots, cinematic camera movements, reflections on polished surface, mist rolling through valleys"
+            },
+            "Coffee Shop Morning": {
+                "jingle": "acoustic guitar, warm and cozy, jazzy piano, uplifting morning vibes, folk pop",
+                "lyrics": "Morning starts with you, fresh and true, every sip a new day, brewing your way",
+                "video": "Steaming coffee cup on rustic wooden table by cafe window, warm morning sunlight streaming through, barista pouring latte art, cozy atmosphere with bokeh background"
+            },
+            "Fitness App Energy": {
+                "jingle": "energetic electronic, powerful drums, motivational synths, upbeat tempo, pumping bass",
+                "lyrics": "Push harder, go further, stronger every day, your journey starts today",
+                "video": "Dynamic shots of athletes training at sunrise, running on urban streets with motion blur, high-energy movements, sweat droplets in slow motion, city skyline background"
+            },
+            "Gourmet Restaurant": {
+                "jingle": "elegant classical piano, soft strings, refined and luxurious, smooth jazz elements",
+                "lyrics": "Taste perfection, culinary art, every bite a masterpiece, dining from the heart",
+                "video": "Extreme close-up of gourmet dishes being plated by chef, flames on grill with premium steaks, artistic food presentation, shallow depth of field, vibrant colors"
+            },
+            "Adventure Travel": {
+                "jingle": "epic rock, electric guitar riffs, powerful drums, adventurous and bold, inspiring melody",
+                "lyrics": "Explore the world, break free, adventure calls, wild and free",
+                "video": "Drone shot soaring over mountain peaks at sunset, hikers reaching summit with arms raised, coastal cliffs with crashing waves, cinematic aerial views"
+            },
+            "Tech Innovation": {
+                "jingle": "futuristic electronic, synthesizers, modern beats, innovative sound, digital atmosphere",
+                "lyrics": "Tomorrow is here, innovation clear, technology that transforms, future takes form",
+                "video": "Modern smartphone with holographic interface projections, sleek product rotating on reflective black surface, blue neon lighting, high-tech laboratory background"
+            },
+            "Summer Beach Party": {
+                "jingle": "tropical house, upbeat rhythm, steel drums, party vibes, summer energy, electronic dance",
+                "lyrics": "Sun and sand, party all night, summer vibes, feeling right",
+                "video": "Beach party at sunset with bonfire, people dancing on the sand, colorful drinks with ice, palm trees swaying, ocean waves in background, golden hour lighting"
+            },
+            "Luxury Perfume": {
+                "jingle": "sensual piano, soft orchestral strings, elegant and mysterious, slow tempo, sophisticated",
+                "lyrics": "Essence of elegance, timeless grace, luxury captured, in every trace",
+                "video": "Elegant perfume bottle on marble pedestal with dramatic spotlight, golden liquid swirling inside, soft focus background, roses falling in slow motion, luxury studio aesthetic"
+            }
+        }
+
+        example_selector = st.selectbox(
+            "Choose an example commercial:",
+            list(EXAMPLE_COMMERCIAL_ADS.keys()),
+            key="commercial_example_selector"
+        )
+
+        if example_selector != "Select an example...":
+            if st.button("📋 Use This Example", key="use_commercial_example_btn"):
+                # Set session state using the widget keys to ensure immediate update
+                st.session_state['ad_jingle_description'] = EXAMPLE_COMMERCIAL_ADS[example_selector]["jingle"]
+                st.session_state['ad_jingle_lyrics_input'] = EXAMPLE_COMMERCIAL_ADS[example_selector]["lyrics"]
+                st.session_state['ad_video_description'] = EXAMPLE_COMMERCIAL_ADS[example_selector]["video"]
+                st.rerun()
+
+        st.markdown("---")
+
+    # ========================================================================
+    # VIDEO GENERATION PARAMETERS - User Controls
+    # ========================================================================
+
+    # Check if user is logged in
+    is_logged_in = st.session_state.get("jwt_token") is not None
+    jwt_token = st.session_state.get("jwt_token", "")
+
+    # Get video credits and eligibility
+    video_credits = None
+    eligibility = None
+    can_generate = False
+    is_admin = False
+
+    if is_logged_in:
+        try:
+            video_credits = get_video_credits(jwt_token)
+            eligibility = check_video_eligibility(jwt_token)
+            can_generate = eligibility.get('can_generate', False)
+
+            # Check if admin
+            decoded_token = jwt.decode(jwt_token, options={"verify_signature": False})
+            user_id = decoded_token.get('data', {}).get('user', {}).get('id')
+            is_admin = user_id in [1, 206]
+
+        except Exception as e:
+            st.error(f"Error checking video eligibility: {str(e)}")
+
+    # Determine if user can customize
+    can_customize = is_admin or (video_credits and int(video_credits.get('remaining_credits', 0)) > 0)
+
+    # Mode toggle
+    is_custom_mode = st.toggle(
+        "🎨 Customize Settings" if can_customize else "🔒 Customize (Requires Credits)",
+        value=False,
+        disabled=not can_customize,
+        help="Use presets (free) or customize all parameters (requires credits)"
+    )
+
+    # Compact settings in expander
+    with st.expander("⚙️ Video Settings" if is_custom_mode else "⚙️ Video Settings (Preset Mode)", expanded=True):
+        # Determine max duration based on package tier
+        if video_credits and video_credits.get('package_tier') == 'expert':
+            max_duration = 15
+            allows_intro = True
+        elif video_credits and video_credits.get('package_tier') in ['advanced', 'custom_4', 'custom_12', 'custom_20']:
+            max_duration = 10
+            allows_intro = False
+        elif video_credits and video_credits.get('package_tier') == 'basic':
+            max_duration = 5
+            allows_intro = False
+        else:
+            max_duration = 3  # Free tier
+            allows_intro = False
+
+        # Display preset info if not customizing
+        if not is_custom_mode:
+            st.info("📌 Preset: 3s video, 16 FPS (Standard), Balanced creativity")
+
+        # Initialize intro variables before they're used in UI
+        add_expert_intro = False
+        intro_prompt = ""
+        company_name = ""
+
+        # Expert intro option (must come before duration slider so checkbox updates variables)
+        if allows_intro and is_custom_mode:
+            with st.expander("🎬 Expert: Add 5-Second Intro (Optional)"):
+                add_expert_intro = st.checkbox("Enable 5s branded intro")
+                if add_expert_intro:
+                    st.info("📹 **How it works:** We'll generate a 5-second intro video with your logo/branding, add a voiceover saying your company name, then combine it with your 10-second main video for a professional 15-second commercial!")
+
+                    intro_prompt = st.text_area(
+                        "Intro Visual Description",
+                        placeholder="Company logo centered on dark blue gradient background with soft spotlight",
+                        height=60,
+                        help="Describe what you want to see in your 5-second intro (logo, background, lighting, etc.)"
+                    )
+                    company_name = st.text_input("Company Name (for voiceover)",
+                        placeholder="YourBrand Inc.",
+                        help="We'll generate a professional voiceover saying this name")
+                    st.caption("💡 Intro generates at 8fps (perfect for static logos) with professional voiceover • Saves compute cost while maintaining quality")
+
+        # Compact 2-column layout for all settings
+        col1, col2 = st.columns(2)
+
+        with col1:
+            # Show duration note if intro is enabled
+            if add_expert_intro:
+                st.info("ℹ️ With intro enabled: 5s intro + 10s main = 15s final video")
+
+            # Determine default and max values for duration slider
+            default_duration = 3
+            max_duration_value = max_duration if is_custom_mode else 3
+
+            if add_expert_intro:
+                max_duration_value = 10  # Limit to 10s when intro enabled
+                default_duration = min(3, 10)
+
+            duration_seconds = st.slider(
+                "📹 Duration" + (" (Main Video)" if add_expert_intro else ""),
+                min_value=2,
+                max_value=max_duration_value,
+                value=default_duration,
+                step=1,
+                disabled=not is_custom_mode,
+                help="With intro: Max 10s (5s intro + 10s main = 15s total) | Without intro: Free: 3s | Basic: 5s | Advanced: 10s | Expert: 15s"
+            )
+
+            guidance_scale = st.slider(
+                "🎨 Creativity",
+                min_value=1.0,
+                max_value=15.0,
+                value=7.0,
+                step=0.5,
+                disabled=not is_custom_mode,
+                help="Lower=creative, Higher=accurate (7-9 optimal)"
+            )
+
+        with col2:
+            # FPS selection - based on credit stacks (each credit tied to specific FPS tier)
+            quality_options = {}
+            fps_to_label = {}  # Maps FPS value back to label for lookup
+
+            if is_admin:
+                # Admin gets all options without credit requirements
+                quality_options = {"Basic (8fps)": 8, "Standard (16fps)": 16, "HD (24fps)": 24}
+                fps_to_label = {8: "Basic (8fps)", 16: "Standard (16fps)", 24: "HD (24fps)"}
+            elif video_credits:
+                # Get available FPS tiers from credit stacks
+                available_fps_tiers = video_credits.get('available_fps_tiers', {})
+
+                # Build dropdown showing ALL FPS options user can use
+                # User can use any FPS <= their max fps_tier
+                # Example: fps_tier=24 allows 8, 16, 24fps (custom packages)
+                #          fps_tier=16 allows 8, 16fps (bought 16fps addon)
+                #          fps_tier=8 allows 8fps only (bought 8fps addon)
+                if available_fps_tiers:
+                    # Find the maximum FPS tier the user has credits for
+                    max_fps_tier = max([int(tier) for tier in available_fps_tiers.keys() if int(available_fps_tiers[tier]) > 0], default=0)
+
+                    # Get total credits (sum across all stacks)
+                    total_credits = sum([int(available_fps_tiers[tier]) for tier in available_fps_tiers.keys()])
+
+                    # Show all FPS options up to their max tier
+                    if max_fps_tier >= 8 and total_credits > 0:
+                        label = f"Basic (8fps) - {total_credits} credit{'s' if total_credits != 1 else ''}"
+                        quality_options[label] = 8
+                        fps_to_label[8] = label
+
+                    if max_fps_tier >= 16 and total_credits > 0:
+                        label = f"Standard (16fps) - {total_credits} credit{'s' if total_credits != 1 else ''}"
+                        quality_options[label] = 16
+                        fps_to_label[16] = label
+
+                    if max_fps_tier >= 24 and total_credits > 0:
+                        label = f"HD (24fps) - {total_credits} credit{'s' if total_credits != 1 else ''}"
+                        quality_options[label] = 24
+                        fps_to_label[24] = label
+
+            if is_custom_mode:
+                if quality_options:
+                    # Show only FPS tiers where user has credits
+                    available_options = list(quality_options.keys())
+                    default_index = min(1, len(available_options) - 1)  # Default to Standard if available
+
+                    selected_quality = st.selectbox(
+                        "🎞️ Quality",
+                        options=available_options,
+                        index=default_index,
+                        help="Each credit is tied to the FPS tier you purchased it with"
+                    )
+                    fps = quality_options[selected_quality]
+                else:
+                    # No credits available - show disabled dropdown
+                    st.selectbox(
+                        "🎞️ Quality",
+                        options=["No credits available"],
+                        index=0,
+                        disabled=True,
+                        help="Purchase credits to unlock custom video generation"
+                    )
+                    fps = 16  # Fallback value
+            else:
+                fps = 16
+                st.selectbox(
+                    "🎞️ Quality",
+                    options=["Standard (16fps)"],
+                    index=0,
+                    disabled=True
+                )
+
+            video_guidance_scale = st.slider(
+                "⚡ Motion",
+                min_value=1.0,
+                max_value=10.0,
+                value=5.0,
+                step=0.5,
+                disabled=not is_custom_mode,
+                help="Lower=smooth, Higher=dynamic"
+            )
+
+    # ========================================================================
+    # LOGIN AND ELIGIBILITY CHECKS
+    # ========================================================================
+
+    # Check 1: Must be logged in
+    if not is_logged_in:
+        st.error("⚠️ **Please log in to generate videos**")
+        st.info("👉 Use the sidebar to log in or sign up")
+        st.stop()
+
+    # Check 2: Check eligibility (credits or free generations)
+    if not is_admin and not can_generate:
+        st.error("⚠️ **No video credits or free generations remaining**")
+
+        if eligibility:
+            st.warning(f"Credits: {eligibility.get('credits', 0)} | Free remaining: {eligibility.get('free_remaining', 0)}/2")
+
+        st.markdown("### 🛒 Purchase Video Credits")
+        st.markdown("Choose a package to continue generating videos:")
+
+        pkg_col1, pkg_col2, pkg_col3 = st.columns(3)
+
+        with pkg_col1:
+            st.markdown("**Basic** - $17.50")
+            st.markdown("- 1 **Basic-Tier** Credit")
+            st.markdown("- Up to 5 seconds")
+            st.markdown("- Choose quality (FPS)")
+
+        with pkg_col2:
+            st.markdown("**Advanced** - $35.00")
+            st.markdown("- 1 **Advanced-Tier** Credit")
+            st.markdown("- Up to 10 seconds")
+            st.markdown("- Choose quality (FPS)")
+
+        with pkg_col3:
+            st.markdown("**Expert** - $42.00")
+            st.markdown("- 1 **Expert-Tier** Credit")
+            st.markdown("- Up to 15 seconds + intro")
+            st.markdown("- Choose quality (FPS)")
+
+        st.markdown("---")
+
+        # Single "View All Packages" button that links to WordPress pricing page
+        st.markdown("### 🛒 Purchase Video Credits")
+        st.markdown("[**Click Here to View All Packages & Buy Credits →**](https://songlabai.com/video-pricing/)")
+        st.info("💡 You'll be redirected to our secure pricing page where you can choose your package and complete payment via Stripe.")
+
+        st.stop()
+
+    # Check 3: Preset mode warning for free users
+    if not is_custom_mode and video_credits:
+        free_remaining = video_credits.get('free_generations_remaining', 0)
+        if free_remaining == 2:
+            st.info(f"🎁 Using free preset generation (1/2)")
+        elif free_remaining == 1:
+            st.warning(f"⚠️ Using your LAST free preset generation (2/2) - Purchase credits to continue after this!")
+        elif free_remaining == 0:
+            st.error(f"🔒 You've used all 2 free generations - Purchase credits to continue")
+
+    # Generation Button - Label changes based on mode and eligibility
+    if generation_mode == "🎵 Jingle + Video":
+        button_label = "🚀 Generate Jingle + Video"
+    else:
+        button_label = "🚀 Generate Video"
+
+    # CRITICAL: Disable button completely if user has no eligibility (no credits and no free generations)
+    # This prevents any endpoint calls from users who have exhausted their free generations
+    button_enabled = is_admin or can_generate
+
+    if button_enabled:
+        generate_ad_button = st.button(button_label, type="primary", use_container_width=True, key="generate_ad_btn")
+    else:
+        # Show disabled button with clear message why it's disabled
+        st.button(
+            "🔒 No Credits or Free Generations Available",
+            type="primary",
+            use_container_width=True,
+            disabled=True,
+            key="generate_ad_btn_disabled",
+            help="Purchase video credits to generate videos"
+        )
+        generate_ad_button = False  # Ensure the button click is always False
+
+    if generate_ad_button:
+        # CRITICAL SAFETY CHECK: Double-check eligibility before starting ANY generation
+        # This prevents endpoint calls even if button was somehow clicked
+        if not is_admin and not can_generate:
+            st.error("❌ **Generation blocked: No credits or free generations available**")
+            st.info("💡 Purchase video credits to continue generating videos")
+            st.stop()
+
+        # Validation based on mode
+        validation_passed = True
+
+        if generation_mode == "🖼️ Video Only (Image-to-Video)" or (generation_mode == "🎵 Jingle + Video" and ad_video_mode == "image_to_video"):
+            if not st.session_state.ad_uploaded_image:
+                st.error("❌ Please upload an image first")
+                validation_passed = False
+
+        if not ad_video_prompt:
+            st.error("❌ Please provide a video description/prompt")
+            validation_passed = False
+
+        if generation_mode == "🎵 Jingle + Video" and not ad_jingle_prompt:
+            st.error("❌ Please provide a jingle description")
+            validation_passed = False
+
+        if validation_passed:
+            # Reset previous generation
+            st.session_state.ad_jingle_bytes = None
+            st.session_state.ad_video_path = None
+            st.session_state.ad_final_video = None
+
+            # Progress tracking
+            st.markdown("### 📊 Generation Progress")
+
+            # Show estimated time and send video warmup request for Jingle + Video mode
+            if generation_mode == "🎵 Jingle + Video":
+                # Calculate dynamic time estimate based on duration and FPS
+                # Reference: 10s @ 24fps = 15 minutes (240 frames)
+                # Formula: estimated_minutes = (duration * fps) / 16 frames/min
+                video_estimate_minutes = (duration_seconds * fps) / 16
+                jingle_estimate_minutes = 2  # Jingle typically takes 1-2 minutes
+                intro_estimate_minutes = 0
+
+                # Add intro time if enabled
+                if add_expert_intro and intro_prompt:
+                    intro_estimate_minutes = 4  # 5s @ 8fps intro + voiceover generation
+                    video_estimate_minutes = (10 * fps) / 16  # Main video capped at 10s
+
+                total_estimate_minutes = int(video_estimate_minutes + jingle_estimate_minutes + intro_estimate_minutes)
+
+                if add_expert_intro and intro_prompt:
+                    st.info(f"⏱️ Total estimated time: ~{total_estimate_minutes} minutes (Jingle: ~2 min, Intro: ~4 min, Main Video: ~{int(video_estimate_minutes)} min, Combining: ~1 min)")
+                else:
+                    st.info(f"⏱️ Total estimated time: ~{total_estimate_minutes} minutes (Jingle: ~2 min, Video: ~{int(video_estimate_minutes)} min)")
+
+                # Send warmup request to video endpoint to start initialization in background
+                VIDEO_ENDPOINT_URL = os.environ.get("VIDEO_ENDPOINT_URL", "")
+                VIDEO_HF_TOKEN = os.environ.get("VIDEO_HF_TOKEN", "")
+
+                if VIDEO_ENDPOINT_URL and VIDEO_HF_TOKEN:
+                    import threading
+
+                    def warmup_video_endpoint():
+                        try:
+                            # Send a minimal warmup request to trigger endpoint initialization
+                            warmup_payload = {
+                                "inputs": {
+                                    "prompt": "warmup",
+                                    "mode": "text_to_video",
+                                    "width": 640,
+                                    "height": 384,
+                                    "temp": 16,
+                                    "guidance_scale": 7.0,
+                                    "video_guidance_scale": 5.0,
+                                    "num_inference_steps": [5, 5, 5],
+                                    "video_num_inference_steps": [3, 3, 3],
+                                    "fps": 24
+                                }
+                            }
+                            warmup_headers = {
+                                "Authorization": f"Bearer {VIDEO_HF_TOKEN}",
+                                "Content-Type": "application/json"
+                            }
+                            requests.post(VIDEO_ENDPOINT_URL, headers=warmup_headers, json=warmup_payload, timeout=10)
+                        except:
+                            pass  # Ignore errors, this is just a warmup to wake the endpoint
+
+                    # Start warmup in background thread - non-blocking
+                    warmup_thread = threading.Thread(target=warmup_video_endpoint)
+                    warmup_thread.daemon = True
+                    warmup_thread.start()
+
+            # ========================================================================
+            # STEP 1: GENERATE JINGLE (only for Jingle + Video mode)
+            # ========================================================================
+            if generation_mode == "🎵 Jingle + Video":
+                with st.container():
+                    st.markdown("#### Step 1/3: Generating Jingle 🎵")
+
+                    # Get lyrics endpoint from environment
+                    LYRICS_API_URL = os.environ.get("LYRICS_API_URL", "")
+
+                    if not LYRICS_API_URL:
+                        st.error("❌ Jingle endpoint not configured. Please set LYRICS_API_URL environment variable.")
+                        st.stop()
+
+                    else:
+                        # Prepare jingle generation payload
+                        # Match jingle duration to video duration
+                        jingle_duration = float(duration_seconds)
+
+                        jingle_payload = {
+                            "inputs": {
+                                "prompt": ad_jingle_prompt,
+                                "lyrics": ad_jingle_lyrics
+                            },
+                            "parameters": {
+                                "duration": jingle_duration,  # Match video duration
+                                "infer_step": 60,
+                                "guidance_scale": 15,
+                                "scheduler_type": "euler",
+                                "cfg_type": "apg",
+                                "omega_scale": 10,
+                                "guidance_interval": 0.5,
+                                "guidance_interval_decay": 0.0,
+                                "min_guidance_scale": 3.0,
+                                "use_erg_tag": True,
+                                "use_erg_lyric": False,
+                                "use_erg_diffusion": True,
+                                "oss_steps": [],
+                                "guidance_scale_text": 0.0,
+                                "guidance_scale_lyric": 0.0
+                            }
+                        }
+
+                        jingle_headers = {
+                            "Authorization": f"Bearer {BEARER_TOKEN}",
+                            "Content-Type": "application/json"
+                        }
+
+                        # Retry logic for cold starts
+                        max_retries = 5
+                        retry_delay = 60  # seconds between retries (cold start ~80s)
+                        jingle_success = False
+
+                        for attempt in range(max_retries):
+                            try:
+                                if attempt == 0:
+                                    spinner_msg = "🎵 Generating jingle (1-2 minutes)..."
+                                else:
+                                    spinner_msg = f"🎵 Retrying jingle generation (attempt {attempt + 1}/{max_retries})..."
+
+                                with st.spinner(spinner_msg):
+                                    jingle_response = requests.post(
+                                        LYRICS_API_URL,
+                                        headers=jingle_headers,
+                                        json=jingle_payload,
+                                        timeout=180  # 3 minute timeout
+                                    )
+
+                                if jingle_response.status_code == 200:
+                                    jingle_result = jingle_response.json()
+
+                                    if "audio" in jingle_result:
+                                        # Decode base64 audio
+                                        jingle_bytes = base64.b64decode(jingle_result["audio"])
+                                        st.session_state.ad_jingle_bytes = jingle_bytes
+
+                                        # Preview jingle
+                                        st.success(f"✅ Jingle generated! ({jingle_result.get('duration', 10):.1f}s)")
+                                        st.audio(jingle_bytes, format="audio/wav")
+                                        jingle_success = True
+                                        break
+                                    else:
+                                        st.error(f"❌ Jingle generation failed: {jingle_result.get('error', 'Unknown error')}")
+                                        st.stop()
+                                elif jingle_response.status_code == 503:
+                                    if attempt < max_retries - 1:
+                                        st.warning(f"⏳ Jingle service is warming up (cold start ~80s). Waiting {retry_delay}s before retry {attempt + 2}/{max_retries}...")
+                                        time.sleep(retry_delay)
+                                    else:
+                                        st.error(f"❌ Jingle endpoint error: HTTP 503 - Service failed to warm up after {max_retries} attempts")
+                                        st.info("💡 Please wait a moment and try generating again.")
+                                        st.stop()
+                                else:
+                                    st.error(f"❌ Jingle endpoint error: HTTP {jingle_response.status_code}")
+                                    st.stop()
+
+                            except requests.exceptions.Timeout:
+                                if attempt < max_retries - 1:
+                                    st.warning(f"⏳ Request timed out. Retrying ({attempt + 2}/{max_retries})...")
+                                    time.sleep(retry_delay)
+                                else:
+                                    st.error(f"❌ Jingle generation timed out after {max_retries} attempts")
+                                    st.stop()
+                            except Exception as e:
+                                if attempt < max_retries - 1:
+                                    st.warning(f"⚠️ Error: {str(e)}. Retrying ({attempt + 2}/{max_retries})...")
+                                    time.sleep(retry_delay)
+                                else:
+                                    st.error(f"❌ Jingle generation error: {str(e)}")
+                                    st.stop()
+
+                        if not jingle_success:
+                            st.error("❌ Failed to generate jingle after all retry attempts")
+                            st.stop()
+
+            st.markdown("---")
+
+            # ========================================================================
+            # STEP 2: GENERATE VIDEO (runs for all modes, but step number varies)
+            # ========================================================================
+            # Determine if we should proceed with video generation
+            should_generate_video = True
+            if generation_mode == "🎵 Jingle + Video":
+                # Only generate video if jingle was successful
+                if not st.session_state.ad_jingle_bytes:
+                    should_generate_video = False
+                step_label = "#### Step 2/3: Generating Video 🎬"
+            else:
+                # Video-only modes - show time estimate
+                step_label = "#### Generating Video 🎬"
+                # Calculate dynamic time estimate based on duration and FPS
+                # Reference: 10s @ 24fps = 15 minutes (240 frames)
+                # Formula: estimated_minutes = (duration * fps) / 16 frames/min
+                intro_estimate_minutes = 0
+                main_video_duration = duration_seconds
+
+                if add_expert_intro and intro_prompt:
+                    intro_estimate_minutes = 4  # 5s @ 8fps intro + voiceover
+                    main_video_duration = min(duration_seconds, 10)  # Main video capped at 10s
+
+                video_estimate_minutes = int((main_video_duration * fps) / 16)
+                total_estimate = video_estimate_minutes + intro_estimate_minutes
+
+                if add_expert_intro and intro_prompt:
+                    st.info(f"⏱️ Estimated time: ~{total_estimate} minutes (Intro: ~4 min, Main Video: ~{video_estimate_minutes} min, Combining: ~1 min)")
+                else:
+                    st.info(f"⏱️ Estimated time: ~{video_estimate_minutes} minutes")
+
+            if should_generate_video:
+                with st.container():
+                    st.markdown(step_label)
+
+                    # Video endpoint configuration from environment variables
+                    VIDEO_ENDPOINT_URL = os.environ.get("VIDEO_ENDPOINT_URL", "")
+                    VIDEO_HF_TOKEN = os.environ.get("VIDEO_HF_TOKEN", "")
+                    VIDEO_REPO_ID = os.environ.get("VIDEO_REPO_ID", "Phoenixak99/savedvideos")
+                    HF_TOKEN_DOWNLOAD = os.environ.get("HF_TOKEN_DOWNLOAD", "")
+
+                    # Check if required environment variables are set
+                    if not VIDEO_ENDPOINT_URL:
+                        st.error("❌ Video endpoint not configured. Please set VIDEO_ENDPOINT_URL environment variable.")
+                        st.stop()
+                    if not VIDEO_HF_TOKEN:
+                        st.error("❌ Video endpoint token not configured. Please set VIDEO_HF_TOKEN environment variable.")
+                        st.stop()
+                    if not HF_TOKEN_DOWNLOAD:
+                        st.error("❌ HuggingFace download token not configured. Please set HF_TOKEN_DOWNLOAD environment variable.")
+                        st.stop()
+
+                    # ========================================================================
+                    # EXPERT INTRO GENERATION (if enabled)
+                    # ========================================================================
+                    intro_video_path = None
+
+                    if add_expert_intro and intro_prompt:
+                        st.markdown("##### 🎬 Generating 5-Second Intro...")
+
+                        # Adjust main video duration to 10s (intro adds +5s)
+                        main_video_duration = min(duration_seconds, 10)
+
+                        # Generate 5-second intro video at 8fps (low quality for logo)
+                        intro_temp = int((5 * 8 * 31) / 240)  # 5 seconds at 8fps
+
+                        intro_payload = {
+                            "inputs": {
+                                "prompt": intro_prompt,
+                                "mode": "text_to_video",
+                                "width": 1280,
+                                "height": 768,
+                                "temp": intro_temp,
+                                "guidance_scale": 7.0,
+                                "video_guidance_scale": 5.0,
+                                "num_inference_steps": [10, 10, 10],  # Lower quality for speed
+                                "video_num_inference_steps": [5, 5, 5],
+                                "fps": 8  # Low FPS for static logo
+                            }
+                        }
+
+                        intro_headers = {
+                            "Authorization": f"Bearer {VIDEO_HF_TOKEN}",
+                            "Content-Type": "application/json"
+                        }
+
+                        try:
+                            from huggingface_hub import HfApi
+                            api = HfApi()
+
+                            # Get initial count
+                            initial_files = api.list_repo_files(
+                                repo_id=VIDEO_REPO_ID,
+                                repo_type="dataset",
+                                token=HF_TOKEN_DOWNLOAD
+                            )
+                            intro_initial_count = len([f for f in initial_files if f.endswith('.mp4')])
+
+                            # Send intro generation request
+                            st.info("📤 Sending intro video generation request...")
+                            intro_response = requests.post(VIDEO_ENDPOINT_URL, headers=intro_headers, json=intro_payload, timeout=60)
+
+                            if intro_response.status_code != 200:
+                                st.error(f"❌ Intro generation failed: HTTP {intro_response.status_code}")
+                                st.stop()
+
+                            # Monitor for intro video completion
+                            intro_start_time = time.time()
+                            intro_max_wait = 300  # 5 minutes for intro
+                            intro_progress = st.progress(0)
+                            intro_status = st.empty()
+
+                            intro_video_path = None
+
+                            while True:
+                                intro_elapsed = time.time() - intro_start_time
+
+                                if intro_elapsed > intro_max_wait:
+                                    st.error("❌ Intro video generation timeout")
+                                    st.stop()
+
+                                intro_progress.progress(min(intro_elapsed / (4 * 60), 0.95))
+                                intro_status.text(f"⏳ Generating intro... {intro_elapsed/60:.1f} min elapsed")
+
+                                # Check for new intro video
+                                try:
+                                    files = api.list_repo_files(
+                                        repo_id=VIDEO_REPO_ID,
+                                        repo_type="dataset",
+                                        token=HF_TOKEN_DOWNLOAD
+                                    )
+                                    video_files = [f for f in files if f.endswith('.mp4')]
+
+                                    if len(video_files) > intro_initial_count:
+                                        # Found new video
+                                        new_videos = sorted([f for f in video_files if f not in initial_files],
+                                                          key=lambda x: x, reverse=True)
+
+                                        if new_videos:
+                                            intro_video_file = new_videos[0]
+                                            video_url = f"https://huggingface.co/datasets/{VIDEO_REPO_ID}/resolve/main/{intro_video_file}"
+
+                                            st.info("📥 Downloading intro video...")
+                                            download_headers = {"Authorization": f"Bearer {HF_TOKEN_DOWNLOAD}"}
+                                            intro_video_response = requests.get(video_url, headers=download_headers, timeout=120)
+
+                                            if intro_video_response.status_code == 200:
+                                                # Save intro video to temp file
+                                                intro_video_path = tempfile.mktemp(suffix="_intro.mp4")
+                                                with open(intro_video_path, "wb") as f:
+                                                    f.write(intro_video_response.content)
+
+                                                st.success("✅ Intro video generated!")
+                                                intro_progress.progress(1.0)
+                                                break
+                                except Exception as e:
+                                    pass
+
+                                time.sleep(10)
+
+                            # Generate voiceover if company name provided
+                            if company_name and intro_video_path:
+                                st.info("🎤 Generating voiceover...")
+
+                                try:
+                                    from gtts import gTTS
+
+                                    # Create TTS audio
+                                    tts = gTTS(text=company_name, lang='en', slow=False)
+                                    voiceover_path = tempfile.mktemp(suffix="_voice.mp3")
+                                    tts.save(voiceover_path)
+
+                                    # Combine intro video + voiceover using FFmpeg
+                                    st.info("🎬 Adding voiceover to intro...")
+                                    import subprocess
+
+                                    intro_with_voice_path = tempfile.mktemp(suffix="_intro_final.mp4")
+
+                                    ffmpeg_cmd = [
+                                        'ffmpeg', '-y',
+                                        '-i', intro_video_path,
+                                        '-i', voiceover_path,
+                                        '-c:v', 'copy',
+                                        '-c:a', 'aac',
+                                        '-b:a', '192k',
+                                        '-filter_complex', '[1:a]afade=t=in:st=0:d=0.5,afade=t=out:st=4.5:d=0.5[a]',
+                                        '-map', '0:v',
+                                        '-map', '[a]',
+                                        '-shortest',
+                                        intro_with_voice_path
+                                    ]
+
+                                    result = subprocess.run(ffmpeg_cmd, capture_output=True, text=True)
+
+                                    if result.returncode == 0:
+                                        # Replace intro_video_path with version that has voiceover
+                                        os.remove(intro_video_path)
+                                        os.remove(voiceover_path)
+                                        intro_video_path = intro_with_voice_path
+                                        st.success("✅ Voiceover added to intro!")
+                                    else:
+                                        st.warning("⚠️ Could not add voiceover, using intro without voice")
+                                        if os.path.exists(voiceover_path):
+                                            os.remove(voiceover_path)
+                                        if os.path.exists(intro_with_voice_path):
+                                            os.remove(intro_with_voice_path)
+
+                                except ImportError:
+                                    st.warning("⚠️ TTS not available, intro will have no voiceover")
+                                except Exception as e:
+                                    st.warning(f"⚠️ Voiceover generation failed: {str(e)}")
+
+                        except Exception as e:
+                            st.error(f"❌ Intro generation error: {str(e)}")
+                            st.stop()
+
+                        st.markdown("---")
+                        st.markdown("##### 🎬 Generating Main Video (10 seconds)...")
+                    else:
+                        # No intro, use full duration
+                        main_video_duration = duration_seconds
+
+                    # Prepare main video generation payload
+                    # Convert duration to temp parameter
+                    # Reference: 31 temp = 10s at 24fps (240 frames)
+                    # Formula: temp = (duration_seconds * fps) / 7.74
+                    temp_value = int((main_video_duration * fps * 31) / 240)
+
+                    video_payload = {
+                        "inputs": {
+                            "prompt": ad_video_prompt,
+                            "mode": ad_video_mode,  # text_to_video or image_to_video
+                            "width": 1280,
+                            "height": 768,
+                            "temp": temp_value,  # User-selected duration
+                            "guidance_scale": guidance_scale,  # User-selected creativity
+                            "video_guidance_scale": video_guidance_scale,  # User-selected transition energy
+                            "num_inference_steps": [20, 20, 20],
+                            "video_num_inference_steps": [10, 10, 10],
+                            "fps": fps  # User-selected FPS (8, 16, or 24)
+                        }
+                    }
+
+                    # Add image to payload if image-to-video mode
+                    if ad_video_mode == "image_to_video" and st.session_state.ad_uploaded_image:
+                        video_payload["inputs"]["image"] = st.session_state.ad_uploaded_image
+
+                    video_headers = {
+                        "Authorization": f"Bearer {VIDEO_HF_TOKEN}",
+                        "Content-Type": "application/json"
+                    }
+
+                    try:
+                        # Get initial video count from HF dataset
+                        from huggingface_hub import HfApi
+                        import time
+
+                        api = HfApi()
+                        initial_files = api.list_repo_files(
+                            repo_id=VIDEO_REPO_ID,
+                            repo_type="dataset",
+                            token=HF_TOKEN_DOWNLOAD
+                        )
+                        initial_video_count = len([f for f in initial_files if f.endswith('.mp4')])
+
+                        # Send video generation request with retry logic for cold starts
+                        import threading
+
+                        max_video_retries = 5
+                        video_retry_delay = 60  # seconds between retries (cold start ~90s)
+                        request_success = False
+
+                        for video_attempt in range(max_video_retries):
+                            try:
+                                if video_attempt == 0:
+                                    st.info("📤 Sending video generation request...")
+                                else:
+                                    st.info(f"📤 Retrying video request (attempt {video_attempt + 1}/{max_video_retries})...")
+
+                                request_sent = threading.Event()
+                                response_status = {"code": None, "error": None}
+
+                                def send_video_request():
+                                    try:
+                                        resp = requests.post(VIDEO_ENDPOINT_URL, headers=video_headers, json=video_payload, timeout=60)
+                                        response_status["code"] = resp.status_code
+                                        if resp.status_code != 200:
+                                            response_status["error"] = resp.text
+                                    except Exception as e:
+                                        response_status["error"] = str(e)
+                                    finally:
+                                        request_sent.set()
+
+                                thread = threading.Thread(target=send_video_request)
+                                thread.start()
+                                request_sent.wait(timeout=70)
+
+                                # Check if we got a 503 (cold start)
+                                if response_status["code"] == 503:
+                                    if video_attempt < max_video_retries - 1:
+                                        st.warning(f"⏳ Video service is warming up (cold start ~90s). Waiting {video_retry_delay}s before retry {video_attempt + 2}/{max_video_retries}...")
+                                        time.sleep(video_retry_delay)
+                                        continue
+                                    else:
+                                        st.error(f"❌ Video endpoint error: HTTP 503 - Service failed to warm up after {max_video_retries} attempts")
+                                        st.info("💡 Please wait a moment and try generating again.")
+                                        st.stop()
+                                elif response_status["code"] and response_status["code"] != 200:
+                                    st.error(f"❌ Video endpoint error: HTTP {response_status['code']}")
+                                    if response_status["error"]:
+                                        st.error(f"Details: {response_status['error']}")
+                                    st.stop()
+
+                                # Request successful or at least sent
+                                request_success = True
+                                break
+
+                            except Exception as e:
+                                if video_attempt < max_video_retries - 1:
+                                    st.warning(f"⚠️ Error sending request: {str(e)}. Retrying ({video_attempt + 2}/{max_video_retries})...")
+                                    time.sleep(video_retry_delay)
+                                else:
+                                    st.error(f"❌ Failed to send video request: {str(e)}")
+                                    st.stop()
+
+                        if not request_success:
+                            st.error("❌ Failed to send video generation request after all attempts")
+                            st.stop()
+
+                        # Set start time for monitoring
+                        start_time = time.time()
+
+                        # Monitor for video completion
+                        progress_bar = st.progress(0)
+                        status_text = st.empty()
+
+                        # Dynamic timeout based on video complexity
+                        # Reference: 10s @ 24fps = 15 minutes, add 20% buffer
+                        estimated_minutes = (duration_seconds * fps) / 16
+                        max_wait_seconds = int((estimated_minutes + 3) * 60 * 1.2)  # Add 3 min buffer + 20% safety margin
+                        check_interval = 10
+
+                        while True:
+                            elapsed = time.time() - start_time
+
+                            if elapsed > max_wait_seconds:
+                                st.error(f"❌ Video generation timeout ({int(max_wait_seconds/60)} minutes)")
+                                st.stop()
+
+                            # Update progress (show up to 95% until complete)
+                            progress = min(elapsed / (max_wait_seconds * 0.95), 0.95)
+                            progress_bar.progress(progress)
+                            status_text.text(f"⏳ Generating video... {elapsed/60:.1f} min elapsed (est: ~{int(estimated_minutes)} min)")
+
+                            # Check for new video
+                            try:
+                                files = api.list_repo_files(
+                                    repo_id=VIDEO_REPO_ID,
+                                    repo_type="dataset",
+                                    token=HF_TOKEN_DOWNLOAD
+                                )
+                                video_files = [f for f in files if f.endswith('.mp4')]
+
+                                if len(video_files) > initial_video_count:
+                                    # New video detected!
+                                    latest_video = sorted(video_files)[-1]
+                                    video_url = f"https://huggingface.co/datasets/{VIDEO_REPO_ID}/resolve/main/{latest_video}"
+
+                                    progress_bar.progress(1.0)
+                                    status_text.text(f"✅ Video generated in {elapsed/60:.1f} minutes!")
+
+                                    # Download video
+                                    st.info("📥 Downloading video...")
+                                    download_headers = {"Authorization": f"Bearer {HF_TOKEN_DOWNLOAD}"}
+                                    video_response = requests.get(video_url, headers=download_headers, timeout=120)
+
+                                    if video_response.status_code == 200:
+                                        # Save to temp file
+                                        with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as f:
+                                            f.write(video_response.content)
+                                            video_path = f.name
+
+                                        st.session_state.ad_video_path = video_path
+
+                                        st.success(f"✅ Video downloaded! ({len(video_response.content)/1024/1024:.1f} MB)")
+
+                                        # ========================================================================
+                                        # DEDUCT VIDEO CREDIT
+                                        # ========================================================================
+                                        if not is_admin:
+                                            try:
+                                                generation_data = {
+                                                    'mode': ad_video_mode,
+                                                    'duration': duration_seconds,
+                                                    'fps': fps,
+                                                    'guidance_scale': guidance_scale,
+                                                    'video_guidance_scale': video_guidance_scale,
+                                                    'is_preset': not is_custom_mode,
+                                                    'is_expert_intro': add_expert_intro,
+                                                    'prompt': ad_video_prompt,
+                                                    'intro_prompt': intro_prompt if add_expert_intro else None
+                                                }
+
+                                                credit_used = use_video_credit(jwt_token, generation_data)
+
+                                                if credit_used:
+                                                    if not is_custom_mode:
+                                                        st.info("✅ Free generation used!")
+                                                    else:
+                                                        st.info("✅ 1 video credit deducted")
+                                                else:
+                                                    st.warning("⚠️ Failed to deduct credit, but video was generated")
+
+                                            except Exception as e:
+                                                st.warning(f"⚠️ Error deducting credit: {str(e)}")
+
+                                        # ========================================================================
+                                        # COMBINE INTRO + MAIN VIDEO (if intro was generated)
+                                        # ========================================================================
+                                        if intro_video_path and os.path.exists(intro_video_path):
+                                            st.markdown("---")
+                                            st.markdown("##### 🎬 Combining Intro + Main Video...")
+
+                                            try:
+                                                import subprocess
+
+                                                # Create concat list for FFmpeg
+                                                concat_list_path = tempfile.mktemp(suffix="_concat.txt")
+                                                with open(concat_list_path, 'w') as f:
+                                                    f.write(f"file '{intro_video_path}'\n")
+                                                    f.write(f"file '{video_path}'\n")
+
+                                                # Output path for combined video
+                                                combined_video_path = tempfile.mktemp(suffix="_combined.mp4")
+
+                                                # Concatenate intro + main with crossfade transition
+                                                ffmpeg_concat_cmd = [
+                                                    'ffmpeg', '-y',
+                                                    '-f', 'concat',
+                                                    '-safe', '0',
+                                                    '-i', concat_list_path,
+                                                    '-c', 'copy',
+                                                    combined_video_path
+                                                ]
+
+                                                result = subprocess.run(ffmpeg_concat_cmd, capture_output=True, text=True)
+
+                                                if result.returncode == 0:
+                                                    # Replace video_path with combined version
+                                                    os.remove(video_path)
+                                                    os.remove(intro_video_path)
+                                                    os.remove(concat_list_path)
+
+                                                    # Update session state with combined video
+                                                    video_path = combined_video_path
+                                                    st.session_state.ad_video_path = combined_video_path
+
+                                                    st.success("✅ Intro + Main video combined! Final video: 15 seconds")
+                                                else:
+                                                    st.warning(f"⚠️ Could not combine videos: {result.stderr}")
+                                                    st.info("💡 Using main video without intro")
+
+                                            except Exception as e:
+                                                st.warning(f"⚠️ Error combining videos: {str(e)}")
+                                                st.info("💡 Using main video without intro")
+
+                                        # Preview video only for Jingle + Video mode (before combining with audio)
+                                        # For video-only modes, skip preview and show final result with download button
+                                        if generation_mode == "🎵 Jingle + Video":
+                                            # Show preview of combined video (with intro if applicable)
+                                            with open(video_path, 'rb') as f:
+                                                st.video(f.read())
+                                        break
+                                    else:
+                                        st.error(f"❌ Failed to download video: HTTP {video_response.status_code}")
+                                        st.stop()
+
+                            except Exception as e:
+                                st.warning(f"⚠️ Error checking for video: {e}")
+
+                            time.sleep(check_interval)
+
+                    except Exception as e:
+                        st.error(f"❌ Video generation error: {str(e)}")
+                        st.stop()
+
+            st.markdown("---")
+
+            # ========================================================================
+            # STEP 3: COMBINE JINGLE + VIDEO
+            # ========================================================================
+            if st.session_state.ad_jingle_bytes and st.session_state.ad_video_path:
+                with st.container():
+                    st.markdown("#### Step 3/3: Creating Final Ad 🎥")
+
+                    try:
+                        # Save jingle to temp file
+                        with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
+                            f.write(st.session_state.ad_jingle_bytes)
+                            jingle_temp_path = f.name
+
+                        # Output path for final video
+                        final_video_path = tempfile.mktemp(suffix=".mp4")
+
+                        # Use ffmpeg to combine audio and video
+                        import subprocess
+
+                        ffmpeg_cmd = [
+                            "ffmpeg",
+                            "-i", st.session_state.ad_video_path,  # Input video
+                            "-i", jingle_temp_path,  # Input audio
+                            "-c:v", "copy",  # Copy video codec
+                            "-c:a", "aac",  # Encode audio as AAC
+                            "-b:a", "192k",  # Audio bitrate
+                            "-shortest",  # Match shortest stream
+                            "-y",  # Overwrite output
+                            final_video_path
+                        ]
+
+                        with st.spinner("🎬 Merging jingle with video..."):
+                            result = subprocess.run(ffmpeg_cmd, capture_output=True, text=True)
+
+                        if result.returncode == 0 and os.path.exists(final_video_path):
+                            # Read final video
+                            with open(final_video_path, "rb") as f:
+                                final_video_bytes = f.read()
+
+                            st.session_state.ad_final_video = final_video_bytes
+
+                            # ========================================================================
+                            # UPLOAD FULL AD TO HUGGINGFACE DATASET
+                            # ========================================================================
+                            try:
+                                from huggingface_hub import upload_file
+                                import uuid
+
+                                # Generate unique filename
+                                timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+                                unique_id = str(uuid.uuid4())[:8]
+
+                                # Get user ID for filename
+                                try:
+                                    decoded_token = jwt.decode(jwt_token, options={"verify_signature": False})
+                                    user_id = decoded_token.get('data', {}).get('user', {}).get('id', 'unknown')
+                                except:
+                                    user_id = 'unknown'
+
+                                filename = f"full_ad_{timestamp}_{user_id}_{unique_id}.mp4"
+
+                                # Silently upload to cloud storage (background)
+                                try:
+                                    temp_upload_path = tempfile.mktemp(suffix=".mp4")
+                                    with open(temp_upload_path, "wb") as f:
+                                        f.write(final_video_bytes)
+
+                                    upload_file(
+                                        path_or_fileobj=temp_upload_path,
+                                        path_in_repo=filename,
+                                        repo_id=VIDEO_REPO_ID,
+                                        repo_type="dataset",
+                                        token=HF_TOKEN_DOWNLOAD,
+                                    )
+
+                                    # Clean up temp upload file
+                                    try:
+                                        os.remove(temp_upload_path)
+                                    except:
+                                        pass
+                                except:
+                                    # Silently fail - user doesn't need to know about storage
+                                    pass
+
+                            except Exception as e:
+                                # Don't show upload errors to user
+                                pass
+
+                            # Cleanup temp files
+                            try:
+                                os.remove(jingle_temp_path)
+                                os.remove(st.session_state.ad_video_path)
+                                os.remove(final_video_path)
+                            except:
+                                pass
+
+                            st.success("✅ Ad created successfully!")
+
+                            # Display final ad
+                            st.markdown("### 🎉 Your Commercial Ad is Ready!")
+                            st.video(final_video_bytes)
+
+                            # Download button
+                            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+                            st.download_button(
+                                label="⬇️ Download Ad (MP4)",
+                                data=final_video_bytes,
+                                file_name=f"commercial_ad_{timestamp}.mp4",
+                                mime="video/mp4",
+                                use_container_width=True,
+                                key="download_ad_btn"
+                            )
+
+                            st.balloons()
+                        else:
+                            st.error(f"❌ ffmpeg error: {result.stderr}")
+
+                    except Exception as e:
+                        st.error(f"❌ Error combining jingle and video: {str(e)}")
+
+            # ========================================================================
+            # VIDEO-ONLY DOWNLOAD (for modes without jingle)
+            # ========================================================================
+            elif st.session_state.ad_video_path and generation_mode != "🎵 Jingle + Video":
+                with st.container():
+                    st.markdown("### 🎉 Your Video is Ready!")
+
+                    # Read the video file
+                    try:
+                        with open(st.session_state.ad_video_path, "rb") as f:
+                            video_bytes = f.read()
+
+                        # Display video
+                        st.video(video_bytes)
+
+                        # Download button
+                        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+                        mode_name = "text_to_video" if ad_video_mode == "text_to_video" else "image_to_video"
+                        st.download_button(
+                            label="⬇️ Download Video (MP4)",
+                            data=video_bytes,
+                            file_name=f"video_{mode_name}_{timestamp}.mp4",
+                            mime="video/mp4",
+                            use_container_width=True,
+                            key="download_video_only_btn"
+                        )
+
+                        st.balloons()
+
+                        # Cleanup
+                        try:
+                            os.remove(st.session_state.ad_video_path)
+                        except:
+                            pass
+
+                    except Exception as e:
+                        st.error(f"❌ Error reading video file: {str(e)}")
+
+
 st.divider()
 st.header("🎵 Load Previous Music")
 st.markdown("""