Update app.py

app.py

@@ -1,11 +1,12 @@
 #!/usr/bin/env python3
+# BUILD v4 - Smart CSV update from last bar - 2026-05-08
 """
-SMC AI BOT v9.9 - Hugging Face Deployment (COMPLETE)
-- All feature functions included
-- Full 31-criteria filter analysis
-- 5-timeframe SMC signals
-- Telegram alerts every 5 minutes
-- Keep-alive ping to prevent sleeping
+SMC AI BOT v9.9 - Hugging Face Deployment (SMART CSV UPDATE)
+- Checks where uploaded CSV ends (date/time)
+- Fetches only missing bars from Twelve Data
+- Updates CSV in Space with new data
+- Saves all timeframes to disk
+- Signal sent ONLY when new candle data arrives
 """
 
 import os, numpy as np, pandas as pd, warnings, requests, time, threading
@@ -21,11 +22,25 @@ app = Flask(__name__)
 
 @app.route('/')
 def home():
-    return "🤖 SMC AI Bot v9.9 — Live on Hugging Face"
+    bars = len(data.get('5min', []))
+    tfs = [tf for tf in ['5min','30min','1h','2h','4h'] if tf in data and len(data[tf]) >= 201]
+    csv_date = get_csv_last_date(CSV_5MIN_LIVE) if os.path.exists(CSV_5MIN_LIVE) else None
+    return f"🤖 SMC Bot v9.9 — {bars:,} bars | Active: {len(tfs)}/5 TFs | CSV ends: {csv_date} | API: {api_call_count}/{MAX_API_CALLS_PER_DAY}"
 
 @app.route('/health')
 def health():
-    return {"status": "alive", "time": str(datetime.now(timezone.utc)), "models": len(models)}
+    return {
+        "status": "alive", "time": str(datetime.now(timezone.utc)),
+        "models": len(models), "active_tfs": len([tf for tf in ['5min','30min','1h','2h','4h'] if tf in data and len(data[tf]) >= 201]),
+        "api_calls_today": api_call_count, "csv_last_bar": str(get_csv_last_date(CSV_5MIN_LIVE)) if os.path.exists(CSV_5MIN_LIVE) else None,
+    }
+
+@app.route('/force-save')
+def force_save():
+    global data
+    if not data: return "❌ No data", 500
+    save_all_csvs()
+    return "💾 Saved:\n" + "\n".join([f"{tf}: {len(data[tf]):,} bars" for tf in data])
 
 # ============================================================
 # LOAD SECRETS
@@ -34,9 +49,30 @@ BOT_TOKEN = os.environ.get('TELEGRAM_BOT_TOKEN', '')
 CHAT_ID = os.environ.get('TELEGRAM_CHAT_ID', '')
 TWELVEDATA_API_KEY = os.environ.get('TWELVEDATA_API_KEY', '')
 
-print(f"🔑 Telegram Bot: {'✅' if BOT_TOKEN else '❌ MISSING'}")
-print(f"🔑 Chat ID: {'✅' if CHAT_ID else '❌ MISSING'}")
-print(f"🔑 Twelve Data: {'✅' if TWELVEDATA_API_KEY else '❌ MISSING'}")
+print(f"🔑 Telegram: {'✅' if BOT_TOKEN else '❌'}")
+print(f"🔑 Chat ID: {'✅' if CHAT_ID else '❌'}")
+print(f"🔑 Twelve Data: {'✅' if TWELVEDATA_API_KEY else '❌'}")
+
+# ============================================================
+# API CALL TRACKING
+# ============================================================
+api_call_count = 0
+api_call_reset = datetime.now(timezone.utc).date()
+MAX_API_CALLS_PER_DAY = 600
+
+def track_api_call():
+    global api_call_count, api_call_reset
+    today = datetime.now(timezone.utc).date()
+    if today != api_call_reset:
+        api_call_count = 0; api_call_reset = today
+    api_call_count += 1
+
+def can_call_api():
+    global api_call_count, api_call_reset
+    today = datetime.now(timezone.utc).date()
+    if today != api_call_reset:
+        api_call_count = 0; api_call_reset = today
+    return api_call_count < MAX_API_CALLS_PER_DAY
 
 # ============================================================
 # LOAD MODELS
@@ -44,34 +80,153 @@ print(f"🔑 Twelve Data: {'✅' if TWELVEDATA_API_KEY else '❌ MISSING'}")
 print("\n📦 Loading models...")
 models = {}
 model_files = {
-    '5min':  'model_5min_entry.pkl',
-    '30min': 'model_30min_bias.pkl',
-    '1h':    'model_1h_bias.pkl',
-    '2h':    'model_2h_bias.pkl',
-    '4h':    'model_4h_bias.pkl',
+    '5min': 'model_5min_entry.pkl', '30min': 'model_30min_bias.pkl',
+    '1h': 'model_1h_bias.pkl', '2h': 'model_2h_bias.pkl', '4h': 'model_4h_bias.pkl',
 }
-
 for name, path in model_files.items():
     if os.path.exists(path):
