Create app.py

app.py

@@ -0,0 +1,516 @@
+#!/usr/bin/env python3
+"""
+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
+"""
+
+import os, numpy as np, pandas as pd, warnings, requests, time, threading
+from datetime import datetime, timedelta, timezone
+from flask import Flask
+warnings.filterwarnings("ignore")
+import xgboost as xgb, joblib
+
+# ============================================================
+# FLASK APP
+# ============================================================
+app = Flask(__name__)
+
+@app.route('/')
+def home():
+    return "🤖 SMC AI Bot v9.9 — Live on Hugging Face"
+
+@app.route('/health')
+def health():
+    return {"status": "alive", "time": str(datetime.now(timezone.utc)), "models": len(models)}
+
+# ============================================================
+# LOAD SECRETS
+# ============================================================
+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'}")
+
+# ============================================================
+# LOAD MODELS
+# ============================================================
+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',
+}
+
+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}")
+    else:
+        print(f"   ❌ {name.upper()}: File not found")
+
+print(f"\n✅ {len(models)}/5 models loaded")
+
+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'}
+
+# ============================================================
+# ALL FEATURE FUNCTIONS
+# ============================================================
+
+def calculate_atr(high, low, close, period=14):
+    pc = np.zeros_like(close); pc[1:] = close[:-1]; pc[0] = close[0]
+    tr = np.maximum(high-low, np.maximum(np.abs(high-pc), np.abs(low-pc)))
+    av = pd.Series(tr).rolling(period, min_periods=1).mean().values[-1]
+    return av if not np.isnan(av) else (high[-1]-low[-1])
+
+def calculate_rsi(close, period=14):
+    if len(close) < period+1: return 50
+    d = pd.Series(close).diff(); g = d.where(d>0,0).rolling(period,min_periods=1).mean()
+    lo = (-d.where(d<0,0)).rolling(period,min_periods=1).mean(); lv = lo.values[-1]
+    if lv == 0: return 50
+    return 100-(100/(1+g.values[-1]/lv))
+
+def calculate_ema(close, period=20):
+    return pd.Series(close).ewm(span=period, adjust=False).mean().values[-1]
+
+def find_swing_points(high, low, lookback=5):
+    sh, sl = [], []
+    for i in range(lookback, len(high)-lookback):
+        if high[i]==max(high[i-lookback:i+lookback+1]): sh.append({'index':i,'price':high[i]})
+        if low[i]==min(low[i-lookback:i+lookback+1]): sl.append({'index':i,'price':low[i]})
+    return sh, sl
+
+def analyze_structure_from_swings(sh, sl):
+    if len(sh)<2 or len(sl)<2: return 'neutral',0
+    hc = (sh[-1]['price']-sh[-2]['price'])/sh[-2]['price']*100 if sh[-2]['price']!=0 else 0
+    lc = (sl[-1]['price']-sl[-2]['price'])/sl[-2]['price']*100 if sl[-2]['price']!=0 else 0
+    if sh[-1]['price']>sh[-2]['price'] and sl[-1]['price']>sl[-2]['price']: return 'bullish',round(hc+lc,2)
+    elif sh[-1]['price']<sh[-2]['price'] and sl[-1]['price']<sl[-2]['price']: return 'bearish',round(hc+lc,2)
+    return 'ranging',0
+
+def detect_bos_from_swings(sh, sl, s, cp):
+    if len(sh)<2 or len(sl)<2: return 'none'
+    if s=='bullish':
+        if cp>sh[-1]['price']: return 'bos_bullish'
+        if cp<sl[-1]['price']: return 'choch_bearish'
+    elif s=='bearish':
+        if cp<sl[-1]['price']: return 'bos_bearish'
+        if cp>sh[-1]['price']: return 'choch_bullish'
+    return 'none'
+
+def find_fair_value_gaps(high, low):
+    lb = min(20, len(high)-4); fvgs = []
+    for i in range(len(high)-3, max(len(high)-lb,0), -1):
+        if high[i]<low[i+2]: fvgs.append({'type':'bullish','top':round(low[i+2],2),'bottom':round(high[i],2)})
+        elif low[i]>high[i+2]: fvgs.append({'type':'bearish','top':round(high[i+2],2),'bottom':round(low[i],2)})
+    return fvgs
+
+def calculate_premium_discount(high, low, close):
+    lb = min(50, len(high)); rh, rl = np.max(high[-lb:]), np.min(low[-lb:]); rt = rh-rl
+    if rt==0: return 'equilibrium',50
+    pct = (close[-1]-rl)/rt*100
+    if pct>=75: return 'premium',round(pct,1)
+    elif pct<=25: return 'discount',round(pct,1)
+    return 'equilibrium',round(pct,1)
+
+def get_kill_zone_score(hour, minute):
+    if (8,0)<=(hour,minute)<=(9,30): return 2
+    elif (13,0)<=(hour,minute)<=(14,30): return 2
+    elif (16,0)<=(hour,minute)<=(17,0): return 2
+    elif (9,30)<=(hour,minute)<=(12,0): return 1
+    elif (14,30)<=(hour,minute)<=(16,0): return 1
+    elif (2,0)<=(hour,minute)<=(4,0): return 1
+    return 0
+
+def calculate_footprint(df_slice):
+    o, h, l, c = df_slice['Open'].values, df_slice['High'].values, df_slice['Low'].values, df_slice['Close'].values
+    if len(c)<10: return 0
+    bp, sp = 0, 0
+    for i in range(-8, 0):
+        body = abs(c[i]-o[i]); tr = h[i]-l[i]
+        if tr==0: continue
+        eff = body/tr; rw = 1+(8+i)/8
+        if c[i]>o[i]: bp += eff*((c[i]-l[i])/tr)*rw
+        elif c[i]<o[i]: sp += eff*((h[i]-c[i])/tr)*rw
+    total = bp+sp; delta = (bp-sp)/total if total>0 else 0
+    lr = h[-1]-l[-1]; absorption = 0
+    if lr>0:
+        uw = h[-1]-max(c[-1],o[-1]); lw = min(c[-1],o[-1])-l[-1]
+        if lw>lr*0.4 and c[-1]>o[-1]: absorption = min(lw/lr,1.0)
+        elif uw>lr*0.4 and c[-1]<o[-1]: absorption = -min(uw/lr,1.0)
+    pace_score = 0
+    if len(c)>=7:
+        rm, om = c[-1]-c[-4], c[-4]-c[-7]; avg = (abs(rm)+abs(om))/2
+        if avg>0:
+            pace = (abs(rm)-abs(om))/avg
+            if rm>0 and pace>0: pace_score = min(pace,1.0)
+            elif rm>0 and pace<0: pace_score = -min(abs(pace),1.0)
+            elif rm<0 and pace>0: pace_score = -min(pace,1.0)
+            elif rm<0 and pace<0: pace_score = min(abs(pace),1.0)
+    return np.clip(delta*0.5+absorption*0.3+pace_score*0.2, -1, 1)
+
+def candle_body_ratio(o,h,l,c): return abs(c[-1]-o[-1])/(h[-1]-l[-1]) if h[-1]!=l[-1] else 0
+def wick_ratio(o,h,l,c):
+    tr = h[-1]-l[-1]
+    return ((h[-1]-max(c[-1],o[-1]))-(min(c[-1],o[-1])-l[-1]))/tr if tr!=0 else 0
+def momentum(c,p=5): return (c[-1]-c[-p-1])/c[-p-1]*100 if len(c)>=p+1 and c[-p-1]!=0 else 0
+def volatility_ratio(h,l,c,sp=5,lp=20):
+    pc=np.zeros_like(c);pc[1:]=c[:-1];pc[0]=c[0]
+    tr=np.maximum(h-l,np.maximum(np.abs(h-pc),np.abs(l-pc)))
+    sa=pd.Series(tr).rolling(sp,min_periods=1).mean().values[-1]
+    la=pd.Series(tr).rolling(lp,min_periods=1).mean().values[-1]
+    return sa/la if not pd.isna(la) and la!=0 else 1.0
+def close_location(h,l,c): return (c[-1]-l[-1])/(h[-1]-l[-1]) if h[-1]!=l[-1] else 0.5
+def gap_detection(o,c): return (o[-1]-c[-2])/c[-2]*100 if len(c)>=2 and c[-2]!=0 else 0
+def consecutive_streak(c,p=5):
+    s=0
+    for i in range(-p,-1):
+        if c[i]>c[i-1]: s+=1
+        elif c[i]<c[i-1]: s-=1
+    return s
+def range_compression(h,l,p=10):
+    rr=np.max(h[-p:])-np.min(l[-p:]); o_r=np.max(h[-p*2:-p])-np.min(l[-p*2:-p])
+    return rr/o_r if o_r!=0 else 1.0
+def price_acceleration(c): return (c[-1]-c[-3])-(c[-3]-c[-5]) if len(c)>=5 else 0
+
+def extract_features_20(df_slice):
+    h,l,c=df_slice['High'].values,df_slice['Low'].values,df_slice['Close'].values; o=df_slice['Open'].values
+    atr=calculate_atr(h,l,c);rsi=calculate_rsi(c)
+    trend=(c[-1]-calculate_ema(c))/atr if atr>0 else 0
+    rh=np.max(h[-50:]) if len(h)>=50 else np.max(h);rl=np.min(l[-50:]) if len(l)>=50 else np.min(l)
+    price_pos=(c[-1]-rl)/(rh-rl) if rh!=rl else 0.5
+    t=df_slice.index[-1];kz=get_kill_zone_score(t.hour,t.minute);fp=calculate_footprint(df_slice)
+    sh,sl=find_swing_points(h,l,5);structure,score=analyze_structure_from_swings(sh,sl)
+    sn=1 if structure=='bullish' else (-1 if structure=='bearish' else 0)
+    bos=detect_bos_from_swings(sh,sl,structure,c[-1])
+    bn=1 if 'bullish' in bos else (-1 if 'bearish' in bos else 0)
+    fvgs=find_fair_value_gaps(h,l);fn=0
+    if fvgs: cur=c[-1];n=fvgs[0];fn=1 if n['type']=='bullish' and cur>n['bottom'] else (-1 if n['type']=='bearish' and cur<n['top'] else 0)
+    pd_sc,pos=calculate_premium_discount(h,l,c);zn=1 if pd_sc=='discount' else (-1 if pd_sc=='premium' else 0)
+    return [rsi,trend,price_pos,kz/2,fp,sn,score/10 if score else 0,bn,fn,zn,pos/100,
+            candle_body_ratio(o,h,l,c),wick_ratio(o,h,l,c),momentum(c,5)/10,
+            volatility_ratio(h,l,c),close_location(h,l,c),gap_detection(o,c)/10,
+            consecutive_streak(c,5)/5,range_compression(h,l,10),price_acceleration(c)/10]
+
+# ============================================================
+# REGIME DETECTION
+# ============================================================
+
+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']}}
+        h,l,c = df['High'].values[-100:], df['Low'].values[-100:], df['Close'].values[-100:]
+        rng = h-l; ca = np.mean(rng[-14:]); la = np.mean(rng); vr = ca/la if la>0 else 1.0
+        s20 = np.mean(c[-20:]); s50 = np.mean(c[-50:]); td = 'BULLISH' if s20>s50 else 'BEARISH'
+        if vr > 1.5: reg = f'HIGH_VOL_{td}'; cf=0.7; pr={'atr_sl':2.0,'atr_tp':3.0,'min_conf':0.65,'max_risk':0.75,'preferred_tfs':['1h','2h','4h']}
+        elif vr < 0.6: reg = 'LOW_VOL_COMPRESSION'; cf=0.75; pr={'atr_sl':0.8,'atr_tp':3.0,'min_conf':0.7,'max_risk':0.5,'preferred_tfs':['5min','30min']}
+        else: reg = f'NORMAL_{td}'; cf=0.6; pr={'atr_sl':1.5,'atr_tp':2.0,'min_conf':0.6,'max_risk':1.0,'preferred_tfs':['5min','30min','1h','2h','4h']}
+        return {'regime':reg,'confidence':cf,'parameters':pr}
+
+def get_current_session():
+    now = datetime.now(timezone.utc); h = now.hour; wd = now.weekday()
+    if wd >= 5: return 'WEEKEND'
+    if wd == 4 and h >= 22: return 'WEEKEND_CLOSE'
+    if 22 <= h or h < 2: return 'ASIAN_LATE'
+    elif 2 <= h < 6: return 'ASIAN'
+    elif 6 <= h < 8: return 'PRE_LONDON'
+    elif 8 <= h < 10: return 'LONDON_KILLZONE'
+    elif 10 <= h < 13: return 'LONDON'
+    elif 13 <= h < 15: return 'NY_KILLZONE'
+    elif 15 <= h < 16: return 'LONDON_NY_OVERLAP'
+    elif 16 <= h < 20: return 'NY'
+    elif 20 <= h < 22: return 'POST_NY'
+    return 'UNKNOWN'
+
+# ============================================================
+# 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)
+        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':
+        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
+    
+    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-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')
+    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')
+    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')
+    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)
+    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
+    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',[])
+    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)
+    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
+    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
+# ============================================================
+
+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}")
+
+def build_message(all_signals, session, regime_info):
+    now = datetime.now(timezone.utc)
+    msg = f"""<b>🤖 SMC BOT v9.9</b>
+🕐 {now.strftime('%H:%M')} UTC | {session}
+🔄 Regime: {regime_info.get('regime','?')}
+🛡️ Filters: Active
+━━━━━━━━━━━━━━━━━━━━━"""
+    
+    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}"
+    return msg
+
+# ============================================================
+# DATA FETCH
+# ============================================================
+
+def fetch_5min(outputsize=500):
+    if not TWELVEDATA_API_KEY: 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))]
+                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
+
+def candle_just_closed(tf_minutes):
+    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
+# ============================================================
+
+def keep_alive():
+    while True:
+        time.sleep(240)
+        try: requests.get("https://kulusia-trade.hf.space/health", timeout=5)
+        except: pass
+
+# ============================================================
+# MAIN BOT LOOP
+# ============================================================
+
+def run_bot():
+    print("\n🔄 Bot starting...")
+    if not models:
+        print("❌ No models loaded — cannot start")
+        return
+    
+    rd = RegimeDetector()
+    last_fetch = datetime.now(timezone.utc) - timedelta(minutes=99)
+    last_regime = datetime.now(timezone.utc) - timedelta(minutes=10)
+    signal_count = 0
+    data = {}
+    
+    send_telegram(f"🤖 <b>SMC Bot v9.9 LIVE on HF!</b>\n📊 {len(models)} models\n🔍 Monitoring XAU/USD")
+    
+    while True:
+        try:
+            now = datetime.now(timezone.utc)
+            session = get_current_session()
+            
+            if 'WEEKEND' in session:
+                time.sleep(300); continue
+            
+            any_fetched = False
+            seconds_since = (now - last_fetch).total_seconds()
+            
+            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")
+            
+            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}")
+            
+            time.sleep(10)
+            
+        except Exception as e:
+            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)