Upload complete V3.1 app.py with all 12 tabs

app.py

@@ -1,46 +1,26 @@
-"""AlphaForge V3.1 - Institutional Quant Trading Platform
-
-Jane Street / Two Sigma / Citadel level quant infrastructure.
-10 modules: Backtester, Portfolio Optimizer, Options, Pairs, Crypto Arbitrage,
-Risk Engine, Sentiment, Macro, Research Desk, Technical Analysis.
-
-Bloomberg Terminal aesthetic: black + orange + green + cyan.
-Powered by K2 Think V2 (MBZUAI) for AI analysis.
-"""
+"""AlphaForge V3.1 - Institutional Quant Trading Platform"""
 import os, json, warnings, math, random, time, hashlib, threading
-from datetime import datetime, timedelta
+from datetime import datetime
 warnings.filterwarnings('ignore')
+import gradio as gr
+import requests
+import yfinance as yf
+import pandas as pd
+import numpy as np
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
 
-try:
-    import gradio as gr
-    import requests
-    import yfinance as yf
-    import pandas as pd
-    import numpy as np
-    import plotly.graph_objects as go
-    from plotly.subplots import make_subplots
-    PLOTLY_OK = True
-except ImportError as e:
-    raise ImportError(f"Missing package: {e}")
-
-# =============================================================================
-# CONFIG
-# =============================================================================
 K2_API_KEY = os.environ.get("K2_API_KEY", "")
 K2_BASE_URL = "https://api.k2think.ai/v1/chat/completions"
 K2_MODEL = "MBZUAI-IFM/K2-Think-v2"
 
-# =============================================================================
-# K2 THINK V2 CLIENT
-# =============================================================================
 class K2ThinkClient:
     def __init__(self):
         self.api_key = K2_API_KEY
         self.available = bool(self.api_key) and len(self.api_key) > 10
-    
     def chat(self, messages, temperature=0.3, max_tokens=4096):
         if not self.available:
-            return "⚠️ K2 Think V2 API Not Configured. Add K2_API_KEY in Space Settings > Repository Secrets. All quant features work without it!"
+            return "K2 Think V2 API Not Configured. Add K2_API_KEY in Space Settings > Repository Secrets. All quant features work without it!"
         payload = {"model": K2_MODEL, "messages": messages, "temperature": temperature, "max_tokens": max_tokens, "stream": False}
         headers = {"accept": "application/json", "Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json"}
         try:
@@ -49,77 +29,43 @@ class K2ThinkClient:
             j = r.json()
             return j['choices'][0]['message']['content'] if 'choices' in j and j['choices'] else str(j)[:400]
         except requests.exceptions.Timeout:
-            return "⏱️ Timeout. API under high load."
+            return "Timeout. API under high load."
         except requests.exceptions.HTTPError as e:
-            return f"🔐 Auth/Rate Error ({e.response.status_code})" if e.response else str(e)[:200]
+            return f"Auth/Rate Error ({e.response.status_code})" if e.response else str(e)[:200]
         except Exception as e:
-            return f"🔴 Error: {str(e)[:300]}"
+            return f"Error: {str(e)[:300]}"
 
-# =============================================================================
-# FALLBACK SYNTHETIC DATA ENGINE (seeded, realistic, deterministic)
-# =============================================================================
 def _ticker_seed(ticker):
-    """Deterministic seed from ticker name + current date so data is realistic 
-    but consistent across reloads on the same day."""
     d = datetime.utcnow().strftime("%Y%m%d")
     return int(hashlib.md5(f"{ticker.upper()}:{d}".encode()).hexdigest(), 16) % (2**31)
 
 def generate_synthetic_data(ticker, period="1y", interval="1d"):
-    """Generate realistic OHLCV data when yfinance is rate-limited.
-    Volatility, trends, and volume patterns are calibrated to real market regimes."""
     seed = _ticker_seed(ticker)
     rng = np.random.RandomState(seed)
-    
-    # Determine number of bars
     days_map = {"1mo": 21, "3mo": 63, "6mo": 126, "1y": 252, "2y": 504, "5y": 1260}
     n = days_map.get(period, 252)
-    
-    # Regime parameters (seeded from ticker name for consistency)
-    vol = rng.uniform(0.15, 0.45)  # annualized volatility
-    drift = rng.uniform(-0.05, 0.15)  # annual drift
+    vol = rng.uniform(0.15, 0.45)
+    drift = rng.uniform(-0.05, 0.15)
     base_price = rng.uniform(20, 500)
-    
-    # Generate returns
     dt = 1/252
     ret = rng.normal(drift*dt, vol*np.sqrt(dt), n)
     price = base_price * np.exp(np.cumsum(ret))
-    
-    # Generate OHLC from close
-    intraday_vol = vol * np.sqrt(dt) * 0.6
-    high = price * (1 + np.abs(rng.normal(0, intraday_vol, n)))
-    low = price * (1 - np.abs(rng.normal(0, intraday_vol, n)))
-    # Ensure logical ordering
+    iv = vol * np.sqrt(dt) * 0.6
+    high = price * (1 + np.abs(rng.normal(0, iv, n)))
+    low = price * (1 - np.abs(rng.normal(0, iv, n)))
     close = price
-    open_p = close * (1 + rng.normal(0, intraday_vol*0.5, n))
-    
-    # Fix any OHLC inversions
+    open_p = close * (1 + rng.normal(0, iv*0.5, n))
     for i in range(n):
         vals = sorted([open_p[i], high[i], low[i], close[i]])
         low[i], high[i] = vals[0], vals[3]
         open_p[i], close[i] = vals[1], vals[2]
-    
-    # Volume with realistic patterns (higher on big moves)
-    base_vol = rng.uniform(1e6, 50e6)
-    vol_spike = 1 + 3 * np.abs(ret) / (np.std(ret) + 1e-10)
-    volume = base_vol * vol_spike * rng.uniform(0.5, 1.5, n)
-    
-    # Build date index
+    bv = rng.uniform(1e6, 50e6)
+    vs = 1 + 3 * np.abs(ret) / (np.std(ret) + 1e-10)
+    volume = bv * vs * rng.uniform(0.5, 1.5, n)
     end = datetime.utcnow()
     idx = pd.bdate_range(end=end, periods=n)
-    
-    df = pd.DataFrame({
-        'Open': open_p,
-        'High': high,
-        'Low': low,
-        'Close': close,
-        'Volume': volume
-    }, index=idx)
-    
-    return df
+    return pd.DataFrame({'Open': open_p, 'High': high, 'Low': low, 'Close': close, 'Volume': volume}, index=idx)
 
-# =============================================================================
-# MARKET DATA (with synthetic fallback for HF Spaces shared-IP rate limits)
-# =============================================================================
 MARKETS = {
     "US Equities": {"suffix": "", "ex": "AAPL, TSLA, NVDA, SPY, QQQ"},
     "EU Equities": {"suffix": ".PA", "ex": "AIR.PA, SAN.PA, TTE.PA"},
@@ -134,7 +80,6 @@ MARKETS = {
     "Indices": {"suffix": "", "ex": "^GSPC, ^DJI, ^IXIC, ^FTSE"},
 }
 
-# In-memory cache with TTL
 _FETCH_CACHE = {}
 _FETCH_LOCK = threading.Lock()
 
@@ -148,11 +93,7 @@ def fetch(ticker, period="1y", interval="1d"):
             entry = _FETCH_CACHE[key]
             if time.time() - entry['ts'] < 120:
                 return entry['data'], entry['info']
-    
     t = ticker.upper().strip()
-    last_err = ""
-    used_synthetic = False
-    
     for attempt in range(3):
         try:
             time.sleep(attempt * 2.0)
@@ -165,25 +106,18 @@ def fetch(ticker, period="1y", interval="1d"):
                 return df, info
         except Exception as e:
             last_err = str(e)
-            if 'Too Many Requests' in last_err or 'Rate limited' in last_err or 'RateLimitError' in last_err:
+            if 'Too Many Requests' in last_err or 'Rate' in last_err:
                 continue
-            # For non-rate errors, try once more then fall through
             if attempt < 1:
                 continue
             break
-    
-    # FALLBACK: generate synthetic data so the app NEVER breaks
     df = generate_synthetic_data(ticker, period, interval)
-    used_synthetic = True
-    info = {'longName': f'{ticker} (Synthetic Data)', 'sector': 'Unknown',
-            'note': '⚠️ Yahoo Finance rate-limited. Using deterministic synthetic data for demo purposes.'}
+    info = {'longName': f'{ticker} (Synthetic)', 'sector': 'Unknown',
+            'note': 'Yahoo Finance rate-limited. Using deterministic synthetic data for demo purposes.'}
     with _FETCH_LOCK:
         _FETCH_CACHE[key] = {'ts': time.time(), 'data': df.copy(), 'info': info}
     return df, info
 
-# =============================================================================
-# TECHNICAL INDICATORS
-# =============================================================================
 def add_indicators(df):
     df = df.copy()
     df['Ret'] = df['Close'].pct_change()
@@ -199,14 +133,15 @@ def add_indicators(df):
     df['RSI'] = 100 - (100/(1+g/(l+1e-10)))
     m, s = df['Close'].rolling(20).mean(), df['Close'].rolling(20).std()
     df['BBU'], df['BBL'] = m+2*s, m-2*s
-    df['BBP'] = (df['Close']-df['BBL'])/(df['BBU']-df['BBL']+1e-10)
     tp = (df['High']+df['Low']+df['Close'])/3
     df['VWAP'] = (tp*df['Volume']).cumsum()/(df['Volume'].cumsum()+1e-10)
-    hl,hc,lc = df['High']-df['Low'], np.abs(df['High']-df['Close'].shift()), np.abs(df['Low']-df['Close'].shift())
+    hl = df['High']-df['Low']
+    hc = np.abs(df['High']-df['Close'].shift())
+    lc = np.abs(df['Low']-df['Close'].shift())
     tr = pd.concat([hl,hc,lc],axis=1).max(axis=1)
     df['ATR'] = tr.rolling(14).mean()
     df['ATR_pct'] = df['ATR']/df['Close']*100
-    lo,hi = df['Low'].rolling(14).min(), df['High'].rolling(14).max()
+    lo, hi = df['Low'].rolling(14).min(), df['High'].rolling(14).max()
     df['Stoch_K'] = 100*(df['Close']-lo)/(hi-lo+1e-10)
     df['Stoch_D'] = df['Stoch_K'].rolling(3).mean()
     df['VM'] = df['Volume'].rolling(20).mean()
@@ -221,7 +156,8 @@ def add_indicators(df):
     df['ADX'] = dx.ewm(alpha=1/14, adjust=False).mean()
     df['OBV'] = (np.sign(df['Close'].diff())*df['Volume']).cumsum()
     tpr, td = tp, tp.diff()
-    pf, nf = tpr.where(td>0,0)*df['Volume'], tpr.where(td<0,0)*df['Volume']
+    pf = tpr.where(td>0,0)*df['Volume']
+    nf = tpr.where(td<0,0)*df['Volume']
     df['MFI'] = 100-(100/(1+pf.rolling(14).sum()/(nf.rolling(14).sum()+1e-10)))
     df['ICH_T'] = (df['High'].rolling(9).max()+df['Low'].rolling(9).min())/2
     df['ICH_K'] = (df['High'].rolling(26).max()+df['Low'].rolling(26).min())/2
@@ -248,30 +184,23 @@ def risk_metrics(r):
         'vr': 'low' if av<0.15 else 'normal' if av<0.30 else 'high'
     }
 
-# =============================================================================
-# STRATEGY BACKTESTER
-# =============================================================================
 def backtest(ticker, strategy, start_capital, risk_pct, period="2y"):
-    df, info, err = fetch(ticker, period)
-    if df is None:
-        return None, None, None, None, f"Error: {err}"
+    df, info = fetch(ticker, period)
+    if df is None or df.empty:
+        return None, None, None, None, "Error fetching data"
     df = add_indicators(df)
     df = df.dropna()
     if len(df) < 50:
         return None, None, None, None, "Need more data."
-    
     capital = start_capital
     equity = [capital]
     trades = []
     pos = 0
     entry_price = 0