-        try:
-            models[name] = joblib.load(path)
-            print(f"   ✅ {name.upper()}")
-        except Exception as e:
-            print(f"   ❌ {name.upper()}: {e}")
+        try: models[name] = joblib.load(path); print(f"   ✅ {name.upper()}")
+        except Exception as e: print(f"   ❌ {name.upper()}: {e}")
+    else: print(f"   ❌ {name.upper()}: File not found")
+print(f"\n✅ {len(models)}/5 models loaded")
+
+# ============================================================
+# CSV PATHS
+# ============================================================
+CSV_5MIN_LIVE = 'XAUUSD_5MIN_LIVE_UPDATED.csv'
+CSV_30MIN_LIVE = 'XAUUSD_30MIN_LIVE_UPDATED.csv'
+CSV_1H_LIVE = 'XAUUSD_1H_LIVE_UPDATED.csv'
+CSV_2H_LIVE = 'XAUUSD_2H_LIVE_UPDATED.csv'
+CSV_4H_LIVE = 'XAUUSD_4H_LIVE_UPDATED.csv'
+
+CSV_MAP = {'5min': CSV_5MIN_LIVE, '30min': CSV_30MIN_LIVE, '1h': CSV_1H_LIVE, '2h': CSV_2H_LIVE, '4h': CSV_4H_LIVE}
+TIMEFRAMES = {'5min': {'minutes': 5, 'fwd': 4}, '30min': {'minutes': 30, 'fwd': 4}, '1h': {'minutes': 60, 'fwd': 6}, '2h': {'minutes': 120, 'fwd': 4}, '4h': {'minutes': 240, 'fwd': 3}}
+TF_LABELS = {'5min':'🎯 5min','30min':'🔒 30min','1h':'🔒 1H','2h':'🔒 2H','4h':'🔒 4H'}
+data = {}
+
+# ============================================================
+# SMART CSV FUNCTIONS
+# ============================================================
+
+def get_csv_last_date(filepath):
+    """Get the last timestamp from a CSV file (fast - reads only last few bytes)"""
+    if not os.path.exists(filepath): return None
+    try:
+        # Fast method: read last 500 bytes
+        with open(filepath, 'rb') as f:
+            f.seek(-500, 2)
+            last_bytes = f.read().decode('utf-8', errors='ignore')
+            lines = last_bytes.strip().split('\n')
+            for line in reversed(lines):
+                if ',' in line and not line.startswith('datetime'):
+                    ts_str = line.split(',')[0]
+                    try:
+                        return pd.to_datetime(ts_str).tz_localize('UTC') if 'UTC' not in ts_str and '+' not in ts_str else pd.to_datetime(ts_str)
+                    except: continue
+        # Fallback: read full file
+        df = pd.read_csv(filepath, parse_dates=['datetime'], nrows=5)
+        return pd.to_datetime(df['datetime'].iloc[-1])
+    except: return None
+
+def update_csv_from_api(filepath):
+    """
+    Check where CSV ends, fetch missing bars from API, update CSV.
+    Returns number of new bars added.
+    """
+    if not TWELVEDATA_API_KEY: return 0
+    if not can_call_api(): return 0
+    
+    last_bar = get_csv_last_date(filepath)
+    now = datetime.now(timezone.utc)
+    
+    # If no CSV or it's empty, fetch 5000 bars
+    if last_bar is None:
+        print(f"   📡 No existing data — fetching 5000 bars...")
+        df_new = fetch_5min(5000)
+        if df_new is not None and len(df_new) > 0:
+            df_new.to_csv(filepath)
+            print(f"   ✅ Created: {len(df_new):,} bars")
+            return len(df_new)
+        return 0
+    
+    # Calculate how many bars are missing
+    gap = now - last_bar
+    gap_minutes = gap.total_seconds() / 60
+    bars_needed = int(gap_minutes / 5) + 10  # 10 extra for safety
+    
+    if bars_needed <= 2:
+        print(f"   ✅ CSV is current (last bar: {last_bar})")
+        return 0
+    
+    bars_needed = min(bars_needed, 5000)
+    print(f"   📡 CSV ends: {last_bar} | Need ~{bars_needed} bars...")
+    
+    df_new = fetch_5min(bars_needed)
+    if df_new is None or len(df_new) == 0:
+        return 0
+    
+    # Filter to only bars after last_bar
+    df_new = df_new[df_new.index > last_bar]
+    
+    if len(df_new) == 0:
+        print(f"   ✅ Already current")
+        return 0
+    
+    # Load existing CSV, merge, save
+    df_existing = load_csv_data(filepath)
+    if df_existing is not None and len(df_existing) > 0:
+        df_combined = pd.concat([df_existing, df_new])
+        df_combined = df_combined[~df_combined.index.duplicated(keep='last')]
+        df_combined.sort_index(inplace=True)
+        added = len(df_combined) - len(df_existing)
+        df_combined.to_csv(filepath)
+        print(f"   ✅ +{added} bars | Total: {len(df_combined):,} | Last: {df_combined.index[-1]}")
+        return added
     else:
-        print(f"   ❌ {name.upper()}: File not found")
+        df_new.to_csv(filepath)
+        print(f"   ✅ Created: {len(df_new):,} bars")
+        return len(df_new)
 
-print(f"\n✅ {len(models)}/5 models loaded")
+# ============================================================
+# DATA PERSISTENCE
+# ============================================================
 