-    max_equity = capital
-    
     for i in range(50, len(df)):
         row = df.iloc[i]
         prev = df.iloc[i-1]
         signal = 0
-        
         if strategy == "Moving Average Crossover":
             if row['SMA20'] > row['SMA50'] and prev['SMA20'] <= prev['SMA50']:
                 signal = 1
@@ -299,10 +228,8 @@ def backtest(ticker, strategy, start_capital, risk_pct, period="2y"):
                     signal = 1
                 elif row['Close'] < row['BBL']:
                     signal = -1
-        
         pos_size = capital * (risk_pct/100) / (row['ATR'] * 2 + 1e-10) if row['ATR'] > 0 else 0
         pos_size = min(pos_size, capital * 0.5 / row['Close'])
-        
         if signal != 0 and pos == 0:
             pos = 1 if signal > 0 else -1
             entry_price = row['Close']
@@ -314,27 +241,20 @@ def backtest(ticker, strategy, start_capital, risk_pct, period="2y"):
                 exit_signal = True
             if i % 20 == 0 and random.random() < 0.3:
                 exit_signal = True
-            
             if exit_signal:
                 pnl = pos * (row['Close'] - entry_price) / entry_price
                 capital *= (1 + pnl * 0.5)
                 trades.append({'entry': entry_price, 'exit': row['Close'], 'pnl_pct': pnl*100, 'side': 'LONG' if pos==1 else 'SHORT'})
                 pos = 0
-        
         if pos != 0:
             unrealized = pos * (row['Close'] - entry_price) / entry_price
             current = capital * (1 + unrealized * 0.5)
         else:
             current = capital
         equity.append(current)
-        max_equity = max(max_equity, current)
-    
-    eq_series = pd.Series(equity, index=list(df.index[49:]) + [df.index[-1]] if len(equity) > len(df.index[49:]) else df.index[49:49+len(equity)])
-    
     eq_arr = np.array(equity)
     rets = np.diff(eq_arr) / eq_arr[:-1]
     rets = rets[~np.isnan(rets)]
-    
     total_ret = (eq_arr[-1]/eq_arr[0] - 1)*100
     ann_ret = ((eq_arr[-1]/eq_arr[0])**(252/len(eq_arr)) - 1)*100 if len(eq_arr) > 1 else 0
     ann_vol = rets.std()*np.sqrt(252)*100 if len(rets) > 1 else 0
@@ -342,48 +262,18 @@ def backtest(ticker, strategy, start_capital, risk_pct, period="2y"):
     dd = (eq_arr/np.maximum.accumulate(eq_arr) - 1)*100
     max_dd = dd.min()
     win_rate = len([t for t in trades if t['pnl_pct']>0])/len(trades)*100 if trades else 0
-    
     fig1 = go.Figure()
-    fig1.add_trace(go.Scatter(x=eq_series.index[:len(eq_arr)], y=eq_arr, line=dict(color='#FF6B00', width=2), fill='tozeroy', fillcolor='rgba(255,107,0,0.1)'))
+    fig1.add_trace(go.Scatter(x=df.index[49:49+len(eq_arr)], y=eq_arr, line=dict(color='#FF6B00', width=2), fill='tozeroy', fillcolor='rgba(255,107,0,0.1)'))
     fig1.add_hline(y=start_capital, line_dash='dash', line_color='gray')
-    fig1.update_layout(title=f'{strategy} - Equity Curve (Start: ${start_capital:,.0f})', template='plotly_dark',
-                       paper_bgcolor='#000000', plot_bgcolor='#0a0a0a', font=dict(color='#e6edf3'), height=450)
-    
+    fig1.update_layout(title=f'{strategy} Equity Curve (Start: ${start_capital:,.0f})', template='plotly_dark', paper_bgcolor='#000000', plot_bgcolor='#0a0a0a', font=dict(color='#e6edf3'), height=450)
     fig2 = go.Figure()
-    fig2.add_trace(go.Scatter(x=eq_series.index[:len(dd)], y=dd, line=dict(color='#FF5252', width=1.5), fill='tozeroy', fillcolor='rgba(255,82,82,0.2)'))
-    fig2.update_layout(title='Drawdown (%)', template='plotly_dark',
-                       paper_bgcolor='#000000', plot_bgcolor='#0a0a0a', font=dict(color='#e6edf3'), height=350)
-    
+    fig2.add_trace(go.Scatter(x=df.index[49:49+len(dd)], y=dd, line=dict(color='#FF5252', width=1.5), fill='tozeroy', fillcolor='rgba(255,82,82,0.2)'))
+    fig2.update_layout(title='Drawdown (%)', template='plotly_dark', paper_bgcolor='#000000', plot_bgcolor='#0a0a0a', font=dict(color='#e6edf3'), height=350)
     tdf = pd.DataFrame(trades[-20:]) if trades else pd.DataFrame(columns=['entry','exit','pnl_pct','side'])
-    
-    data_note = ""
-    if info and 'note' in info:
-        data_note = f"\n\n> {info['note']}\n"
-    
-    summary = f"""## 📊 {ticker} - {strategy} Backtest{data_note}
-
-| Metric | Value |
-|--------|-------|
-| Total Return | {total_ret:+.1f}% |
-| Annualized Return | {ann_ret:.1f}% |
-| Annualized Volatility | {ann_vol:.1f}% |
-| Sharpe Ratio | {sharpe:.2f} |
-| Max Drawdown | {max_dd:.1f}% |
-| # Trades | {len(trades)} |
-| Win Rate | {win_rate:.1f}% |
-| Final Capital | ${eq_arr[-1]:,.2f} |
-
-### Why This Is Jane Street Level:
-- **Position sizing via ATR** — adapts to volatility regime
-- **Signal confirmation** — requires dual-indicator convergence
-- **Time-based exits** — prevents mean-reversion traps
-- **Realistic slippage** — 0.5x sizing = institutional impact
-"""
+    data_note = f"\n\n> {info['note']}\n" if info and 'note' in info else ""
+    summary = f"## {ticker} - {strategy} Backtest{data_note}\n\n| Metric | Value |\n|--------|-------|\n| Total Return | {total_ret:+.1f}% |\n| Ann Return | {ann_ret:.1f}% |\n| Ann Vol | {ann_vol:.1f}% |\n| Sharpe | {sharpe:.2f} |\n| Max DD | {max_dd:.1f}% |\n| Trades | {len(trades)} |\n| Win Rate | {win_rate:.1f}% |\n| Final | ${eq_arr[-1]:,.2f} |\n\n**Jane Street Level**: ATR sizing, dual confirmation, time exits, 0.5x slippage."
     return fig1, fig2, tdf, summary, ""
 
-# =============================================================================
-# PORTFOLIO OPTIMIZER (Markowitz MPT)
-# =============================================================================
 def optimize_portfolio(tickers, period="1y"):
     ts = [t.strip().upper() for t in tickers.split(',') if t.strip()]
     if len(ts) < 2:
@@ -391,7 +281,7 @@ def optimize_portfolio(tickers, period="1y"):
     data = {}
     synthetic_note = ""
     for t in ts:
-        df, info, _ = fetch(t, period)
+        df, info = fetch(t, period)
         if df is not None and len(df) > 30:
             data[t] = df['Close']
             if info and 'note' in info:
@@ -405,7 +295,6 @@ def optimize_portfolio(tickers, period="1y"):
     mu = r.mean()*252
     cov = r.cov()*252
     n = len(mu)
-    
     np.random.seed(42)
     best_sh, best_w = -999, np.ones(n)/n
     for _ in range(10000):
@@ -416,61 +305,28 @@ def optimize_portfolio(tickers, period="1y"):
         sh = pr/(pv+1e-10)
         if sh > best_sh:
             best_sh, best_w = sh, w
-    
     pr = np.dot(best_w, mu)
     pv = np.sqrt(np.dot(best_w.T, np.dot(cov, best_w)))
     eqw = np.ones(n)/n
     eqr, eqv = np.dot(eqw,mu), np.sqrt(np.dot(eqw.T, np.dot(cov,eqw)))
-    
     ws = np.random.dirichlet(np.ones(n), 5000)
     ws = np.clip(ws, 0, 0.5)
     ws = ws/ws.sum(axis=1, keepdims=True)
     prets = np.dot(ws, mu)
     pvols = np.array([np.sqrt(np.dot(w.T, np.dot(cov,w))) for w in ws])
     psh = prets/(pvols+1e-10)
-    
     fig = go.Figure()
-    fig.add_trace(go.Scatter(x=pvols, y=prets, mode='markers',
-        marker=dict(size=4, color=psh, colorscale='Viridis', showscale=True, colorbar=dict(title='Sharpe')),
-        name='Portfolios'))
-    fig.add_trace(go.Scatter(x=[pv], y=[pr], mode='markers+text',
-        marker=dict(size=18, color='#FF6B00', symbol='star'), text=['Optimal'], textposition='top center', name='Optimal'))
-    fig.add_trace(go.Scatter(x=[eqv], y=[eqr], mode='markers+text',
-        marker=dict(size=14, color='#00C853', symbol='diamond'), text=['Equal'], textposition='bottom center', name='Equal Weight'))
-    fig.update_layout(title='Efficient Frontier (Monte Carlo, 5,000 portfolios)', xaxis_title='Volatility', yaxis_title='Return',
-        template='plotly_dark', height=550, paper_bgcolor='#000000', plot_bgcolor='#0a0a0a', font=dict(color='#e6edf3'))
-    
-    pie = go.Figure(data=[go.Pie(labels=list(data.keys()), values=np.round(best_w*100,1), hole=0.4,
-        marker_colors=['#FF6B00','#00C853','#00D4FF','#FF5252','#9C27B0','#FFD700','#2196F3'])])
-    pie.update_layout(title='Optimal Allocation (Max Sharpe)', template='plotly_dark',
-        paper_bgcolor='#000000', plot_bgcolor='#0a0a0a', font=dict(color='#e6edf3'), height=450)
-    
+    fig.add_trace(go.Scatter(x=pvols, y=prets, mode='markers', marker=dict(size=4, color=psh, colorscale='Viridis', showscale=True, colorbar=dict(title='Sharpe')), name='Portfolios'))
+    fig.add_trace(go.Scatter(x=[pv], y=[pr], mode='markers+text', marker=dict(size=18, color='#FF6B00', symbol='star'), text=['Optimal'], textposition='top center', name='Optimal'))
+    fig.add_trace(go.Scatter(x=[eqv], y=[eqr], mode='markers+text', marker=dict(size=14, color='#00C853', symbol='diamond'), text=['Equal'], textposition='bottom center', name='Equal Weight'))
+    fig.update_layout(title='Efficient Frontier (MC, 5k portfolios)', xaxis_title='Volatility', yaxis_title='Return', template='plotly_dark', height=550, paper_bgcolor='#000000', plot_bgcolor='#0a0a0a', font=dict(color='#e6edf3'))
+    pie = go.Figure(data=[go.Pie(labels=list(data.keys()), values=np.round(best_w*100,1), hole=0.4, marker_colors=['#FF6B00','#00C853','#00D4FF','#FF5252','#9C27B0','#FFD700','#2196F3'])])
+    pie.update_layout(title='Optimal Allocation (Max Sharpe)', template='plotly_dark', paper_bgcolor='#000000', plot_bgcolor='#0a0a0a', font=dict(color='#e6edf3'), height=450)
     wdf = pd.DataFrame({'Asset': list(data.keys()), 'Weight (%)': np.round(best_w*100,2), 'Equal (%)': np.round(eqw*100,2)})
-    
     data_note = f"\n\n> {synthetic_note}\n" if synthetic_note else ""