-TIMEFRAMES = {
-    '5min':  {'minutes': 5,   'fwd': 4},
-    '30min': {'minutes': 30,  'fwd': 4},
-    '1h':    {'minutes': 60,  'fwd': 6},
-    '2h':    {'minutes': 120, 'fwd': 4},
-    '4h':    {'minutes': 240, 'fwd': 3},
-}
+def save_all_csvs():
+    global data
+    if not data: return
+    for tf_name, path in CSV_MAP.items():
+        if tf_name in data and data[tf_name] is not None and len(data[tf_name]) > 0:
+            try: data[tf_name].to_csv(path)
+            except Exception as e: print(f"   ⚠️ Save {tf_name}: {e}")
 
-TF_LABELS = {'5min':'🎯 5min','30min':'🔒 30min','1h':'🔒 1H','2h':'🔒 2H','4h':'🔒 4H'}
+def load_csv_data(filepath):
+    if not os.path.exists(filepath): return None
+    try:
+        df = pd.read_csv(filepath, parse_dates=['datetime'])
+        if len(df) == 0: return None
+        df.set_index('datetime', inplace=True)
+        if df.index.tz is None: df.index = df.index.tz_localize('UTC')
+        rename = {}
+        for col in df.columns:
+            low = col.lower()
+            if low == 'open': rename[col] = 'Open'
+            elif low == 'high': rename[col] = 'High'
+            elif low == 'low': rename[col] = 'Low'
+            elif low == 'close': rename[col] = 'Close'
+            elif low == 'volume': rename[col] = 'Volume'
+        if rename: df.rename(columns=rename, inplace=True)
+        for col in ['Open','High','Low','Close']:
+            if col not in df.columns: return None
+        if 'Volume' not in df.columns: df['Volume'] = 0
+        df = df[df['Close'] > 0].dropna(subset=['Open','High','Low','Close'])
+        df = df[df['High'] >= df['Low']]
+        df = df[df.index.weekday < 5]
+        df = df[~((df.index.weekday == 4) & (df.index.hour >= 22))]
+        df.sort_index(inplace=True)
+        return df
+    except Exception as e:
+        print(f"   ⚠️ Load {filepath}: {e}")
+        return None
 
 # ============================================================
 # ALL FEATURE FUNCTIONS
@@ -213,9 +368,8 @@ def extract_features_20(df_slice):
             consecutive_streak(c,5)/5,range_compression(h,l,10),price_acceleration(c)/10]
 
 # ============================================================
-# REGIME DETECTION
+# REGIME + SESSION
 # ============================================================
-
 class RegimeDetector:
     def detect(self, df):
         if len(df) < 100: return {'regime':'NORMAL','confidence':0.5,'parameters':{'atr_sl':1.5,'atr_tp':2.0,'min_conf':0.6,'max_risk':1.0,'preferred_tfs':['5min','30min','1h','2h','4h']}}
@@ -242,275 +396,220 @@ def get_current_session():
     elif 20 <= h < 22: return 'POST_NY'
     return 'UNKNOWN'
 
+def is_active_session(session):
+    return session in ['LONDON_KILLZONE','LONDON','NY_KILLZONE','LONDON_NY_OVERLAP','NY','ASIAN','PRE_LONDON']
+
 # ============================================================
 # SIGNAL GENERATION
 # ============================================================
-
 def get_signal(model, df):
     if len(df) < 201: return None
     features = np.array([extract_features_20(df.iloc[-201:-1])])
     try:
-        probs = model.predict_proba(features)[0]
-        pred = np.argmax(probs)
+        probs = model.predict_proba(features)[0]; pred = np.argmax(probs)
         return {'action':{0:'SELL',1:'HOLD',2:'BUY'}[pred],'confidence':float(probs[pred]),
                 'all_probs':{'SELL':float(probs[0]),'HOLD':float(probs[1]),'BUY':float(probs[2])}}
     except: return None
 
 def analyze_signal(model, df, tf_name, tf_minutes, forward_bars, regime_params):
     bias = get_signal(model, df)