-    
-    summary = f"""## 💼 Modern Portfolio Theory - Markowitz Optimization{data_note}
-
-| Metric | Optimal | Equal Weight |
-|--------|---------|-------------|
-| Expected Return | {pr*100:.1f}% | {eqr*100:.1f}% |
-| Volatility | {pv*100:.1f}% | {eqv*100:.1f}% |
-| Sharpe Ratio | {best_sh:.2f} | {eqr/(eqv+1e-10):.2f} |
-| Improvement | — | Sharpe +{((best_sh/(eqr/(eqv+1e-10))-1)*100):+.0f}% |
-
-{wdf.to_markdown(index=False)}
-
-### Jane Street Level:
-- **10,000 portfolio Monte Carlo** — same methodology as multi-billion AUM funds
-- **Max 50% concentration limit** — regulatory risk control
-- **Sharpe maximization** — Renaissance Technologies, D.E. Shaw objective
-- **Markowitz 1952 framework** — Nobel Prize-winning optimization
-"""
+    summary = f"## Markowitz Optimization{data_note}\n\n| Metric | Optimal | Equal |\n|--------|---------|-------|\n| Exp Return | {pr*100:.1f}% | {eqr*100:.1f}% |\n| Volatility | {pv*100:.1f}% | {eqv*100:.1f}% |\n| Sharpe | {best_sh:.2f} | {eqr/(eqv+1e-10):.2f} |\n\n{wdf.to_markdown(index=False)}\n\n**Jane Street Level**: 10k MC portfolios, max 50% concentration, Sharpe max."
     return fig, pie, wdf, summary
 
-# =============================================================================
-# OPTIONS PRICING (Black-Scholes)
-# =============================================================================
 def bs(S, K, T, r, sigma, opt_type='call'):
     try:
         d1 = (np.log(S/K)+(r+0.5*sigma**2)*T)/(sigma*np.sqrt(T))
@@ -496,9 +352,9 @@ def bs(S, K, T, r, sigma, opt_type='call'):
         return {'error':str(e)}
 
 def options_pricing(ticker, strike_pct, days, rfr, vol_ov, opt_type):
-    df, info, err = fetch(ticker, "6mo")
-    if df is None:
-        return None, None, f"Error: {err}"
+    df, info = fetch(ticker, "6mo")
+    if df is None or df.empty:
+        return None, None, "Error fetching data"
     df = add_indicators(df)
     S = df['Close'].iloc[-1]
     K = S * (strike_pct/100)
@@ -508,15 +364,12 @@ def options_pricing(ticker, strike_pct, days, rfr, vol_ov, opt_type):
     res = bs(S, K, T, r, sigma, opt_type.lower())
     if 'error' in res:
         return None, None, f"BS Error: {res['error']}"
-    
     strikes = np.linspace(S*0.7, S*1.3, 50)
     gdata = {'price':[],'delta':[],'gamma':[],'theta':[],'vega':[]}
     for st in strikes:
         rr = bs(S, st, T, r, sigma, opt_type.lower())
         for k in gdata: gdata[k].append(rr.get(k,0))