-    if bias is None: return None, [("MODEL","❌","Prediction failed")]
-    
-    h,l,c = df['High'].values,df['Low'].values,df['Close'].values; o = df['Open'].values
-    price = round(c[-1],2); atr_val = calculate_atr(h[-14:],l[-14:],c[-14:]); rsi_val = calculate_rsi(c)
-    
-    fp_df = pd.DataFrame({'Open':o,'High':h,'Low':l,'Close':c})
-    footprint = calculate_footprint(fp_df)
-    sh,sl_sw = find_swing_points(h,l,5)
-    structure,_ = analyze_structure_from_swings(sh,sl_sw)
-    bos = detect_bos_from_swings(sh,sl_sw,structure,c[-1])
-    fvgs = find_fair_value_gaps(h,l); fvg_count = len(fvgs)
-    prem,pos = calculate_premium_discount(h,l,c)
-    t = df.index[-1]; kz = get_kill_zone_score(t.hour,t.minute)
-    
-    filters = []
-    probs_str = f"S:{bias['all_probs']['SELL']:.0%} H:{bias['all_probs']['HOLD']:.0%} B:{bias['all_probs']['BUY']:.0%}"
-    filters.append(("Probs","ℹ️",probs_str))
-    
-    if bias['action'] == 'HOLD':
+    if bias is None: return None, [("MODEL","❌","Failed")]
+    h,l,c = df['High'].values,df['Low'].values,df['Close'].values; o=df['Open'].values
+    price=round(c[-1],2); atr_val=calculate_atr(h[-14:],l[-14:],c[-14:]); rsi_val=calculate_rsi(c)
+    fp_df=pd.DataFrame({'Open':o,'High':h,'Low':l,'Close':c}); footprint=calculate_footprint(fp_df)
+    sh,sl_sw=find_swing_points(h,l,5); structure,_=analyze_structure_from_swings(sh,sl_sw)
+    bos=detect_bos_from_swings(sh,sl_sw,structure,c[-1]); fvgs=find_fair_value_gaps(h,l)
+    prem,pos=calculate_premium_discount(h,l,c); kz=get_kill_zone_score(df.index[-1].hour,df.index[-1].minute)
+    filters=[("Probs","ℹ️",f"S:{bias['all_probs']['SELL']:.0%} H:{bias['all_probs']['HOLD']:.0%} B:{bias['all_probs']['BUY']:.0%}")]
+    if bias['action']=='HOLD':
         filters.append(("HOLD","⚪",f"HOLD ({bias['confidence']:.0%})"))
-        signal = {'timeframe':TF_LABELS.get(tf_name,tf_name),'action':'HOLD','confidence':bias['confidence'],
-                  'price':price,'stop_loss':0,'take_profit':0,'rr_ratio':0,'entry_time':'','exit_time':'',
-                  'rsi':round(rsi_val,1),'atr':round(atr_val,2),'structure':structure,'bos':bos,'fvg_count':fvg_count,
-                  'zone':f"{prem} ({pos:.0f}%)",'footprint':round(footprint,3),'kill_zone':kz,
-                  'pass_count':0,'fail_count':1,'warn_count':0,'filters':filters,'all_probs':bias['all_probs']}
-        return signal, filters
-    
+        sig={'timeframe':TF_LABELS.get(tf_name,tf_name),'action':'HOLD','confidence':bias['confidence'],'price':price,'stop_loss':0,'take_profit':0,'rr_ratio':0,'entry_time':'','exit_time':'','rsi':round(rsi_val,1),'atr':round(atr_val,2),'structure':structure,'bos':bos,'fvg_count':len(fvgs),'zone':f"{prem} ({pos:.0f}%)",'footprint':round(footprint,3),'kill_zone':kz,'pass_count':0,'fail_count':1,'warn_count':0,'filters':filters,'all_probs':bias['all_probs']}
+        return sig, filters
     filters.append(("HOLD","✅",f"Signal={bias['action']}"))
-    fp_status = "✅" if abs(footprint)>=0.1 else "❌"
-    filters.append(("FP-Neutral",fp_status,f"FP={footprint:.3f}"))
-    fp_conflict = (bias['action']=='BUY' and footprint<0.0) or (bias['action']=='SELL' and footprint>0.0)
+    filters.append(("FP-Neutral","✅" if abs(footprint)>=0.1 else "❌",f"FP={footprint:.3f}"))
+    fp_conflict=(bias['action']=='BUY' and footprint<0.0) or (bias['action']=='SELL' and footprint>0.0)
     filters.append(("FP-Conflict","❌" if fp_conflict else "✅","Opposes" if fp_conflict else "Aligned"))
-    struct_conflict = (bias['action']=='BUY' and structure=='bearish') or (bias['action']=='SELL' and structure=='bullish')
+    struct_conflict=(bias['action']=='BUY' and structure=='bearish') or (bias['action']=='SELL' and structure=='bullish')
     filters.append(("Structure","❌" if struct_conflict else "✅" if structure!='ranging' else "⚠️",f"{structure}"))
-    bos_conflict = (bias['action']=='BUY' and bos=='choch_bearish') or (bias['action']=='SELL' and bos=='choch_bullish')
+    bos_conflict=(bias['action']=='BUY' and bos=='choch_bearish') or (bias['action']=='SELL' and bos=='choch_bullish')
     filters.append(("BOS/CHoCH","❌" if bos_conflict else "✅" if bos!='none' else "⚠️",f"{bos}"))
-    zone_conflict = (bias['action']=='BUY' and prem=='premium') or (bias['action']=='SELL' and prem=='discount')
+    zone_conflict=(bias['action']=='BUY' and prem=='premium') or (bias['action']=='SELL' and prem=='discount')
     filters.append(("Zone","❌" if zone_conflict else "✅",f"{prem} ({pos:.0f}%)"))
-    rsi_conflict = (bias['action']=='BUY' and rsi_val>75) or (bias['action']=='SELL' and rsi_val<25)
+    rsi_conflict=(bias['action']=='BUY' and rsi_val>75) or (bias['action']=='SELL' and rsi_val<25)
     filters.append(("RSI","❌" if rsi_conflict else "✅",f"{rsi_val:.1f}"))
     filters.append(("KillZone","✅" if kz>=1 else "⚠️",f"KZ={kz}"))
-    min_c = regime_params.get('min_conf',0.6)
-    conf_ok = bias['confidence']>=min_c
+    min_c=regime_params.get('min_conf',0.6); conf_ok=bias['confidence']>=min_c
     filters.append(("Confidence","✅" if conf_ok else "❌",f"{bias['confidence']:.0%} (min={min_c:.0%})"))
-    tf_ok = tf_name in regime_params.get('preferred_tfs',[])
+    tf_ok=tf_name in regime_params.get('preferred_tfs',[])
     filters.append(("PreferredTF","✅" if tf_ok else "⚠️","Yes" if tf_ok else "No"))
-    sl_m = regime_params.get('atr_sl',1.5); tp_m = regime_params.get('atr_tp',2.0)
+    sl_m=regime_params.get('atr_sl',1.5); tp_m=regime_params.get('atr_tp',2.0)
     if bias['action']=='BUY': sl=round(price-atr_val*sl_m,2); tp=round(price+atr_val*tp_m,2)
     else: sl=round(price+atr_val*sl_m,2); tp=round(price-atr_val*tp_m,2)
-    rr = round(abs(tp-price)/abs(sl-price),2) if sl!=price else 0
+    rr=round(abs(tp-price)/abs(sl-price),2) if sl!=price else 0
     filters.append(("R:R","✅" if rr>=1.2 else "❌",f"1:{rr}"))
-    
-    pc = sum(1 for _,s,_ in filters if s=="✅")
-    wc = sum(1 for _,s,_ in filters if s=="⚠️")
-    fc = sum(1 for _,s,_ in filters if s=="❌")
-    
-    et = datetime.now(timezone.utc)+timedelta(minutes=1)
-    xt = et+timedelta(minutes=tf_minutes*forward_bars)
-    
-    signal = {'timeframe':TF_LABELS.get(tf_name,tf_name),'action':bias['action'],'confidence':bias['confidence'],
-              'price':price,'stop_loss':sl,'take_profit':tp,'rr_ratio':rr,
-              'entry_time':et.strftime('%H:%M UTC'),'exit_time':xt.strftime('%H:%M UTC'),
-              'rsi':round(rsi_val,1),'atr':round(atr_val,2),'structure':structure,'bos':bos,'fvg_count':fvg_count,
-              'zone':f"{prem} ({pos:.0f}%)",'footprint':round(footprint,3),'kill_zone':kz,
-              'pass_count':pc,'fail_count':fc,'warn_count':wc,'filters':filters,'all_probs':bias['all_probs']}
-    return signal, filters
-
-# ============================================================
-# TELEGRAM
-# ============================================================
+    pc=sum(1 for _,s,_ in filters if s=="✅"); wc=sum(1 for _,s,_ in filters if s=="⚠️"); fc=sum(1 for _,s,_ in filters if s=="❌")
+    et=datetime.now(timezone.utc)+timedelta(minutes=1); xt=et+timedelta(minutes=tf_minutes*forward_bars)
+    sig={'timeframe':TF_LABELS.get(tf_name,tf_name),'action':bias['action'],'confidence':bias['confidence'],'price':price,'stop_loss':sl,'take_profit':tp,'rr_ratio':rr,'entry_time':et.strftime('%H:%M UTC'),'exit_time':xt.strftime('%H:%M UTC'),'rsi':round(rsi_val,1),'atr':round(atr_val,2),'structure':structure,'bos':bos,'fvg_count':len(fvgs),'zone':f"{prem} ({pos:.0f}%)",'footprint':round(footprint,3),'kill_zone':kz,'pass_count':pc,'fail_count':fc,'warn_count':wc,'filters':filters,'all_probs':bias['all_probs']}
+    return sig, filters
 
 def send_telegram(msg):
     if not BOT_TOKEN or not CHAT_ID: return
-    try:
-        requests.post(f"https://api.telegram.org/bot{BOT_TOKEN}/sendMessage",
-                     data={'chat_id':CHAT_ID,'text':msg,'parse_mode':'HTML'}, timeout=10)
-    except Exception as e:
-        print(f"⚠️ Telegram: {e}")
+    try: requests.post(f"https://api.telegram.org/bot{BOT_TOKEN}/sendMessage", data={'chat_id':CHAT_ID,'text':msg,'parse_mode':'HTML'}, timeout=10)
+    except: pass
 
 def build_message(all_signals, session, regime_info):
-    now = datetime.now(timezone.utc)
-    msg = f"""<b>🤖 SMC BOT v9.9</b>
+    now=datetime.now(timezone.utc)
+    active_tfs=len([tf for tf in ['5min','30min','1h','2h','4h'] if tf in data and len(data[tf])>=201])
+    msg=f"""<b>🤖 SMC BOT v9.9</b>
 🕐 {now.strftime('%H:%M')} UTC | {session}
 🔄 Regime: {regime_info.get('regime','?')}