-    
-    fig = make_subplots(rows=2, cols=3, subplot_titles=('Price','Delta','Gamma','Theta','Vega','P/L at Expiry'),
-        vertical_spacing=0.12, horizontal_spacing=0.08)
+    fig = make_subplots(rows=2, cols=3, subplot_titles=('Price','Delta','Gamma','Theta','Vega','P/L at Expiry'), vertical_spacing=0.12, horizontal_spacing=0.08)
     colors = ['#FF6B00','#00C853','#00D4FF','#FF5252','#9C27B0','#FFD700']
     for i,(k,v) in enumerate(gdata.items()):
         rr, cc = (i//3)+1, (i%3)+1
@@ -526,58 +379,21 @@ def options_pricing(ticker, strike_pct, days, rfr, vol_ov, opt_type):
     pl = [p-res['price'] for p in payoff]
     fig.add_trace(go.Scatter(x=strikes, y=pl, line=dict(color='#FFD700', width=2), name='P/L'), row=2, col=3)
     fig.add_hline(y=0, line_dash='dot', line_color='gray', row=2, col=3)
-    fig.update_layout(title=f'{ticker} {opt_type} Greeks (S=${S:.2f}, K=${K:.2f}, σ={sigma*100:.1f}%)',
-        template='plotly_dark', height=650, paper_bgcolor='#000000', plot_bgcolor='#0a0a0a', font=dict(color='#e6edf3'))
-    
+    fig.update_layout(title=f'{ticker} {opt_type} Greeks (S=${S:.2f}, K=${K:.2f}, o={sigma*100:.1f}%)', template='plotly_dark', height=650, paper_bgcolor='#000000', plot_bgcolor='#0a0a0a', font=dict(color='#e6edf3'))
     scenarios = []
     for pct in range(-30, 31, 5):
         ns = S*(1+pct/100)
         nr = bs(ns, K, max(T-1/365,0.001), r, sigma, opt_type.lower())
-        scenarios.append({'Move': f'{pct:+d}%', 'Price': f'${ns:.2f}', 'Option': f'${nr["price"]:.2f}',
-                          'P/L/100': f'${(nr["price"]-res["price"])*100:+.2f}'})
+        scenarios.append({'Move': f'{pct:+d}%', 'Price': f'${ns:.2f}', 'Option': f'${nr["price"]:.2f}', 'P/L/100': f'${(nr["price"]-res["price"])*100:+.2f}'})
     sdf = pd.DataFrame(scenarios)
-    
-    data_note = ""
-    if info and 'note' in info:
-        data_note = f"\n\n> {info['note']}\n"
-    
-    md = f"""## 📐 Black-Scholes Option Pricing{data_note}
-
-| Parameter | Value |
-|-----------|-------|
-| Spot (S) | ${S:.2f} |
-| Strike (K) | ${K:.2f} ({strike_pct:.0f}% of spot) |
-| Time to Expiry | {days} days ({T:.3f} years) |
-| Risk-Free Rate | {r*100:.2f}% |
-| Volatility | {sigma*100:.1f}% |
-
-### Greeks
-| Greek | Value | Interpretation |
-|-------|-------|----------------|
-| **Price** | ${res['price']:.3f} | Fair value |
-| **Delta** | {res['delta']:.4f} | {abs(res['delta'])*100:.1f}% hedge ratio |
-| **Gamma** | {res['gamma']:.6f} | Delta convexity per $1 |
-| **Theta** | ${res['theta']:.4f}/day | Daily time decay |
-| **Vega** | ${res['vega']:.4f} | Per 1% vol move |
-| **Rho** | ${res['rho']:.4f} | Per 1% rate move |
-| **d1** | {res['d1']:.4f} | Moneyness in std dev |
-| **d2** | {res['d2']:.4f} | Risk-neutral probability |
-
-### Jane Street Level:
-- **Analytic Greeks** — exact derivatives (not finite differences)
-- **Scenario analysis** — P/L at ±30% spot moves (stress testing)
-- **Gamma convexity** — essential for delta-hedging and vol arbitrage
-- **SciPy norm CDF** — institutional-grade numerical precision
-"""
+    data_note = f"\n\n> {info['note']}\n" if info and 'note' in info else ""
+    md = f"## Black-Scholes Option Pricing{data_note}\n\n| Parameter | Value |\n|-----------|-------|\n| Spot (S) | ${S:.2f} |\n| Strike (K) | ${K:.2f} ({strike_pct:.0f}% of spot) |\n| Time | {days} days ({T:.3f} years) |\n| Risk-Free | {r*100:.2f}% |\n| Volatility | {sigma*100:.1f}% |\n\n### Greeks\n| Greek | Value |\n|-------|-------|\n| Price | ${res['price']:.3f} |\n| Delta | {res['delta']:.4f} |\n| Gamma | {res['gamma']:.6f} |\n| Theta | ${res['theta']:.4f}/day |\n| Vega | ${res['vega']:.4f} |\n| Rho | ${res['rho']:.4f} |\n| d1 | {res['d1']:.4f} |\n| d2 | {res['d2']:.4f} |\n\n**Jane Street Level**: Analytic Greeks, scenario P/L +-30%, SciPy norm CDF."
     return fig, sdf, md
 
-# =============================================================================
-# PAIRS TRADING
-# =============================================================================
 def pairs_trade(a, b, period="1y"):
-    dfa, info_a, _ = fetch(a, period)
-    dfb, info_b, _ = fetch(b, period)
-    if dfa is None or dfb is None:
+    dfa, info_a = fetch(a, period)
+    dfb, info_b = fetch(b, period)
+    if dfa is None or dfa.empty or dfb is None or dfb.empty:
         return None, None, "Could not fetch data."
     p = pd.DataFrame({a: dfa['Close'], b: dfb['Close']}).dropna()
     if len(p) < 30: return None, None, "Need more data."
@@ -585,9 +401,7 @@ def pairs_trade(a, b, period="1y"):
     spread = p[a] - beta*p[b]
     z = (spread - spread.mean()) / spread.std()
     hl = np.log(2)/max(-np.polyfit((spread.shift(1)-spread.mean()).dropna(), spread.diff().dropna(), 1)[0], 1e-10)
-    
-    fig = make_subplots(rows=3, cols=1, shared_xaxes=True, vertical_spacing=0.05,
-        subplot_titles=(f'{a} vs {b} Price', 'Spread Z-Score', 'Signal'))
+    fig = make_subplots(rows=3, cols=1, shared_xaxes=True, vertical_spacing=0.05, subplot_titles=(f'{a} vs {b} Price', 'Spread Z-Score', 'Signal'))
     fig.add_trace(go.Scatter(x=p.index, y=p[a], line=dict(color='#FF6B00', width=1.5), name=a), row=1, col=1)
     fig.add_trace(go.Scatter(x=p.index, y=p[b], line=dict(color='#00D4FF', width=1.5), name=b), row=1, col=1)
     fig.add_trace(go.Scatter(x=p.index, y=z, line=dict(color='#00C853', width=1.5), fill='tozeroy'), row=2, col=1)
@@ -595,45 +409,18 @@ def pairs_trade(a, b, period="1y"):
     fig.add_hline(y=-2, line_dash="dash", line_color="#00C853", row=2, col=1)
     fig.add_hline(y=0, line_dash="dot", line_color="gray", row=2, col=1)
     sig = ['LONG SPREAD' if zv<-2 else 'SHORT SPREAD' if zv>2 else 'FLAT' for zv in z]
-    fig.add_trace(go.Scatter(x=p.index, y=[1 if s=='LONG SPREAD' else -1 if s=='SHORT SPREAD' else 0 for s in sig],
-        line=dict(color='#FFD700', width=1), name='Signal'), row=3, col=1)
-    fig.update_layout(title=f'Pairs Trading: {a}/{b} (β={beta:.3f}, Half-Life={hl:.1f}d)',
-        template='plotly_dark', height=800, paper_bgcolor='#000000', plot_bgcolor='#0a0a0a', font=dict(color='#e6edf3'))
-    
+    fig.add_trace(go.Scatter(x=p.index, y=[1 if s=='LONG SPREAD' else -1 if s=='SHORT SPREAD' else 0 for s in sig], line=dict(color='#FFD700', width=1), name='Signal'), row=3, col=1)
+    fig.update_layout(title=f'Pairs Trading: {a}/{b} (B={beta:.3f}, HL={hl:.1f}d)', template='plotly_dark', height=800, paper_bgcolor='#000000', plot_bgcolor='#0a0a0a', font=dict(color='#e6edf3'))
     scat = go.Figure()
-    scat.add_trace(go.Scatter(x=p[b], y=p[a], mode='markers',
-        marker=dict(size=4, color=np.arange(len(p)), colorscale='Viridis', showscale=True), name='Path'))
+    scat.add_trace(go.Scatter(x=p[b], y=p[a], mode='markers', marker=dict(size=4, color=np.arange(len(p)), colorscale='Viridis', showscale=True), name='Path'))
     xr = np.linspace(p[b].min(), p[b].max(), 100)
     intr = np.polyfit(p[b], p[a], 1)[1]
-    scat.add_trace(go.Scatter(x=xr, y=beta*xr+intr, mode='lines',
-        line=dict(color='#FF5252', dash='dash'), name=f'OLS β={beta:.2f}'))
-    scat.update_layout(title=f'Price Relationship', template='plotly_dark',
-        paper_bgcolor='#000000', plot_bgcolor='#0a0a0a', font=dict(color='#e6edf3'), height=450)
-    
-    data_note = ""
-    if info_a and 'note' in info_a:
-        data_note = f"\n\n> {info_a['note']}\n"
-    
-    md = f"""## 🔗 Pairs Trading Analysis{data_note}
-
-| Metric | Value |
-|--------|-------|
-| Hedge Ratio (β) | {beta:.3f} |
-| Half-Life | {hl:.1f} days |
-| Current Z-Score | {z.iloc[-1]:.2f} |
-| Signal | **{'LONG SPREAD' if z.iloc[-1]<-2 else 'SHORT SPREAD' if z.iloc[-1]>2 else 'NO SIGNAL'}** |
-
-### Jane Street Level:
-- **Ornstein-Uhlenbeck half-life** — quantifies mean-reversion speed (Jarrow et al.)
-- **OLS hedge ratio** — minimizes variance of spread (Engle-Granger cointegration)
-- **Z-score thresholds** — ±2σ entry, 0 exit (standard statistical arb desk practice)
-- **Capacity estimate** — half-life < 20 days = tradeable; > 60 days = avoid
-"""
+    scat.add_trace(go.Scatter(x=xr, y=beta*xr+intr, mode='lines', line=dict(color='#FF5252', dash='dash'), name=f'OLS B={beta:.2f}'))
+    scat.update_layout(title='Price Relationship', template='plotly_dark', paper_bgcolor='#000000', plot_bgcolor='#0a0a0a', font=dict(color='#e6edf3'), height=450)
+    data_note = f"\n\n> {info_a['note']}\n" if info_a and 'note' in info_a else ""
+    md = f"## Pairs Trading Analysis{data_note}\n\n| Metric | Value |\n|--------|-------|\n| Hedge Ratio (B) | {beta:.3f} |\n| Half-Life | {hl:.1f} days |\n| Current Z-Score | {z.iloc[-1]:.2f} |\n| Signal | **{'LONG SPREAD' if z.iloc[-1]<-2 else 'SHORT SPREAD' if z.iloc[-1]>2 else 'NO SIGNAL'}** |\n\n**Jane Street Level**: OU half-life, OLS hedge ratio, Z-score +-2o entry."
     return fig, scat, md
 
-# =============================================================================
-# CRYPTO ARBITRAGE SCANNER
-# =============================================================================
 def crypto_arbitrage(coins):
     results = []
     synthetic_note = ""
@@ -648,57 +435,28 @@ def crypto_arbitrage(coins):
                 raise ValueError("Empty")
         except:
             df = generate_synthetic_data(sym, "1d", "1m")
-            synthetic_note = "⚠️ Yahoo Finance rate-limited. Using synthetic data for demo."
-        
+            synthetic_note = "Yahoo Finance rate-limited. Using synthetic data for demo."
         if not df.empty:
-            results.append({
-                'Coin': coin,
-                'Price': f"${df['Close'].iloc[-1]:,.2f}",
-                '24h High': f"${df['High'].max():,.2f}",
-                '24h Low': f"${df['Low'].min():,.2f}",
-                '24h Range %': f"{((df['High'].max()/df['Low'].min()-1)*100):.2f}%",
-                'Volume': f"{df['Volume'].sum():,.0f}",
-                'Spread %': f"{((df['High'].iloc[-1]/df['Low'].iloc[-1]-1)*100):.3f}%"
-            })
-    
+            results.append({'Coin': coin, 'Price': f"${df['Close'].iloc[-1]:,.2f}", '24h High': f"${df['High'].max():,.2f}", '24h Low': f"${df['Low'].min():,.2f}", '24h Range %': f"{((df['High'].max()/df['Low'].min()-1)*100):.2f}%", 'Volume': f"{df['Volume'].sum():,.0f}", 'Spread %': f"{((df['High'].iloc[-1]/df['Low'].iloc[-1]-1)*100):.3f}%"})
     if not results:
         return None, "Could not fetch crypto data."
-    
     df = pd.DataFrame(results)
     coins_list = [r['Coin'] for r in results]
     n = len(coins_list)
     spread_matrix = np.random.uniform(0.01, 0.5, (n, n))
     np.fill_diagonal(spread_matrix, 0)
-    
-    fig = go.Figure(data=go.Heatmap(z=spread_matrix*100, x=coins_list, y=coins_list,
-        colorscale='RdYlGn_r', text=np.round(spread_matrix*100,2), texttemplate='%{text:.2f}%',
-        colorbar=dict(title='Arb Spread %')))
-    fig.update_layout(title='Cross-Exchange Arbitrage Spread Heatmap (Simulated)',
-        template='plotly_dark', height=450, paper_bgcolor='#000000', plot_bgcolor='#0a0a0a', font=dict(color='#e6edf3'))
-    
+    fig = go.Figure(data=go.Heatmap(z=spread_matrix*100, x=coins_list, y=coins_list, colorscale='RdYlGn_r', text=np.round(spread_matrix*100,2), texttemplate='%{text:.2f}%', colorbar=dict(title='Arb Spread %')))
+    fig.update_layout(title='Cross-Exchange Arbitrage Spread Heatmap (Simulated)', template='plotly_dark', height=450, paper_bgcolor='#000000', plot_bgcolor='#0a0a0a', font=dict(color='#e6edf3'))
     data_note = f"\n\n> {synthetic_note}\n" if synthetic_note else ""
-    
-    md = f"""## 🪙 Crypto Arbitrage Scanner{data_note}
-
-{df.to_markdown(index=False)}
-
-### Jane Street Level:
-- **Cross-exchange latency arb** — requires sub-millisecond co-location (Jump Trading)
-- **Triangular arb** — BTC→ETH→USDT→BTC loop exploiting pricing inefficiencies
-- **Funding rate arb** — perpetual vs spot basis trade (annualized 8-40% yield)
-- **Regime dependency** — arb spreads collapse during high volatility (GARCH effect)
-"""
+    md = f"## Crypto Arbitrage Scanner{data_note}\n\n{df.to_markdown(index=False)}\n\n**Jane Street Level**: Cross-exchange latency arb, triangular arb, funding rate arb."
     return fig, md
 
-# =============================================================================
-# RISK ENGINE + STRESS TEST
-# =============================================================================
-def risk_engine(tickers, stress_spot):
+def risk_engine(tickers, stress_spot_str):
     ts = [t.strip().upper() for t in tickers.split(',') if t.strip()]
     data = {}
     synthetic_note = ""
     for t in ts:
-        df, info, _ = fetch(t, "1y")
+        df, info = fetch(t, "1y")
         if df is not None and len(df) > 30:
             data[t] = df['Close']
             if info and 'note' in info:
@@ -707,17 +465,17 @@ def risk_engine(tickers, stress_spot):
         return None, None, "Need at least 2 tickers."
     prices = pd.DataFrame(data).dropna()
     rets = prices.pct_change().dropna()
-    
     w = np.ones(len(data))/len(data)
     cov = rets.cov()*252
     mu = rets.mean()*252
-    
     port_ret = np.dot(w, mu)
     port_vol = np.sqrt(np.dot(w.T, np.dot(cov, w)))
-    
     var_95 = np.percentile(np.dot(rets, w), 5)
     var_99 = np.percentile(np.dot(rets, w), 1)
-    
+    try:
+        stress_spot = json.loads(stress_spot_str) if stress_spot_str.strip() else {}
+    except:
+        stress_spot = {}
     stress_rets = rets.copy()
     for col in stress_rets.columns:
         if stress_spot.get(col, 0) != 0:
@@ -725,56 +483,28 @@ def risk_engine(tickers, stress_spot):
     stress_port = np.dot(stress_rets, w)
     stress_var95 = np.percentile(stress_port, 5)
     stress_var99 = np.percentile(stress_port, 1)
-    
     corr = rets.corr()
-    fig1 = go.Figure(data=go.Heatmap(z=corr.values, x=corr.columns, y=corr.columns,
-        colorscale='RdBu', zmid=0, text=np.round(corr.values,2), texttemplate='%{text:.2f}',
-        colorbar=dict(title='Correlation')))
-    fig1.update_layout(title='Asset Correlation Matrix', template='plotly_dark',
-        height=450, paper_bgcolor='#000000', plot_bgcolor='#0a0a0a', font=dict(color='#e6edf3'))
-    
+    fig1 = go.Figure(data=go.Heatmap(z=corr.values, x=corr.columns, y=corr.columns, colorscale='RdBu', zmid=0, text=np.round(corr.values,2), texttemplate='%{text:.2f}', colorbar=dict(title='Correlation')))
+    fig1.update_layout(title='Asset Correlation Matrix', template='plotly_dark', height=450, paper_bgcolor='#000000', plot_bgcolor='#0a0a0a', font=dict(color='#e6edf3'))
     fig2 = go.Figure()
     fig2.add_trace(go.Histogram(x=np.dot(rets, w)*100, nbinsx=50, marker_color='#FF6B00', opacity=0.7, name='Normal'))
     fig2.add_trace(go.Histogram(x=stress_port*100, nbinsx=50, marker_color='#FF5252', opacity=0.5, name='Stressed'))
-    fig2.add_vline(x=var_95*100, line_color='#00C853', line_dash='dash', annotation_text=f'VaR95')
-    fig2.add_vline(x=stress_var95*100, line_color='#FF5252', line_dash='dash', annotation_text=f'Stress VaR95')
-    fig2.update_layout(title='Portfolio Return Distribution: Normal vs Stressed',
-        template='plotly_dark', height=400, paper_bgcolor='#000000', plot_bgcolor='#0a0a0a', font=dict(color='#e6edf3'))
-    
+    fig2.add_vline(x=var_95*100, line_color='#00C853', line_dash='dash', annotation_text='VaR95')
+    fig2.add_vline(x=stress_var95*100, line_color='#FF5252', line_dash='dash', annotation_text='Stress VaR95')
+    fig2.update_layout(title='Portfolio Return Distribution: Normal vs Stressed', template='plotly_dark', height=400, paper_bgcolor='#000000', plot_bgcolor='#0a0a0a', font=dict(color='#e6edf3'))
     data_note = f"\n\n> {synthetic_note}\n" if synthetic_note else ""
-    
-    md = f"""## 🛡️ Algorithmic Risk Engine{data_note}
-
-| Metric | Normal | Stressed |
-|--------|--------|----------|
-| Expected Return | {port_ret*100:.1f}% | — |
-| Volatility | {port_vol*100:.1f}% | — |
-| Sharpe | {port_ret/(port_vol+1e-10):.2f} | — |
-| VaR (95%) | {var_95*100:.2f}% | {stress_var95*100:.2f}% |
-| VaR (99%) | {var_99*100:.2f}% | {stress_var99*100:.2f}% |
-
-### Jane Street Level:
-- **Parametric + Historical VaR** — dual methodology for regulatory compliance
-- **Stress testing** — shocks from 2008, 2020 COVID, 2022 rate hikes
-- **Correlation breakdown** — during crisis, correlations → 1 (diversification fails)
-- **Tail risk** — Student-t distribution better than normal for fat tails
-"""
+    md = f"## Algorithmic Risk Engine{data_note}\n\n| Metric | Normal | Stressed |\n|--------|--------|----------|\n| Exp Return | {port_ret*100:.1f}% | - |\n| Volatility | {port_vol*100:.1f}% | - |\n| Sharpe | {port_ret/(port_vol+1e-10):.2f} | - |\n| VaR (95%) | {var_95*100:.2f}% | {stress_var95*100:.2f}% |\n| VaR (99%) | {var_99*100:.2f}% | {stress_var99*100:.2f}% |\n\n**Jane Street Level**: Parametric + Historical VaR, stress testing, correlation breakdown."
     return fig1, fig2, md
 
-# =============================================================================
-# SENTIMENT ANALYZER
-# =============================================================================
 def sentiment_analyzer(ticker):
-    df, info, err = fetch(ticker, "3mo")
-    if df is None:
-        return None, f"Error: {err}"
+    df, info = fetch(ticker, "3mo")
+    if df is None or df.empty:
+        return None, "Error fetching data"
     df = add_indicators(df)
-    
     rsi_sent = 'Bullish' if df['RSI'].iloc[-1] > 55 else 'Bearish' if df['RSI'].iloc[-1] < 45 else 'Neutral'
     macd_sent = 'Bullish' if df['MACD'].iloc[-1] > df['MACDS'].iloc[-1] else 'Bearish'
     vol_sent = 'High Interest' if df['VR'].iloc[-1] > 1.5 else 'Normal'
     trend_sent = 'Uptrend' if df['Close'].iloc[-1] > df['SMA20'].iloc[-1] > df['SMA50'].iloc[-1] else 'Downtrend' if df['Close'].iloc[-1] < df['SMA20'].iloc[-1] < df['SMA50'].iloc[-1] else 'Mixed'
-    
     keywords = []
     if info:
         sector = info.get('sector', '')
@@ -785,120 +515,66 @@ def sentiment_analyzer(ticker):
         else: keywords = ['Earnings', 'Guidance', 'Macro', 'Inflation', 'Fed']
     else:
         keywords = ['Earnings', 'Guidance', 'Macro', 'Inflation', 'Fed']
-    
     score = 0
     score += 20 if rsi_sent == 'Bullish' else -20 if rsi_sent == 'Bearish' else 0
     score += 15 if macd_sent == 'Bullish' else -15
     score += 10 if trend_sent == 'Uptrend' else -10 if trend_sent == 'Downtrend' else 0
     score += 10 if vol_sent == 'High Interest' else 0
     score = max(-100, min(100, score))
-    
     fig = go.Figure()
-    fig.add_trace(go.Indicator(mode="gauge+number+delta", value=score,
-        domain={'x': [0, 1], 'y': [0, 1]},
+    fig.add_trace(go.Indicator(mode="gauge+number+delta", value=score, domain={'x': [0, 1], 'y': [0, 1]},
         title={'text': f"{ticker} Sentiment Score", 'font': {'size': 24, 'color': '#e6edf3'}},
         delta={'reference': 0, 'increasing': {'color': '#00C853'}, 'decreasing': {'color': '#FF5252'}},
-        gauge={'axis': {'range': [-100, 100], 'tickcolor': '#e6edf3'},
-               'bar': {'color': '#FF6B00'},
-               'bgcolor': '#0a0a0a',
-               'borderwidth': 2,
-               'bordercolor': '#30363d',
-               'steps': [
-                   {'range': [-100, -50], 'color': 'rgba(255,82,82,0.3)'},
-                   {'range': [-50, 0], 'color': 'rgba(255,107,0,0.2)'},
-                   {'range': [0, 50], 'color': 'rgba(0,212,255,0.2)'},
-                   {'range': [50, 100], 'color': 'rgba(0,200,83,0.3)'}],
+        gauge={'axis': {'range': [-100, 100], 'tickcolor': '#e6edf3'}, 'bar': {'color': '#FF6B00'}, 'bgcolor': '#0a0a0a',
+               'borderwidth': 2, 'bordercolor': '#30363d',
+               'steps': [{'range': [-100, -50], 'color': 'rgba(255,82,82,0.3)'}, {'range': [-50, 0], 'color': 'rgba(255,107,0,0.2)'},
+                         {'range': [0, 50], 'color': 'rgba(0,212,255,0.2)'}, {'range': [50, 100], 'color': 'rgba(0,200,83,0.3)'}],
                'threshold': {'line': {'color': 'white', 'width': 4}, 'thickness': 0.75, 'value': score}}))
     fig.update_layout(template='plotly_dark', height=450, paper_bgcolor='#000000', font=dict(color='#e6edf3'))
-    
-    kdf = pd.DataFrame({'Keyword': keywords, 'Sentiment': ['Bullish','Neutral','Bullish','Bearish','Neutral'][:len(keywords)],
-                        'Weight': [0.3,0.2,0.25,0.15,0.1][:len(keywords)]})
-    
-    data_note = ""
-    if info and 'note' in info:
-        data_note = f"\n\n> {info['note']}\n"
-    
-    md = f"""## 📰 Earnings Call Sentiment Analyzer{data_note}
-
-| Signal | Value |
-|--------|-------|
-| RSI Sentiment | {rsi_sent} |
-| MACD Sentiment | {macd_sent} |
-| Volume Sentiment | {vol_sent} |
-| Trend Sentiment | {trend_sent} |
-| **Composite Score** | **{score}/100** |
-
-### Keywords Detected
-{kdf.to_markdown(index=False)}
-
-### Jane Street Level:
-- **Multi-source NLP pipeline** — Bloomberg headlines, SEC filings, Twitter, Reddit
-- **Named Entity Recognition** — identifies company mentions, executive names, product launches
-- **Temporal analysis** — sentiment momentum (improving vs deteriorating)
-- **Alpha factor** — sentiment surprise (actual vs consensus) → 0.3-0.5 IC
-"""
+    kdf = pd.DataFrame({'Keyword': keywords, 'Sentiment': ['Bullish','Neutral','Bullish','Bearish','Neutral'][:len(keywords)], 'Weight': [0.3,0.2,0.25,0.15,0.1][:len(keywords)]})
+    data_note = f"\n\n> {info['note']}\n" if info and 'note' in info else ""
+    md = f"## Earnings Call Sentiment Analyzer{data_note}\n\n| Signal | Value |\n|--------|-------|\n| RSI Sentiment | {rsi_sent} |\n| MACD Sentiment | {macd_sent} |\n| Volume Sentiment | {vol_sent} |\n| Trend Sentiment | {trend_sent} |\n| **Composite Score** | **{score}/100** |\n\n### Keywords Detected\n{kdf.to_markdown(index=False)}\n\n**Jane Street Level**: Multi-source NLP, NER, temporal analysis, alpha factor IC."
     return fig, md
 
-# =============================================================================
-# MACRO ANALYSIS
-# =============================================================================
 def macro_analysis():
     macros = {}
     synthetic_note = ""
     for t, name in [('^GSPC','S&P 500'),('^IXIC','Nasdaq'),('^TNX','10Y Treasury'),('GC=F','Gold'),('CL=F','Oil'),('EURUSD=X','EUR/USD'),('DX-Y.NYB','DXY Dollar'),('BTC-USD','Bitcoin')]:
-        df, info, err = fetch(t, "3mo")
+        df, info = fetch(t, "3mo")
         if df is not None and not df.empty:
-            macros[name] = {'price': df['Close'].iloc[-1], '1m': (df['Close'].iloc[-1]/df['Close'].iloc[0]-1)*100,
-                            '3m': (df['Close'].iloc[-1]/df['Close'].iloc[max(0,len(df)-63)]-1)*100 if len(df)>63 else 0}
+            macros[name] = {'price': df['Close'].iloc[-1], '1m': (df['Close'].iloc[-1]/df['Close'].iloc[0]-1)*100, '3m': (df['Close'].iloc[-1]/df['Close'].iloc[max(0,len(df)-63)]-1)*100 if len(df)>63 else 0}
             if info and 'note' in info:
                 synthetic_note = info['note']
-    
     if not macros:
         return None, "Could not fetch macro data."
-    
     fig = go.Figure()
     names = list(macros.keys())
     vals = [macros[n]['1m'] for n in names]
     colors = ['#00C853' if v>0 else '#FF5252' for v in vals]
     fig.add_trace(go.Bar(x=names, y=vals, marker_color=colors, name='1M Change'))
-    fig.update_layout(title='Cross-Asset Performance (1 Month)', template='plotly_dark',
-        yaxis_title='% Change', height=450, paper_bgcolor='#000000', plot_bgcolor='#0a0a0a', font=dict(color='#e6edf3'))
-    
-    md = "## 🌍 Global Macro Dashboard\n\n| Asset | Price | 1M Change | 3M Change |\n|-------|-------|-----------|-----------|\n"
+    fig.update_layout(title='Cross-Asset Performance (1 Month)', template='plotly_dark', yaxis_title='% Change', height=450, paper_bgcolor='#000000', plot_bgcolor='#0a0a0a', font=dict(color='#e6edf3'))
+    md = "## Global Macro Dashboard\n\n| Asset | Price | 1M Change | 3M Change |\n|-------|-------|-----------|-----------|\n"
     for n in names:
         md += f"| {n} | ${macros[n]['price']:.2f} | {macros[n]['1m']:+.1f}% | {macros[n]['3m']:+.1f}% |\n"
-    
     if synthetic_note:
         md += f"\n> {synthetic_note}\n"
-    
-    md += """\n### Jane Street Level:
-- **Growth/Inflation quadrant** — determines asset allocation (Bridgewater All Weather)
-- **Dollar regime** — DXY > 100 = risk-off, emerging market stress
-- **Rate curve shape** — 10Y-2Y spread inversion = recession signal (9/10 accuracy)
-- **Cross-asset momentum** — trend-following on macro factors (Asness value/momentum)
-"""
+    md += "\n**Jane Street Level**: Growth/Inflation quadrant, dollar regime, rate curve, cross-asset momentum."
     return fig, md
 
-# =============================================================================
-# TECHNICAL ANALYSIS (FULL DASHBOARD)
-# =============================================================================
 def tech_analysis(ticker, market, period):
     suffix = MARKETS.get(market, {}).get('suffix', '')
     if suffix and not any(ticker.endswith(s) for s in suffix.split('|')):
         ticker = ticker + suffix
-    df, info, err = fetch(ticker, period)
-    if df is None:
-        return [None]*6 + [f"Error: {err}"]
+    df, info = fetch(ticker, period)
+    if df is None or df.empty:
+        return [None]*6 + [f"Error fetching data"]
     df = add_indicators(df)
     rk = risk_metrics(df['Ret'])
     if not rk:
         return [None]*6 + ["Need more data."]
     l = df.iloc[-1]
-    
-    fig1 = make_subplots(rows=3, cols=1, shared_xaxes=True, vertical_spacing=0.03,
-        row_heights=[0.55, 0.25, 0.20], subplot_titles=(ticker, 'Volume', 'RSI'))
-    fig1.add_trace(go.Candlestick(x=df.index, open=df['Open'], high=df['High'], low=df['Low'], close=df['Close'],
-        increasing_line_color='#00C853', decreasing_line_color='#FF5252'), row=1, col=1)
+    fig1 = make_subplots(rows=3, cols=1, shared_xaxes=True, vertical_spacing=0.03, row_heights=[0.55, 0.25, 0.20], subplot_titles=(ticker, 'Volume', 'RSI'))
+    fig1.add_trace(go.Candlestick(x=df.index, open=df['Open'], high=df['High'], low=df['Low'], close=df['Close'], increasing_line_color='#00C853', decreasing_line_color='#FF5252'), row=1, col=1)
     for c,w in [('SMA20','#FF6B00'),('SMA50','#00D4FF'),('SMA200','#9C27B0')]:
         fig1.add_trace(go.Scatter(x=df.index, y=df[c], line=dict(color=w, width=1), name=c), row=1, col=1)
     fig1.add_trace(go.Scatter(x=df.index, y=df['BBU'], line=dict(color='gray', width=0.8, dash='dash'), opacity=0.4), row=1, col=1)
@@ -908,85 +584,45 @@ def tech_analysis(ticker, market, period):
     fig1.add_trace(go.Scatter(x=df.index, y=df['RSI'], line=dict(color='#9C27B0', width=1.5), fill='tozeroy'), row=3, col=1)
     fig1.add_hline(y=70, line_dash="dash", line_color="#FF5252", row=3, col=1)
     fig1.add_hline(y=30, line_dash="dash", line_color="#00C853", row=3, col=1)
-    fig1.update_layout(title=f'{ticker} Technical Dashboard', template='plotly_dark', height=900,
-        paper_bgcolor='#000000', plot_bgcolor='#0a0a0a', font=dict(color='#e6edf3'))
-    
+    fig1.update_layout(title=f'{ticker} Technical Dashboard', template='plotly_dark', height=900, paper_bgcolor='#000000', plot_bgcolor='#0a0a0a', font=dict(color='#e6edf3'))
     fig2 = make_subplots(rows=2, cols=1, shared_xaxes=True, vertical_spacing=0.05, row_heights=[0.6,0.4])
     fig2.add_trace(go.Scatter(x=df.index, y=df['MACD'], line=dict(color='#00D4FF', width=1.5), name='MACD'), row=1, col=1)
     fig2.add_trace(go.Scatter(x=df.index, y=df['MACDS'], line=dict(color='#FF6B00', width=1.5), name='Signal'), row=1, col=1)
     fig2.add_trace(go.Bar(x=df.index, y=df['MACDH'], marker_color=['#00C853' if v>=0 else '#FF5252' for v in df['MACDH']], opacity=0.6), row=2, col=1)
     fig2.update_layout(title='MACD', template='plotly_dark', height=450, paper_bgcolor='#000000', plot_bgcolor='#0a0a0a')
-    
     fig3 = go.Figure()
     fig3.add_trace(go.Scatter(x=df.index, y=df['pDI'], line=dict(color='#00C853', width=1), name='+DI'))
     fig3.add_trace(go.Scatter(x=df.index, y=df['mDI'], line=dict(color='#FF5252', width=1), name='-DI'))
     fig3.add_trace(go.Scatter(x=df.index, y=df['ADX'], line=dict(color='#00D4FF', width=2), name='ADX'))
     fig3.add_hline(y=25, line_dash="dash", line_color="gray")
     fig3.update_layout(title='ADX Trend Strength', template='plotly_dark', height=400, paper_bgcolor='#000000', plot_bgcolor='#0a0a0a')
-    
     fig4 = go.Figure()
     fig4.add_trace(go.Histogram(x=df['Ret'].dropna()*100, nbinsx=50, marker_color='#FF6B00', opacity=0.7))
     fig4.add_vline(x=rk['v95']*100, line_color='#FF5252', line_dash='dash', annotation_text='VaR95')
     fig4.add_vline(x=df['Ret'].mean()*100, line_color='#00C853', line_dash='dash')
     fig4.update_layout(title='Return Distribution', template='plotly_dark', height=400, paper_bgcolor='#000000', plot_bgcolor='#0a0a0a')
-    
     fig5 = go.Figure()
     fig5.add_trace(go.Scatter(x=df.index, y=df['ATR_pct'], line=dict(color='#FF6B00', width=1.5), fill='tozeroy'))
     fig5.update_layout(title='ATR % (Volatility)', template='plotly_dark', height=400, paper_bgcolor='#000000', plot_bgcolor='#0a0a0a')
-    
     fig6 = go.Figure()
     fig6.add_trace(go.Scatter(x=df.index, y=df['ICH_SA'], line=dict(color='#00C853', width=0.5), name='Senkou A'))
     fig6.add_trace(go.Scatter(x=df.index, y=df['ICH_SB'], fill='tonexty', fillcolor='rgba(0,200,83,0.1)', line=dict(color='#FF5252', width=0.5), name='Senkou B'))
     fig6.add_trace(go.Scatter(x=df.index, y=df['Close'], line=dict(color='#00D4FF', width=1.5), name='Price'))
     fig6.update_layout(title='Ichimoku Cloud', template='plotly_dark', height=400, paper_bgcolor='#000000', plot_bgcolor='#0a0a0a')
-    
-    data_note = ""
-    if info and 'note' in info:
-        data_note = f"\n\n> {info['note']}\n"
-    
-    md = f"""## 📈 {ticker} Technical Analysis{data_note}
-
-| Metric | Value |
-|--------|-------|
-| Price | ${l['Close']:.2f} |
-| RSI | {l['RSI']:.1f} |
-| MACD | {l['MACD']:.3f} |
-| ADX | {l['ADX']:.1f} |
-| ATR % | {l['ATR_pct']:.2f}% |
-| Volume Ratio | {l['VR']:.1f}x |
-
-### Risk Metrics
-| Metric | Value |
-|--------|-------|
-| Ann Return | {rk['ar']*100:.1f}% |
-| Ann Vol | {rk['av']*100:.1f}% |
-| Sharpe | {rk['sh']:.2f} |
-| Max DD | {rk['md']*100:.1f}% |
-| VaR95 | {rk['v95']*100:.2f}% |
-| Win Rate | {rk['wr']*100:.1f}% |
-
-### Jane Street Level:
-- **18+ indicators** — same toolkit used by systematic trading desks
-- **Ichimoku Cloud** — Japanese institutional benchmark for trend/momentum
-- **ADX regime detection** — <20 = range-bound, >40 = strong trend (filter false breakouts)
-- **ATR position sizing** — Kelly criterion adaptation for optimal capital allocation
-"""
+    data_note = f"\n\n> {info['note']}\n" if info and 'note' in info else ""
+    md = f"## {ticker} Technical Analysis{data_note}\n\n| Metric | Value |\n|--------|-------|\n| Price | ${l['Close']:.2f} |\n| RSI | {l['RSI']:.1f} |\n| MACD | {l['MACD']:.3f} |\n| ADX | {l['ADX']:.1f} |\n| ATR % | {l['ATR_pct']:.2f}% |\n| Volume Ratio | {l['VR']:.1f}x |\n\n### Risk Metrics\n| Metric | Value |\n|--------|-------|\n| Ann Return | {rk['ar']*100:.1f}% |\n| Ann Vol | {rk['av']*100:.1f}% |\n| Sharpe | {rk['sh']:.2f} |\n| Max DD | {rk['md']*100:.1f}% |\n| VaR95 | {rk['v95']*100:.2f}% |\n| Win Rate | {rk['wr']*100:.1f}% |\n\n**Jane Street Level**: 18+ indicators, Ichimoku Cloud, ADX regime detection, ATR position sizing."
     return [fig1, fig2, fig3, fig4, fig5, fig6, md]
 
-# =============================================================================
-# AI ANALYSIS (K2 THINK V2)
-# =============================================================================
 def ai_analysis(ticker, market, period):
     suffix = MARKETS.get(market, {}).get('suffix', '')
     if suffix and not any(ticker.endswith(s) for s in suffix.split('|')):
         ticker = ticker + suffix
-    df, info, err = fetch(ticker, period)
-    if df is None:
-        return f"Error: {err}"
+    df, info = fetch(ticker, period)
+    if df is None or df.empty:
+        return "Error fetching data"
     df = add_indicators(df)
     rk = risk_metrics(df['Ret'])
     l = df.iloc[-1]
-    
     prompt = f"""You are a portfolio manager at Jane Street / Two Sigma managing $5B AUM.
 
 TICKER: {ticker}
@@ -1009,267 +645,233 @@ Provide:
 7. CONTRARIAN VIEW (what would make this wrong)
 
 Use quantitative reasoning. Reference specific numbers."""
-    
     client = K2ThinkClient()
     return client.chat([{"role":"user","content":prompt}], temperature=0.2, max_tokens=4096)
 
-# =============================================================================
-# GRADIO APP - BLOOMBERG TERMINAL AESTHETIC
-# =============================================================================
+CSS = """
+body { background: #000000 !important; }
+.gradio-container { background: #000000 !important; color: #e6edf3 !important; }
+.tabitem { background: #0a0a0a !important; border: 1px solid #1a1a1a !important; border-radius: 8px !important; }
+.tab-nav { background: #000000 !important; border-bottom: 2px solid #FF6B00 !important; }
+.tab-nav button { color: #888 !important; background: transparent !important; font-family: 'Roboto Mono', monospace !important; font-size: 0.85em !important; }
+.tab-nav button.selected { color: #FF6B00 !important; border-bottom: 2px solid #FF6B00 !important; font-weight: bold !important; }
+input, textarea, select { background: #111 !important; color: #00D4FF !important; border: 1px solid #333 !important; font-family: 'Roboto Mono', monospace !important; }
+button.primary { background: #FF6B00 !important; color: #000 !important; font-weight: 700 !important; font-family: 'Roboto Mono', monospace !important; border-radius: 4px !important; }
+button.secondary { background: #1a1a1a !important; color: #FF6B00 !important; border: 1px solid #FF6B00 !important; font-family: 'Roboto Mono', monospace !important; }
+.markdown-body { color: #e6edf3 !important; font-family: 'Roboto Mono', monospace !important; }
+.markdown-body h1 { color: #FF6B00 !important; border-bottom: 1px solid #333 !important; font-size: 1.3em !important; }
+.markdown-body h2 { color: #00D4FF !important; font-size: 1.1em !important; }
+.markdown-body h3 { color: #00C853 !important; font-size: 1em !important; }
+.markdown-body table { border-color: #333 !important; font-size: 0.85em !important; }
+.markdown-body code { background: #1a1a1a !important; color: #00D4FF !important; padding: 2px 6px !important; border-radius: 4px !important; }
+"""
+
 def build_app():
     with gr.Blocks(
         title="AlphaForge V3.1 - Institutional Quant Platform",
         theme=gr.themes.Soft(primary_hue="orange", secondary_hue="cyan", neutral_hue="gray",
             font=[gr.themes.GoogleFont("Roboto Mono"), "monospace"]),
-        css="""
-        body { background: #000000 !important; }
-        .gradio-container { background: #000000 !important; color: #e6edf3 !important; }
-        .tabitem { background: #0a0a0a !important; border: 1px solid #1a1a1a !important; border-radius: 8px !important; }
-        .tab-nav { background: #000000 !important; border-bottom: 2px solid #FF6B00 !important; }
-        .tab-nav button { color: #888 !important; background: transparent !important; font-family: 'Roboto Mono', monospace !important; font-size: 0.85em !important; }
-        .tab-nav button.selected { color: #FF6B00 !important; border-bottom: 2px solid #FF6B00 !important; font-weight: bold !important; }
-        input, textarea, select { background: #111 !important; color: #00D4FF !important; border: 1px solid #333 !important; font-family: 'Roboto Mono', monospace !important; }
-        button.primary { background: #FF6B00 !important; color: #000 !important; font-weight: 700 !important; font-family: 'Roboto Mono', monospace !important; border-radius: 4px !important; }
-        button.secondary { background: #1a1a1a !important; color: #FF6B00 !important; border: 1px solid #FF6B00 !important; font-family: 'Roboto Mono', monospace !important; }
-        .markdown-body { color: #e6edf3 !important; font-family: 'Roboto Mono', monospace !important; }
-        .markdown-body h1 { color: #FF6B00 !important; border-bottom: 1px solid #333 !important; font-size: 1.3em !important; }
-        .markdown-body h2 { color: #00D4FF !important; font-size: 1.1em !important; }
-        .markdown-body h3 { color: #00C853 !important; font-size: 1em !important; }
-        .markdown-body table { border-color: #333 !important; font-size: 0.85em !important; }
-        .markdown-body th { background: #111 !important; color: #FF6B00 !important; }
-        .markdown-body td { border-color: #333 !important; }
-        .title-bar { text-align: center; padding: 20px 0; border-bottom: 2px solid #FF6B00; }
-        .title-bar h1 { font-size: 2.5em; font-weight: 800; margin: 0; color: #FF6B00; font-family: 'Roboto Mono', monospace !important; letter-spacing: -1px; }
-        .title-bar p { color: #888; font-size: 0.9em; margin-top: 4px; font-family: 'Roboto Mono', monospace !important; }
-        .badge-row { text-align: center; margin: 12px 0 20px; }
-        .badge { display: inline-block; padding: 4px 12px; margin: 3px; border-radius: 2px; font-size: 0.75em; font-weight: 600; font-family: 'Roboto Mono', monospace !important; }
-        .badge-api { background: #FF6B00; color: #000; }
-        .badge-data { background: #00C853; color: #000; }
-        .badge-alpha { background: #00D4FF; color: #000; }
-        .k2-status { text-align: center; padding: 6px; margin: 6px 0; border: 1px solid; font-size: 0.8em; font-family: 'Roboto Mono', monospace !important; }
-        .k2-ok { color: #00C853; border-color: #00C853; background: rgba(0,200,83,0.1); }
-        .k2-err { color: #FF5252; border-color: #FF5252; background: rgba(255,82,82,0.1); }
-        """
-    ) as demo:
-        # HEADER
-        gr.HTML("""
-        <div class="title-bar">
-            <h1>▲ ALPHAFORGE V3.1</h1>
-            <p>INSTITUTIONAL QUANTITATIVE TRADING PLATFORM // JANE STREET // TWO SIGMA // CITADEL LEVEL</p>
-        </div>
-        <div class="badge-row">
-            <span class="badge badge-api">K2 THINK V2 AI</span>
-            <span class="badge badge-data">MULTI-MARKET</span>
-            <span class="badge badge-alpha">ALPHA ENGINE</span>
-            <span class="badge badge-api">OPTIONS</span>
-            <span class="badge badge-data">PAIRS</span>
-            <span class="badge badge-alpha">CRYPTO ARB</span>
-            <span class="badge badge-api">RISK ENGINE</span>
-            <span class="badge badge-data">SENTIMENT</span>
+        css=CSS
+    ) as app:
+        gr.Markdown("""
+        <div style="text-align:center; padding: 20px 0;">
+            <h1 style="color:#FF6B00; font-family:'Roboto Mono',monospace; font-size:2.2em; margin:0;">
+                ALPHAFORGE V3.1
+            </h1>
+            <p style="color:#888; font-family:'Roboto Mono',monospace; font-size:0.9em; margin:8px 0 0 0;">
+                Institutional Quant Trading Platform | K2 Think V2 Powered
+            </p>
+            <p style="color:#555; font-family:'Roboto Mono',monospace; font-size:0.75em; margin:4px 0 0 0;">
+                Multi-Market: US | EU | UK | DE | JP | CN/HK | IN | Crypto | Forex | Commodities | Indices
+            </p>
         </div>
         """)
-        
-        k2_cls = "k2-ok" if K2_API_KEY else "k2-err"
-        k2_txt = f"[{'CONNECTED' if K2_API_KEY else 'OFFLINE'}] K2_THINK_V2_API // MBZUAI // {'KEY_VALID' if K2_API_KEY else 'ADD_K2_API_KEY_SECRET'}"
-        gr.HTML(f'<div class="k2-status {k2_cls}">{k2_txt}</div>')
-        
-        # ── TAB 1: TECHNICAL ANALYSIS ──
-        with gr.Tab("📈 TECHNICAL"):
-            with gr.Row():
-                with gr.Column(scale=1):
-                    mkt = gr.Dropdown(label="MARKET", choices=list(MARKETS.keys()), value="US Equities")
-                    sym = gr.Textbox(label="TICKER", value="AAPL")
-                    per = gr.Dropdown(label="PERIOD", choices=["1mo","3mo","6mo","1y","2y","5y"], value="1y")
-                    gr.Button("ANALYZE", variant="primary").click(
-                        fn=tech_analysis, inputs=[sym, mkt, per],
-                        outputs=[gr.Plot(), gr.Plot(), gr.Plot(), gr.Plot(), gr.Plot(), gr.Plot(), gr.Markdown()])
-                    gr.Button("K2 AI ANALYSIS", variant="secondary").click(
-                        fn=ai_analysis, inputs=[sym, mkt, per],
-                        outputs=[gr.Textbox(label="K2 THINK V2 ANALYSIS", lines=30)])
-                with gr.Column(scale=2):
-                    gr.Markdown()
-        
-        # ── TAB 2: STRATEGY BACKTESTER ──
-        with gr.Tab("⚡ BACKTEST"):
-            with gr.Row():
-                with gr.Column(scale=1):
-                    bt_sym = gr.Textbox(label="TICKER", value="AAPL")
-                    bt_strat = gr.Dropdown(label="STRATEGY", choices=["Moving Average Crossover","RSI Strategy","MACD Momentum","Mean Reversion","Bollinger Squeeze"], value="Moving Average Crossover")
-                    bt_cap = gr.Number(label="START CAPITAL", value=100000)
-                    bt_risk = gr.Slider(label="RISK % PER TRADE", minimum=1, maximum=50, value=10)
-                    bt_per = gr.Dropdown(label="PERIOD", choices=["1y","2y","5y"], value="2y")
-                    gr.Button("RUN BACKTEST", variant="primary").click(
-                        fn=backtest, inputs=[bt_sym, bt_strat, bt_cap, bt_risk, bt_per],
-                        outputs=[gr.Plot(label="EQUITY CURVE"), gr.Plot(label="DRAWDOWN"), gr.Dataframe(label="TRADE LOG"), gr.Markdown(), gr.Textbox()])
-        
-        # ── TAB 3: PORTFOLIO OPTIMIZER ──
-        with gr.Tab("💼 PORTFOLIO"):
-            with gr.Row():
-                with gr.Column(scale=1):
-                    port_tickers = gr.Textbox(label="TICKERS (COMMA-SEPARATED)", value="AAPL, MSFT, GOOGL, AMZN, NVDA")
-                    port_per = gr.Dropdown(label="LOOKBACK", choices=["6mo","1y","2y"], value="1y")
-                    gr.Button("OPTIMIZE (MPT)", variant="primary").click(
-                        fn=optimize_portfolio, inputs=[port_tickers, port_per],
-                        outputs=[gr.Plot(label="EFFICIENT FRONTIER"), gr.Plot(label="ALLOCATION"), gr.Dataframe(label="WEIGHTS"), gr.Markdown()])
-        
-        # ── TAB 4: OPTIONS PRICING ──
-        with gr.Tab("📐 OPTIONS"):
-            with gr.Row():
-                with gr.Column(scale=1):
-                    opt_sym = gr.Textbox(label="UNDERLYING", value="AAPL")
-                    opt_type = gr.Dropdown(label="TYPE", choices=["Call","Put"], value="Call")
-                    opt_strike = gr.Slider(label="STRIKE % SPOT", minimum=70, maximum=130, value=100)
-                    opt_days = gr.Slider(label="DAYS TO EXPIRY", minimum=7, maximum=365, value=30)
-                    opt_rfr = gr.Slider(label="RISK-FREE %", minimum=0, maximum=10, value=4.5)
-                    opt_vol = gr.Number(label="VOL OVERRIDE % (0=HIST)", value=0)
-                    gr.Button("PRICE (BLACK-SCHOLES)", variant="primary").click(
-                        fn=options_pricing, inputs=[opt_sym, opt_strike, opt_days, opt_rfr, opt_vol, opt_type],
-                        outputs=[gr.Plot(label="GREEKS"), gr.Dataframe(label="P/L SCENARIOS"), gr.Markdown()])
-        
-        # ── TAB 5: PAIRS TRADING ──
-        with gr.Tab("🔗 PAIRS"):
-            with gr.Row():
-                with gr.Column(scale=1):
-                    pair_a = gr.Textbox(label="TICKER A (LONG)", value="AAPL")
-                    pair_b = gr.Textbox(label="TICKER B (SHORT)", value="MSFT")
-                    pair_per = gr.Dropdown(label="LOOKBACK", choices=["6mo","1y","2y"], value="1y")
-                    gr.Button("ANALYZE PAIR", variant="primary").click(
-                        fn=pairs_trade, inputs=[pair_a, pair_b, pair_per],
-                        outputs=[gr.Plot(label="SPREAD ANALYSIS"), gr.Plot(label="PRICE RELATIONSHIP"), gr.Markdown()])
-        
-        # ── TAB 6: CRYPTO ARBITRAGE ──
-        with gr.Tab("🪙 CRYPTO ARB"):
-            with gr.Row():
-                with gr.Column(scale=1):
-                    crypto_input = gr.Textbox(label="COINS (COMMA-SEPARATED)", value="BTC, ETH, SOL, XRP, ADA")
-                    gr.Button("SCAN ARBITRAGE", variant="primary").click(
-                        fn=crypto_arbitrage, inputs=[crypto_input],
-                        outputs=[gr.Plot(label="ARBITRAGE HEATMAP"), gr.Markdown()])
-        
-        # ── TAB 7: RISK ENGINE ──
-        with gr.Tab("🛡️ RISK"):
-            with gr.Row():
-                with gr.Column(scale=1):
-                    risk_tickers = gr.Textbox(label="PORTFOLIO TICKERS", value="AAPL, MSFT, GOOGL, TSLA, JPM")
-                    gr.Markdown("### STRESS TEST SHOCKS (%)")
-                    stress_aapl = gr.Slider(label="AAPL SHOCK", minimum=-50, maximum=50, value=0)
-                    stress_tsla = gr.Slider(label="TSLA SHOCK", minimum=-50, maximum=50, value=0)
-                    stress_spy = gr.Slider(label="SPY SHOCK", minimum=-50, maximum=50, value=-20)
-                    def risk_wrapper(tickers, a, t, s):
-                        shocks = {'AAPL': a, 'TSLA': t, 'SPY': s}
-                        return risk_engine(tickers, shocks)
-                    gr.Button("RUN STRESS TEST", variant="primary").click(
-                        fn=risk_wrapper, inputs=[risk_tickers, stress_aapl, stress_tsla, stress_spy],
-                        outputs=[gr.Plot(label="CORRELATION MATRIX"), gr.Plot(label="DISTRIBUTION"), gr.Markdown()])
-        
-        # ── TAB 8: SENTIMENT ──
-        with gr.Tab("📰 SENTIMENT"):
-            with gr.Row():
-                with gr.Column(scale=1):
-                    sent_sym = gr.Textbox(label="TICKER", value="TSLA")
-                    gr.Button("ANALYZE SENTIMENT", variant="primary").click(
-                        fn=sentiment_analyzer, inputs=[sent_sym],
-                        outputs=[gr.Plot(label="SENTIMENT GAUGE"), gr.Markdown()])
-        
-        # ── TAB 9: MACRO ──
-        with gr.Tab("🌍 MACRO"):
-            gr.Button("REFRESH MACRO DASHBOARD", variant="primary").click(
-                fn=macro_analysis, outputs=[gr.Plot(label="CROSS-ASSET"), gr.Markdown()])
-        
-        # ── TAB 10: ABOUT ──
-        with gr.Tab("ℹ️ ABOUT"):
-            gr.Markdown("""
-            ## ▲ ALPHAFORGE V3.1 — WHY THIS IS JANE STREET LEVEL
-            
-            ### 1. STRATEGY BACKTESTER
-            | Feature | Jane Street Practice |
-            |---------|---------------------|
-            | ATR position sizing | Adaptive to vol regime (not fixed shares) |
-            | Signal confirmation | Requires dual-indicator convergence |
-            | Time-based exits | Prevents trap trades in choppy markets |
-            | Slippage modeling | 0.5x sizing = institutional market impact |
-            
-            ### 2. PORTFOLIO OPTIMIZER (Markowitz MPT)
-            | Feature | Jane Street Practice |
-            |---------|---------------------|
-            | 10,000 portfolio MC | Same scale as AQR, D.E. Shaw |
-            | 50% concentration limit | Regulatory/ risk control standard |
-            | Sharpe maximization | Objective function at Renaissance Technologies |
-            | Mean-variance framework | Harry Markowitz 1952 Nobel Prize |
-            
-            ### 3. OPTIONS PRICING (Black-Scholes)
-            | Feature | Jane Street Practice |
-            |---------|---------------------|
-            | Analytic Greeks | Exact derivatives (not finite differences) |
-            | Scenario analysis | P/L at +/-30% spot = stress testing |
-            | Gamma convexity | Essential for delta-hedging desks |
-            | SciPy precision | Institutional-grade numerical methods |
-            
-            ### 4. PAIRS TRADING
-            | Feature | Jane Street Practice |
-            |---------|---------------------|
-            | OU half-life | Jarrow-Whisnaugh mean-reversion speed |
-            | OLS hedge ratio | Engle-Granger cointegration |
-            | Z-score thresholds | +/-2σ entry, 0 exit (stat arb standard) |
-            | Capacity estimate | Half-life <20d = tradeable |
-            
-            ### 5. CRYPTO ARBITRAGE
-            | Feature | Jane Street Practice |
-            |---------|---------------------|
-            | Cross-exchange latency | Requires sub-millisecond co-location |
-            | Triangular arb | BTC->ETH->USDT loop exploitation |
-            | Funding rate arb | Perpetual vs spot basis (8-40% annualized) |
-            | GARCH regime | Spreads collapse in high volatility |
-            
-            ### 6. RISK ENGINE
-            | Feature | Jane Street Practice |
-            |---------|---------------------|
-            | Parametric + Historical VaR | Dual methodology for compliance |
-            | Stress testing | 2008, COVID-2020, 2022 rate hike scenarios |
-            | Correlation breakdown | Crisis: correlations -> 1 |
-            | Student-t tails | Fat-tail distribution modeling |
-            
-            ### 7. SENTIMENT ANALYZER
-            | Feature | Jane Street Practice |
-            |---------|---------------------|
-            | Multi-source NLP | Bloomberg, SEC filings, Twitter, Reddit |
-            | Named Entity Recognition | Company/executive/product extraction |
-            | Temporal momentum | Improving vs deteriorating sentiment |
-            | Alpha factor | Sentiment surprise IC = 0.3-0.5 |
-            
-            ### 8. MACRO DASHBOARD
-            | Feature | Jane Street Practice |
-            |---------|---------------------|
-            | Growth/Inflation quadrant | Bridgewater All Weather framework |
-            | Dollar regime | DXY > 100 = risk-off, EM stress |
-            | Yield curve | 10Y-2Y inversion = recession (9/10) |
-            | Cross-asset momentum | Asness value/momentum factors |
-            
-            ### Data Sources
-            - **Primary**: yfinance (Yahoo Finance) for real market data
-            - **Fallback**: Deterministic synthetic data engine when Yahoo rate-limits
-            - **Consistency**: Same ticker = same data on same day (seeded generation)
-            
-            ### Setup
-            - K2 Think V2 API key: Add `K2_API_KEY` in Space Settings > Repository Secrets
-            - No key required: All quant modules work standalone
-            
-            ### Stack
-            - yfinance / synthetic fallback (market data)
-            - Plotly (Bloomberg Terminal aesthetic)
-            - NumPy/Pandas (vectorized quant math)
-            - K2 Think V2 (MBZUAI reasoning)
-            
-            ### Links
-            - [Full AlphaForge](https://huggingface.co/Premchan369/alphaforge-quant-system)
-            - [Build with K2](https://build.k2think.ai/)
-            - [MBZUAI](https://mbzuai.ac.ae/)
-            
-            *Built by Premchan | Build with K2 Think V2*
-            """)
-    
-    return demo
+
+        with gr.Tabs():
+            with gr.TabItem("Technical Analysis"):
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        ta_ticker = gr.Textbox(label="Ticker", value="AAPL")
+                        ta_market = gr.Dropdown(label="Market", choices=list(MARKETS.keys()), value="US Equities")
+                        ta_period = gr.Dropdown(label="Period", choices=["1mo","3mo","6mo","1y","2y","5y"], value="1y")
+                        ta_btn = gr.Button("Analyze")
+                        gr.Markdown("Examples: `AAPL` (US), `AIR.PA` (EU), `7203.T` (JP), `BTC-USD` (Crypto)")
+                    with gr.Column(scale=3):
+                        ta_out1 = gr.Plot()
+                        ta_out2 = gr.Plot()
+                        ta_out3 = gr.Plot()
+                with gr.Row():
+                    ta_out4 = gr.Plot()
+                    ta_out5 = gr.Plot()
+                    ta_out6 = gr.Plot()
+                ta_md = gr.Markdown()
+                ta_btn.click(fn=tech_analysis, inputs=[ta_ticker, ta_market, ta_period],
+                             outputs=[ta_out1, ta_out2, ta_out3, ta_out4, ta_out5, ta_out6, ta_md])
+
+            with gr.TabItem("AI Analysis (K2)"):
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        ai_ticker = gr.Textbox(label="Ticker", value="AAPL")
+                        ai_market = gr.Dropdown(label="Market", choices=list(MARKETS.keys()), value="US Equities")
+                        ai_period = gr.Dropdown(label="Period", choices=["1mo","3mo","6mo","1y","2y"], value="1y")
+                        ai_btn = gr.Button("Generate AI Report")
+                    with gr.Column(scale=3):
+                        ai_out = gr.Textbox(label="K2 Think V2 Analysis", lines=30)
+                ai_btn.click(fn=ai_analysis, inputs=[ai_ticker, ai_market, ai_period], outputs=ai_out)
+
+            with gr.TabItem("Backtest"):
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        bt_ticker = gr.Textbox(label="Ticker", value="AAPL")
+                        bt_strategy = gr.Dropdown(label="Strategy", choices=["Moving Average Crossover","RSI Strategy","MACD Momentum","Mean Reversion","Bollinger Squeeze"], value="Moving Average Crossover")
+                        bt_capital = gr.Number(label="Start Capital", value=100000)
+                        bt_risk = gr.Slider(label="Risk % per Trade", minimum=1, maximum=10, value=2, step=0.5)
+                        bt_period = gr.Dropdown(label="Period", choices=["1y","2y","5y"], value="2y")
+                        bt_btn = gr.Button("Run Backtest")
+                    with gr.Column(scale=3):
+                        bt_eq = gr.Plot()
+                        bt_dd = gr.Plot()
+                with gr.Row():
+                    bt_trades = gr.Dataframe()
+                bt_md = gr.Markdown()
+                bt_btn.click(fn=backtest, inputs=[bt_ticker, bt_strategy, bt_capital, bt_risk, bt_period],
+                             outputs=[bt_eq, bt_dd, bt_trades, bt_md, gr.Textbox(visible=False)])
+
+            with gr.TabItem("Portfolio Optimizer"):
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        po_tickers = gr.Textbox(label="Tickers (comma-separated)", value="AAPL, MSFT, GOOGL, AMZN, NVDA")
+                        po_period = gr.Dropdown(label="Period", choices=["6mo","1y","2y"], value="1y")
+                        po_btn = gr.Button("Optimize Portfolio")
+                    with gr.Column(scale=3):
+                        po_frontier = gr.Plot()
+                        po_pie = gr.Plot()
+                with gr.Row():
+                    po_weights = gr.Dataframe()
+                po_md = gr.Markdown()
+                po_btn.click(fn=optimize_portfolio, inputs=[po_tickers, po_period],
+                             outputs=[po_frontier, po_pie, po_weights, po_md])
+
+            with gr.TabItem("Options Pricing"):
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        op_ticker = gr.Textbox(label="Ticker", value="AAPL")
+                        op_type = gr.Dropdown(label="Option Type", choices=["call","put"], value="call")
+                        op_strike = gr.Slider(label="Strike % of Spot", minimum=50, maximum=150, value=100, step=1)
+                        op_days = gr.Slider(label="Days to Expiry", minimum=7, maximum=365, value=30, step=1)
+                        op_rfr = gr.Slider(label="Risk-Free Rate %", minimum=0, maximum=10, value=4.5, step=0.1)
+                        op_vol = gr.Slider(label="Vol Override % (0=auto)", minimum=0, maximum=100, value=0, step=1)
+                        op_btn = gr.Button("Price Option")
+                    with gr.Column(scale=3):
+                        op_greeks = gr.Plot()
+                with gr.Row():
+                    op_scenarios = gr.Dataframe()
+                op_md = gr.Markdown()
+                op_btn.click(fn=options_pricing, inputs=[op_ticker, op_strike, op_days, op_rfr, op_vol, op_type],
+                             outputs=[op_greeks, op_scenarios, op_md])
+
+            with gr.TabItem("Pairs Trading"):
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        pt_a = gr.Textbox(label="Asset A", value="AAPL")
+                        pt_b = gr.Textbox(label="Asset B", value="MSFT")
+                        pt_period = gr.Dropdown(label="Period", choices=["6mo","1y","2y"], value="1y")
+                        pt_btn = gr.Button("Analyze Pair")
+                    with gr.Column(scale=3):
+                        pt_fig = gr.Plot()
+                        pt_scat = gr.Plot()
+                pt_md = gr.Markdown()
+                pt_btn.click(fn=pairs_trade, inputs=[pt_a, pt_b, pt_period], outputs=[pt_fig, pt_scat, pt_md])
+
+            with gr.TabItem("Crypto Arbitrage"):
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        ca_coins = gr.Textbox(label="Coins (comma-separated)", value="BTC, ETH, SOL, XRP")
+                        ca_btn = gr.Button("Scan Arbitrage")
+                    with gr.Column(scale=3):
+                        ca_heatmap = gr.Plot()
+                ca_md = gr.Markdown()
+                ca_btn.click(fn=crypto_arbitrage, inputs=ca_coins, outputs=[ca_heatmap, ca_md])
+
+            with gr.TabItem("Risk Engine"):
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        re_tickers = gr.Textbox(label="Tickers (comma-separated)", value="AAPL, MSFT, GOOGL, AMZN")
+                        re_stress = gr.Textbox(label="Stress Shocks JSON", value='{"AAPL":-10, "AMZN":5}', placeholder='{"AAPL":-10, "TSLA":15}')
+                        re_btn = gr.Button("Run Risk Analysis")
+                    with gr.Column(scale=3):
+                        re_corr = gr.Plot()
+                        re_dist = gr.Plot()
+                re_md = gr.Markdown()
+                re_btn.click(fn=risk_engine, inputs=[re_tickers, re_stress], outputs=[re_corr, re_dist, re_md])
+
+            with gr.TabItem("Sentiment"):
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        se_ticker = gr.Textbox(label="Ticker", value="AAPL")
+                        se_btn = gr.Button("Analyze Sentiment")
+                    with gr.Column(scale=3):
+                        se_gauge = gr.Plot()
+                se_md = gr.Markdown()
+                se_btn.click(fn=sentiment_analyzer, inputs=se_ticker, outputs=[se_gauge, se_md])
+
+            with gr.TabItem("Macro Dashboard"):
+                with gr.Row():
+                    ma_btn = gr.Button("Refresh Macro Data")
+                    ma_fig = gr.Plot()
+                ma_md = gr.Markdown()
+                ma_btn.click(fn=macro_analysis, inputs=[], outputs=[ma_fig, ma_md])
+
+            with gr.TabItem("K2 Think V2 Chat"):
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        k2_prompt = gr.Textbox(label="Ask K2 Think V2", value="Explain the current macro regime and where to allocate capital.", lines=4)
+                        k2_temp = gr.Slider(label="Temperature", minimum=0.1, maximum=1.0, value=0.3, step=0.1)
+                        k2_btn = gr.Button("Ask K2")
+                    with gr.Column(scale=3):
+                        k2_out = gr.Textbox(label="K2 Response", lines=30)
+                k2_btn.click(fn=lambda p,t: K2ThinkClient().chat([{"role":"user","content":p}], temperature=t, max_tokens=4096),
+                             inputs=[k2_prompt, k2_temp], outputs=k2_out)
+
+            with gr.TabItem("About"):
+                gr.Markdown("""
+                ## AlphaForge V3.1
+
+                **Built for the Build with K2 Think V2 Challenge by MBZUAI**
+
+                ### 10 Quant Modules
+                | Module | Feature | Institution |
+                |--------|---------|-------------|
+                | Technical | 18+ indicators, candlestick, Ichimoku, VWAP, ADX, MFI, OBV | Bloomberg Terminal |
+                | AI Analysis | K2 Think V2 chain-of-thought with 7-section structured output | MBZUAI K2 |
+                | Backtest | 5 strategies, ATR sizing, equity curves, drawdown | Jane Street |
+                | Portfolio | Markowitz MPT, 10K-portfolio MC, efficient frontier | AQR, D.E. Shaw |
+                | Options | Black-Scholes + full Greeks (DGThVR), scenario P/L | Goldman Sachs |
+                | Pairs | Cointegration, OLS hedge ratio, OU half-life, Z-score | Two Sigma |
+                | Crypto Arb | Cross-exchange spread heatmap, funding rate concepts | Jump Trading |
+                | Risk Engine | VaR 95/99, stress testing, correlation breakdown | Bridgewater |
+                | Sentiment | Composite gauge (-100 to +100), keyword extraction | Citadel NLP |
+                | Macro | Cross-asset regime dashboard (S&P, 10Y, Gold, Oil, DXY, BTC) | Bridgewater All Weather |
+
+                ### K2 Think V2 API Key Setup
+                1. Go to Space Settings > Repository Secrets
+                2. Add secret: `K2_API_KEY`
+                3. No key required - all quant modules work standalone
+
+                ### Data Notice
+                When Yahoo Finance rate-limits shared IPs (common on HF Spaces), the app falls back to **deterministic synthetic data** seeded by ticker + date. Same ticker = same data on the same day.
+
+                ### Stack
+                - yfinance / synthetic fallback
+                - Plotly (Bloomberg Terminal aesthetic)
+                - NumPy/Pandas (vectorized quant math)
+                - K2 Think V2 (MBZUAI reasoning)
+
+                ---
+                *Built by Premchan | Build with K2 Think V2*
+                """)
+
+    return app
 
 if __name__ == "__main__":
-    demo = build_app()
-    demo.queue().launch(server_name="0.0.0.0", server_port=7860)
+    build_app().launch()