-🛡️ Filters: Active
+📊 Active: {active_tfs}/5 | API: {api_call_count}/{MAX_API_CALLS_PER_DAY}
 ━━━━━━━━━━━━━━━━━━━━━"""
-    
-    if not all_signals: return msg + "\n\n⚪ No predictions"
-    
-    emoji = {'BUY':'🟢','SELL':'🔴','HOLD':'⚪'}
+    if not all_signals: return msg+"\n\n⚪ No predictions"
+    emoji={'BUY':'🟢','SELL':'🔴','HOLD':'⚪'}
     for tf_name in ['5min','30min','1h','2h','4h']:
-        result = all_signals.get(tf_name)
-        if not result: continue
-        signal, filters = result
-        e = emoji.get(signal['action'],'🟡')
-        
-        if signal['action'] == 'HOLD': verdict = "⚪ HOLD"
-        elif signal['fail_count'] == 0: verdict = "✅ PASS"
-        else: verdict = f"❌ BLOCKED({signal['fail_count']})"
-        
-        msg += f"\n\n{e} <b>{signal['timeframe']}</b> → {signal['action']} ({signal['confidence']:.0%}) — {verdict}"
-        msg += f"\n   Probs: {signal.get('all_probs',{}).get('SELL',0):.0%}S/{signal.get('all_probs',{}).get('HOLD',0):.0%}H/{signal.get('all_probs',{}).get('BUY',0):.0%}B"
-        if signal['action'] != 'HOLD':
-            msg += f"\n   💰 ${signal['price']} | SL:${signal['stop_loss']} | TP:${signal['take_profit']} | R:R 1:{signal['rr_ratio']}"
-        msg += f"\n   ─────────────────────────"
-        for fn, fs, fd in filters:
-            msg += f"\n   {fs} {fn:<15s}: {fd}"
-    
-    actions = [all_signals[tf][0]['action'] for tf in all_signals if all_signals[tf]]
-    buys = actions.count('BUY'); sells = actions.count('SELL'); holds = actions.count('HOLD')
-    msg += f"\n\n━━━━━━━━━━━━━━━━━━━━━\n📊 BUY:{buys} SELL:{sells} HOLD:{holds}"
+        result=all_signals.get(tf_name)
+        if not result: msg+=f"\n\n⚠️ <b>{TF_LABELS.get(tf_name,tf_name)}</b>: Accumulating..."; continue
+        sig,filters=result; e=emoji.get(sig['action'],'🟡')
+        verdict="⚪ HOLD" if sig['action']=='HOLD' else ("✅ PASS" if sig['fail_count']==0 else f"❌ BLOCKED({sig['fail_count']})")
+        msg+=f"\n\n{e} <b>{sig['timeframe']}</b> → {sig['action']} ({sig['confidence']:.0%}) — {verdict}"
+        msg+=f"\n   Probs: {sig.get('all_probs',{}).get('SELL',0):.0%}S/{sig.get('all_probs',{}).get('HOLD',0):.0%}H/{sig.get('all_probs',{}).get('BUY',0):.0%}B"
+        if sig['action']!='HOLD': msg+=f"\n   💰 ${sig['price']} | SL:${sig['stop_loss']} | TP:${sig['take_profit']} | R:R 1:{sig['rr_ratio']}"
+        msg+="\n   ─────────────────────────"
+        for fn,fs,fd in filters: msg+=f"\n   {fs} {fn:<15s}: {fd}"
+    actions=[all_signals[tf][0]['action'] for tf in all_signals if all_signals[tf]]
+    buys=actions.count('BUY'); sells=actions.count('SELL'); holds=actions.count('HOLD')
+    msg+=f"\n\n━━━━━━━━━━━━━━━━━━━━━\n📊 BUY:{buys} SELL:{sells} HOLD:{holds}"
     return msg
 
-# ============================================================
-# DATA FETCH
-# ============================================================
-
-def fetch_5min(outputsize=500):
-    if not TWELVEDATA_API_KEY: return None
+def fetch_5min(outputsize=5000):
+    if not TWELVEDATA_API_KEY or not can_call_api(): return None
     try:
-        r = requests.get("https://api.twelvedata.com/time_series",
-                        params={'symbol':'XAU/USD','interval':'5min','outputsize':outputsize,'timezone':'UTC','apikey':TWELVEDATA_API_KEY}, timeout=15)
-        if r.status_code == 200:
-            data = r.json()
-            if 'values' in data and len(data['values']) > 0:
-                candles = [{'datetime':pd.to_datetime(b['datetime']).tz_localize('UTC'),
-                           'Open':float(b['open']),'High':float(b['high']),
-                           'Low':float(b['low']),'Close':float(b['close']),'Volume':0} for b in data['values']]
-                df = pd.DataFrame(candles).set_index('datetime').sort_index()
-                df = df[df.index.weekday<5]; df = df[~((df.index.weekday==4)&(df.index.hour>=22))]
+        r=requests.get("https://api.twelvedata.com/time_series", params={'symbol':'XAU/USD','interval':'5min','outputsize':outputsize,'timezone':'UTC','apikey':TWELVEDATA_API_KEY}, timeout=15)
+        track_api_call()
+        if r.status_code==200:
+            d=r.json()
+            if 'values' in d and len(d['values'])>0:
+                candles=[{'datetime':pd.to_datetime(b['datetime']).tz_localize('UTC'),'Open':float(b['open']),'High':float(b['high']),'Low':float(b['low']),'Close':float(b['close']),'Volume':0} for b in d['values']]
+                df=pd.DataFrame(candles).set_index('datetime').sort_index()
+                df=df[df.index.weekday<5]; df=df[~((df.index.weekday==4)&(df.index.hour>=22))]
                 return df
         return None
     except: return None
 
 def generate_tfs(df5):
     if df5 is None or len(df5)==0: return {}
-    data = {'5min':df5}
-    df30 = df5.resample('30min',label='right',closed='right').agg({'Open':'first','High':'max','Low':'min','Close':'last','Volume':'sum'}).dropna()
-    data['30min'] = df30
-    df1h = df5.resample('1h',label='right',closed='right').agg({'Open':'first','High':'max','Low':'min','Close':'last','Volume':'sum'}).dropna()
-    data['1h'] = df1h
-    df2h = df1h.resample('2h',label='right',closed='right').agg({'Open':'first','High':'max','Low':'min','Close':'last','Volume':'sum'}).dropna()
-    data['2h'] = df2h
-    df4h = df1h.resample('4h',label='right',closed='right').agg({'Open':'first','High':'max','Low':'min','Close':'last','Volume':'sum'}).dropna()
-    data['4h'] = df4h
-    return data
+    result={'5min':df5}
+    result['30min']=df5.resample('30min',label='right',closed='right').agg({'Open':'first','High':'max','Low':'min','Close':'last','Volume':'sum'}).dropna()
+    result['1h']=df5.resample('1h',label='right',closed='right').agg({'Open':'first','High':'max','Low':'min','Close':'last','Volume':'sum'}).dropna()
+    result['2h']=result['1h'].resample('2h',label='right',closed='right').agg({'Open':'first','High':'max','Low':'min','Close':'last','Volume':'sum'}).dropna()
+    result['4h']=result['1h'].resample('4h',label='right',closed='right').agg({'Open':'first','High':'max','Low':'min','Close':'last','Volume':'sum'}).dropna()
+    return result
 
 def candle_just_closed(tf_minutes):
-    now = datetime.now(timezone.utc)
+    now=datetime.now(timezone.utc)
     if now.weekday()>=5: return False
     if now.weekday()==4 and now.hour>=22: return False
-    return (now.minute%tf_minutes)*60+now.second < 45
-
-# ============================================================
-# KEEP-ALIVE
-# ============================================================
+    return (now.minute%tf_minutes)*60+now.second<45
 
 def keep_alive():
+    space_url=os.environ.get('SPACE_URL','https://kulusia-trade-bot.hf.space')
     while True:
         time.sleep(240)
-        try: requests.get("https://kulusia-trade.hf.space/health", timeout=5)
+        try: requests.get(f"{space_url}/health",timeout=5)
         except: pass
 
 # ============================================================
 # MAIN BOT LOOP
 # ============================================================
-
 def run_bot():
+    global data, api_call_count
     print("\n🔄 Bot starting...")
-    if not models:
-        print("❌ No models loaded — cannot start")
-        return
+    if not models: print("❌ No models"); return
+    
+    # STEP 1: Check uploaded CSV and update it
+    print("\n📂 Checking uploaded CSV...")
+    csv_exists = os.path.exists(CSV_5MIN_LIVE)
+    last_bar = get_csv_last_date(CSV_5MIN_LIVE)
+    
+    if csv_exists:
+        print(f"   ✅ CSV found: {last_bar}")
+        added = update_csv_from_api(CSV_5MIN_LIVE)
+        if added > 0:
+            print(f"   📡 Updated CSV with +{added} new bars")
+    else:
+        print(f"   ⚠️ No CSV found — fetching fresh data...")
+    
+    # STEP 2: Load data from CSV
+    data = {}
+    df5 = load_csv_data(CSV_5MIN_LIVE)
+    if df5 is not None and len(df5) > 0:
+        data = generate_tfs(df5)
+        save_all_csvs()
+        print(f"   ✅ Loaded: 5min={len(data.get('5min',[])):,} bars")
     
     rd = RegimeDetector()
     last_fetch = datetime.now(timezone.utc) - timedelta(minutes=99)
     last_regime = datetime.now(timezone.utc) - timedelta(minutes=10)
+    last_save = datetime.now(timezone.utc)
     signal_count = 0
-    data = {}
     
-    send_telegram(f"🤖 <b>SMC Bot v9.9 LIVE on HF!</b>\n📊 {len(models)} models\n🔍 Monitoring XAU/USD")
+    active_tfs = len([tf for tf in ['5min','30min','1h','2h','4h'] if tf in data and len(data[tf])>=201])
+    print(f"\n🔍 Active: {active_tfs}/5 TFs\n")
+    send_telegram(f"🤖 <b>SMC Bot v9.9 LIVE!</b>\n📊 {len(models)} models | {active_tfs}/5 TFs\n📂 CSV: {len(data.get('5min',[])):,} bars\n🔍 Monitoring XAU/USD")
     
     while True:
         try:
-            now = datetime.now(timezone.utc)
-            session = get_current_session()
-            
-            if 'WEEKEND' in session:
-                time.sleep(300); continue
+            now = datetime.now(timezone.utc); session = get_current_session()
+            if 'WEEKEND' in session: time.sleep(300); continue
             
-            any_fetched = False
+            active = is_active_session(session)
             seconds_since = (now - last_fetch).total_seconds()
+            fetch_interval = 285 if active else 885
             
-            if seconds_since >= 285 and candle_just_closed(5):
-                print(f"⏰ {now.strftime('%H:%M')} — fetching...")
-                nd = fetch_5min(500)
-                if nd is not None and len(nd) > 0:
-                    if '5min' in data:
-                        new_bars = nd[~nd.index.isin(data['5min'].index)]
-                        if len(new_bars) > 0:
-                            data['5min'] = pd.concat([data['5min'], new_bars])
-                            data['5min'] = data['5min'][~data['5min'].index.duplicated(keep='last')]
-                            data['5min'].sort_index(inplace=True)
-                            print(f"   ✅ +{len(new_bars)} bars | Total: {len(data['5min']):,}")
-                            last_fetch = now; any_fetched = True
-                    else:
-                        data['5min'] = nd
-                        last_fetch = now; any_fetched = True
-                        print(f"   ✅ Initial: {len(nd):,} bars")
+            if seconds_since >= fetch_interval and candle_just_closed(5 if active else 15):
+                if can_call_api():
+                    print(f"⏰ {now.strftime('%H:%M')} — fetching...")
+                    nd = fetch_5min(3)
+                    if nd is not None and len(nd) > 0:
+                        if '5min' in data:
+                            new_bars = nd[~nd.index.isin(data['5min'].index)]
+                            if len(new_bars) > 0:
+                                data['5min'] = pd.concat([data['5min'], new_bars])
+                                data['5min'] = data['5min'][~data['5min'].index.duplicated(keep='last')]
+                                data['5min'].sort_index(inplace=True)
+                                print(f"   ✅ +{len(new_bars)} | Total: {len(data['5min']):,}")
+                                last_fetch = now
+                                data.update(generate_tfs(data['5min']))
+                                save_all_csvs(); last_save = now
+                                
+                                if '1h' in data and len(data['1h']) >= 100: ri = rd.detect(data['1h']); last_regime = now
+                                else: ri = {'regime':'NORMAL','confidence':0.5,'parameters':{'atr_sl':1.5,'atr_tp':2.0,'min_conf':0.6,'max_risk':1.0,'preferred_tfs':['5min','30min','1h','2h','4h']}}
+                                
+                                all_signals = {}
+                                for tf_name in TIMEFRAMES:
+                                    if tf_name in models and tf_name in data and len(data[tf_name]) >= 201:
+                                        sig, filters = analyze_signal(models[tf_name], data[tf_name], tf_name, TIMEFRAMES[tf_name]['minutes'], TIMEFRAMES[tf_name]['fwd'], ri.get('parameters',{}))
+                                        if sig: all_signals[tf_name] = (sig, filters)
+                                
+                                if all_signals:
+                                    signal_count += 1
+                                    send_telegram(build_message(all_signals, session, ri))
+                                    print(f"📝 Signal #{signal_count} → Telegram")
+                        else:
+                            data['5min'] = nd; last_fetch = now
+                            data.update(generate_tfs(data['5min']))
+                            save_all_csvs()
             
-            time_since_regime = (now - last_regime).total_seconds()
-            
-            if any_fetched or time_since_regime >= 300:
-                if any_fetched and '5min' in data:
-                    data = generate_tfs(data['5min'])
-                
-                if '1h' in data and len(data['1h']) >= 100:
-                    ri = rd.detect(data['1h']); last_regime = now
-                else:
-                    ri = {'regime':'NORMAL','confidence':0.5,'parameters':{'atr_sl':1.5,'atr_tp':2.0,'min_conf':0.6,'max_risk':1.0,'preferred_tfs':['5min','30min','1h','2h','4h']}}
-                
-                all_signals = {}
-                for tf_name in TIMEFRAMES:
-                    if tf_name in models and tf_name in data and len(data[tf_name]) >= 201:
-                        sig, filters = analyze_signal(
-                            models[tf_name], data[tf_name], tf_name,
-                            TIMEFRAMES[tf_name]['minutes'], TIMEFRAMES[tf_name]['fwd'],
-                            ri.get('parameters',{})
-                        )
-                        if sig: all_signals[tf_name] = (sig, filters)
-                
-                if all_signals:
-                    signal_count += 1
-                    msg = build_message(all_signals, session, ri)
-                    send_telegram(msg)
-                    print(f"📝 Signal #{signal_count} → Telegram")
-                    
-                    for tf_name, (sig, _) in all_signals.items():
-                        status = "✅" if sig['fail_count']==0 else f"❌({sig['fail_count']})"
-                        print(f"   {sig['timeframe']}: {sig['action']} {sig['confidence']:.0%} | {status}")
+            if (now - last_save).total_seconds() >= 3600:
+                save_all_csvs(); last_save = now
             
             time.sleep(10)
-            
         except Exception as e:
-            print(f"⚠️ Error: {e}")
-            time.sleep(60)
+            print(f"⚠️ Error: {e}"); time.sleep(60)
 
-# ============================================================
-# START
-# ============================================================
 threading.Thread(target=keep_alive, daemon=True).start()
-print("💓 Keep-alive active")
 threading.Thread(target=run_bot, daemon=True).start()
 
 if __name__ == '__main__':
-    port = int(os.environ.get('PORT', 7860))
-    app.run(host='0.0.0.0', port=port)
+    app.run(host='0.0.0.0', port=int(os.environ.get('PORT', 7860)))