Update app.py

app.py

@@ -1,501 +1,833 @@
 """
-RCEA Lite v1.0 — yfinance Edition
-Regime-Conditioned Evidence Accumulation. Causal HMM. No supervised ML.
+BIST Value Intelligence — Conservative Value Screener
+=====================================================
+A transparent, data-honest value screening application for Borsa Istanbul.
+
+DESIGN PHILOSOPHY:
+- Never fabricate missing data. Missing data = None + confidence penalty.
+- Clearly distinguish between computed metrics and unavailable fields.
+- Use only yfinance as data source (no KAP API key required).
+- All assumptions are explicit in code.
+
+LIMITATIONS (READ BEFORE USE):
+- yfinance fundamentals are NOT point-in-time. Do not use for backtesting.
+- Coverage for non-BIST-100 names is incomplete. Many fields will be None.
+- No DCF, Monte Carlo, or ML—insufficient reliable historical data.
 """
 
-import math, time, warnings
-from datetime import datetime, timezone
-from typing import List, Optional
+import logging
+import time
+from datetime import datetime, timedelta
+from typing import Any, Dict, List, Optional, Tuple
 
+import gradio as gr
 import numpy as np
 import pandas as pd
+import plotly.graph_objects as go
 import yfinance as yf
-import gradio as gr
-from hmmlearn import hmm
-
-warnings.filterwarnings("ignore")
-
-# ---------- Config ----------
-COMMISSION, SLIPPAGE = 0.001, 0.0005
-COST = 2 * (COMMISSION + SLIPPAGE)
-REGIME_NAMES = ["TREND", "MEAN_REVERSION", "COMPRESSION"]
-HMM_K = 3
-TRAIN_FRAC, PURGE, EMBARGO = 0.60, 5, 3
-MIN_HMM, MIN_SIG = 150, 80
-FEAT_COLS = ["ret", "atr_norm", "ema_diff_norm", "efficiency", "rsi_dev", "dist_ma"]
-
-# 30 USDT paritesi (yfinance sembolleri)
-COINS = [
-    "BTC-USD", "ETH-USD", "BNB-USD", "SOL-USD", "XRP-USD",
-    "ADA-USD", "DOGE-USD", "AVAX-USD", "TRX-USD", "DOT-USD",
-    "LINK-USD", "MATIC-USD", "LTC-USD", "BCH-USD", "UNI-USD",
-    "ATOM-USD", "ETC-USD", "XLM-USD", "NEAR-USD", "APT-USD",
-    "ARB-USD", "OP-USD", "FIL-USD", "INJ-USD", "SUI-USD",
-    "SEI-USD", "TIA-USD", "AAVE-USD", "MKR-USD", "GRT-USD",
+
+# ============================================================================
+# CONFIGURATION
+# ============================================================================
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s | %(levelname)s | %(message)s",
+)
+logger = logging.getLogger(__name__)
+
+# BIST universe: core liquid names. Extend cautiously—non-BIST-100
+# fundamentals coverage in yfinance is poor and produces misleading scores.
+BIST_UNIVERSE = [
+    "AEFES.IS", "AKBNK.IS", "AKSA.IS", "AKSEN.IS", "ALARK.IS",
+    "ARCLK.IS", "ASELS.IS", "ASTOR.IS", "BIMAS.IS", "BRSAN.IS",
+    "CCOLA.IS", "CIMSA.IS", "DOAS.IS", "DOHOL.IS", "ECILC.IS",
+    "EKGYO.IS", "ENJSA.IS", "ENKAI.IS", "EREGL.IS", "FROTO.IS",
+    "GARAN.IS", "GUBRF.IS", "HEKTS.IS", "ISCTR.IS", "KCHOL.IS",
+    "KRDMD.IS", "MGROS.IS", "ODAS.IS", "PETKM.IS", "PGSUS.IS",
+    "SAHOL.IS", "SASA.IS", "SISE.IS", "SKBNK.IS", "TCELL.IS",
+    "THYAO.IS", "TKFEN.IS", "TOASO.IS", "TSKB.IS", "TTKOM.IS",
+    "TUPRS.IS", "ULKER.IS", "VAKBN.IS", "VESBE.IS", "YKBNK.IS",
+    "ZOREN.IS",
 ]
 
-# yfinance interval mapping + max period per interval
-YF_TF = {
-    "15m": ("15m", "60d"),
-    "1h":  ("1h",  "730d"),
-    "4h":  ("1h",  "730d"),   # 4h yok → 1h'den resample
-    "1d":  ("1d",  "5y"),
-}
+# Cache configuration
+CACHE_TTL_HOURS = 6
+_cache: Dict[str, Tuple[datetime, Any]] = {}
 
-TARGET_BARS = 1000
 
+def _cache_get(key: str) -> Optional[Any]:
+    """Retrieve from cache if TTL valid."""
+    if key in _cache:
+        ts, data = _cache[key]
+        if datetime.now() - ts < timedelta(hours=CACHE_TTL_HOURS):
+            return data
+    return None
 
-# ---------- Helpers ----------
-def _sig(x):
-    return 1.0 / (1.0 + math.exp(-x)) if x >= 0 else math.exp(x) / (1.0 + math.exp(x))
 
+def _cache_set(key: str, data: Any) -> None:
+    """Store in cache."""
+    _cache[key] = (datetime.now(), data)
 
-def _ema(a, span):
-    al = 2.0 / (span + 1.0)
-    o = np.empty_like(a, dtype=float); o[0] = a[0]
-    for i in range(1, len(a)): o[i] = al * a[i] + (1 - al) * o[i - 1]
-    return o
 
+# ============================================================================
+# DATA ACQUISITION
+# ============================================================================
 
-def _atr(h, l, c, p=14):
-    n = len(c); tr = np.empty(n)
-    tr[0] = h[0] - l[0]
-    for i in range(1, n):
-        tr[i] = max(h[i] - l[i], abs(h[i] - c[i-1]), abs(l[i] - c[i-1]))
-    return _ema(tr, p)
+def fetch_ticker_data(symbol: str, force_refresh: bool = False) -> Optional[Dict[str, Any]]:
+    """
+    Fetch all available data for a single ticker.
+    Returns None if the ticker cannot be retrieved at all.
+    All individual fields may be None if unavailable.
+    """
+    cache_key = f"ticker_{symbol}"
+    if not force_refresh:
+        cached = _cache_get(cache_key)
+        if cached is not None:
+            return cached
 
+    try:
+        ticker = yf.Ticker(symbol)
+        info = ticker.info or {}
+
+        # Core price data
+        price = info.get("currentPrice") or info.get("regularMarketPrice")
+        if price is None:
+            # Fallback: try history
+            hist = ticker.history(period="5d")
+            if not hist.empty:
+                price = float(hist["Close"].iloc[-1])
+
+        # Market cap
+        market_cap = info.get("marketCap")
+
+        # Valuation multiples
+        trailing_pe = info.get("trailingPE")
+        forward_pe = info.get("forwardPE")
+        price_to_book = info.get("priceToBook")
+        price_to_sales = info.get("priceToSalesTrailing12Months")
+        ev_to_ebitda = info.get("enterpriseToEbitda")
+        enterprise_value = info.get("enterpriseValue")
+        earnings_yield = (1.0 / trailing_pe) if trailing_pe and trailing_pe > 0 else None
+
+        # Profitability
+        roe = info.get("returnOnEquity")
+        roa = info.get("returnOnAssets")
+        gross_margin = info.get("grossMargins")
+        operating_margin = info.get("operatingMargins")
+        profit_margin = info.get("profitMargins")
+
+        # Balance sheet
+        debt_to_equity = info.get("debtToEquity")
+        current_ratio = info.get("currentRatio")
+        total_debt = info.get("totalDebt")
+        total_cash = info.get("totalCash")
+
+        # Cash flow
+        free_cashflow = info.get("freeCashflow")
+        operating_cashflow = info.get("operatingCashflow")
+        fcf_yield = None
+        if free_cashflow is not None and market_cap and market_cap > 0:
+            fcf_yield = free_cashflow / market_cap
+
+        # Per-share data for Graham
+        trailing_eps = info.get("trailingEps")
+        book_value_per_share = info.get("bookValue")
+
+        # Sector
+        sector = info.get("sector", "Unknown")
+        industry = info.get("industry", "Unknown")
+
+        # Dividend
+        dividend_yield = info.get("dividendYield")
+
+        result = {
+            "symbol": symbol.replace(".IS", ""),
+            "price": price,
+            "market_cap": market_cap,
+            "trailing_pe": trailing_pe,
+            "forward_pe": forward_pe,
+            "price_to_book": price_to_book,
+            "price_to_sales": price_to_sales,
+            "ev_to_ebitda": ev_to_ebitda,
+            "enterprise_value": enterprise_value,
+            "earnings_yield": earnings_yield,
+            "roe": roe,
+            "roa": roa,
+            "gross_margin": gross_margin,
+            "operating_margin": operating_margin,
+            "profit_margin": profit_margin,
+            "debt_to_equity": debt_to_equity,
+            "current_ratio": current_ratio,
+            "total_debt": total_debt,
+            "total_cash": total_cash,
+            "free_cashflow": free_cashflow,
+            "operating_cashflow": operating_cashflow,
+            "fcf_yield": fcf_yield,
+            "trailing_eps": trailing_eps,
+            "book_value_per_share": book_value_per_share,
+            "sector": sector,
+            "industry": industry,
+            "dividend_yield": dividend_yield,
+            "data_timestamp": datetime.now().isoformat(),
+        }
+
+        # Graham Number: sqrt(22.5 * EPS * BVPS)
+        if (trailing_eps is not None and trailing_eps > 0
+                and book_value_per_share is not None and book_value_per_share > 0):
+            result["graham_number"] = float(np.sqrt(22.5 * trailing_eps * book_value_per_share))
+        else:
+            result["graham_number"] = None
 
-def _rsi(c, p=14):
-    d = np.diff(c, prepend=c[0])
-    g = np.where(d > 0, d, 0.0); ls = np.where(d < 0, -d, 0.0)
-    ag, al = _ema(g, p), _ema(ls, p)
-    rs = np.where(al > 1e-12, ag / al, 100.0)
-    return 100.0 - 100.0 / (1.0 + rs)
+        _cache_set(cache_key, result)
+        return result
 
+    except Exception as e:
+        logger.warning(f"Failed to fetch {symbol}: {e}")
+        return None
 
-# ---------- yfinance Data Layer ----------
-def fetch_pairs(n=30):
-    """Return fixed 30-coin USDT list (yfinance)."""
-    out = COINS[:30]
-    print(f"[RCEA] {len(out)} yfinance pairs resolved", flush=True)
-    return out
 
+# ============================================================================
+# SCORING ENGINE
+# ============================================================================
 
-def fetch_klines(inst_id, timeframe, target_bars=TARGET_BARS):
+def compute_piotroski_score(data: Dict[str, Any]) -> Optional[int]:
     """
-    Fetch OHLCV from Yahoo Finance via yfinance.
-    For 4h, downloads 1h and resamples to 4H.
+    Compute Piotroski F-Score using available data.
     Returns None if insufficient data.
+    
+    Note: True Piotroski requires year-over-year changes in 9 metrics.
+    Without historical statements, we compute a reduced version using
+    only current-period available fields. This is explicitly a partial score.
     """
-    if timeframe not in YF_TF:
+    score = 0
+    components_available = 0
+
+    # Profitability signals (4 components if data exists)
+    if data.get("roa") is not None:
+        components_available += 1
+        if data["roa"] > 0:
+            score += 1
+
+    if data.get("operating_cashflow") is not None:
+        components_available += 1
+        if data["operating_cashflow"] > 0:
+            score += 1
+
+    if data.get("roa") is not None and data.get("operating_cashflow") is not None:
+        components_available += 1
+        # CFO > ROA (approximation: CFO/assets > net income/assets)
+        if data["operating_cashflow"] > 0 and data["roa"] > 0:
+            score += 1
+
+    # Leverage/liquidity (2 components)
+    if data.get("debt_to_equity") is not None:
+        components_available += 1
+        # Lower leverage is better; use 100 as threshold (yfinance reports as percentage)
+        if data["debt_to_equity"] < 100:
+            score += 1
+
+    if data.get("current_ratio") is not None:
+        components_available += 1
+        if data["current_ratio"] > 1.0:
+            score += 1
+
+    # Require at least 4 components to return a score
+    if components_available < 4:
         return None
-    interval, period = YF_TF[timeframe]
 
-    try:
-        raw = yf.download(
-            inst_id,
-            interval=interval,
-            period=period,
-            auto_adjust=False,
-            progress=False,
-            threads=False,
-        )
-    except Exception as e:
-        print(f"[RCEA] {inst_id} download failed: {e}", flush=True)
-        return None
+    # Scale to 9-point maximum based on available components
+    # This is NOT a true Piotroski score and should be labeled accordingly
+    max_possible = components_available
+    scaled = round((score / max_possible) * 9) if max_possible > 0 else 0
+    return min(9, max(0, scaled))
 
-    if raw is None or raw.empty:
-        print(f"[RCEA] {inst_id}: empty data", flush=True)
-        return None
 
-    # yfinance multiindex flatten (tek sembolde bile MultiIndex dönebilir)
-    if isinstance(raw.columns, pd.MultiIndex):
-        raw.columns = raw.columns.get_level_values(0)
+def compute_valuation_score(data: Dict[str, Any], sector_medians: Dict[str, float]) -> Tuple[Optional[float], int]:
+    """
+    Compute valuation score (0-100). Returns (score, confidence_0_to_100).
+    Confidence reflects data completeness.
+    """
+    scores = []
+    weights = []
+    missing = 0
+    total = 0
+
+    # Earnings Yield (higher = better value)
+    total += 1
+    ey = data.get("earnings_yield")
+    if ey is not None and ey > 0:
+        # Normalize: 0% = 0, 15%+ = 100
+        s = min(100, ey * 100 / 0.15 * 100)
+        scores.append(s)
+        weights.append(0.25)
+    else:
+        missing += 1
+
+    # P/B vs sector (lower = better)
+    total += 1
+    pb = data.get("price_to_book")
+    sector_pb = sector_medians.get(data.get("sector", ""), {}).get("pb")
+    if pb is not None and pb > 0 and sector_pb and sector_pb > 0:
+        ratio = pb / sector_pb
+        s = max(0, min(100, (1.5 - ratio) / 1.5 * 100))
+        scores.append(s)
+        weights.append(0.25)
+    else:
+        missing += 1
+
+    # EV/EBITDA vs sector
+    total += 1
+    evebitda = data.get("ev_to_ebitda")
+    sector_ev = sector_medians.get(data.get("sector", ""), {}).get("ev_ebitda")
+    if evebitda is not None and evebitda > 0 and sector_ev and sector_ev > 0:
+        ratio = evebitda / sector_ev
+        s = max(0, min(100, (1.5 - ratio) / 1.5 * 100))
+        scores.append(s)
+        weights.append(0.25)
+    else:
+        missing += 1
+
+    # FCF Yield
+    total += 1
+    fcfy = data.get("fcf_yield")
+    if fcfy is not None:
+        s = min(100, max(0, fcfy * 100 / 0.08 * 100))
+        scores.append(s)
+        weights.append(0.25)
+    else:
+        missing += 1
+
+    if not scores:
+        return None, 0
+
+    # Weighted average
+    total_weight = sum(weights)
+    if total_weight == 0:
+        return None, 0
+    final_score = sum(s * w for s, w in zip(scores, weights)) / total_weight
+
+    # Confidence: penalize missing data
+    confidence = max(0, 100 - (missing / total) * 60)
+    return final_score, int(confidence)
+
+
+def compute_quality_score(data: Dict[str, Any]) -> Tuple[Optional[float], int]:
+    """Compute quality score (0-100) with confidence."""
+    scores = []
+    weights = []
+    missing = 0
+    total = 0
+
+    # ROE (higher = better)
+    total += 1
+    roe = data.get("roe")
+    if roe is not None:
+        s = min(100, max(0, roe * 100 / 0.25 * 100))
+        scores.append(s)
+        weights.append(0.3)
+    else:
+        missing += 1
+
+    # Operating margin
+    total += 1
+    om = data.get("operating_margin")
+    if om is not None:
+        s = min(100, max(0, om * 100 / 0.20 * 100))
+        scores.append(s)
+        weights.append(0.25)
+    else:
+        missing += 1
+
+    # Debt/Equity (lower = better)
+    total += 1
+    de = data.get("debt_to_equity")
+    if de is not None and de >= 0:
+        s = max(0, min(100, (150 - de) / 150 * 100))
+        scores.append(s)
+        weights.append(0.25)
+    else:
+        missing += 1
+
+    # Current ratio
+    total += 1
+    cr = data.get("current_ratio")
+    if cr is not None:
+        s = min(100, max(0, (cr - 0.5) / 2.0 * 100))
+        scores.append(s)
+        weights.append(0.20)
+    else:
+        missing += 1
+
+    if not scores:
+        return None, 0
 
-    raw = raw.rename(columns=str.lower)
-    needed = ["open", "high", "low", "close", "volume"]
-    if not all(c in raw.columns for c in needed):
-        print(f"[RCEA] {inst_id}: missing columns {raw.columns.tolist()}", flush=True)
-        return None
+    total_weight = sum(weights)
+    final_score = sum(s * w for s, w in zip(scores, weights)) / total_weight
+    confidence = max(0, 100 - (missing / total) * 60)
+    return final_score, int(confidence)
 
-    df = raw[needed].copy()
-    df = df.dropna(subset=["open", "high", "low", "close"])
-    df = df[df["close"] > 0]
 
-    # 4h resample
-    if timeframe == "4h":
-        df = df.resample("4H").agg({
-            "open": "first", "high": "max", "low": "min",
-            "close": "last", "volume": "sum",
-        }).dropna()
+def compute_composite_score(
+    data: Dict[str, Any],
+    sector_medians: Dict[str, float],
+) -> Dict[str, Any]:
+    """
+    Compute composite score with explicit component breakdown.
+    Missing data reduces confidence; it does NOT boost scores.
+    """
+    val_score, val_conf = compute_valuation_score(data, sector_medians)
+    qual_score, qual_conf = compute_quality_score(data)
+
+    piotroski = compute_piotroski_score(data)
+
+    # Weighted composite: 50% valuation, 50% quality (simplified from spec
+    # because growth data is unavailable)
+    components = []
+    weights = []
+
+    if val_score is not None:
+        components.append(val_score * 0.50)
+        weights.append(0.50)
+    if qual_score is not None:
+        components.append(qual_score * 0.50)
+        weights.append(0.50)
+
+    if not components:
+        composite = None
+        overall_conf = 0
+    else:
+        total_w = sum(weights)
+        composite = sum(c * w for c, w in zip(components, weights)) / total_w
+        # Overall confidence: weighted average of component confidences
+        overall_conf = int((val_conf * 0.5 + qual_conf * 0.5)) if (val_score is not None and qual_score is not None) else max(val_conf, qual_conf)
+
+    # Margin of Safety vs Graham Number
+    mos = None
+    graham = data.get("graham_number")
+    price = data.get("price")
+    if graham and price and price > 0:
+        mos = (graham - price) / graham
+
+    return {
+        "composite_score": composite,
+        "valuation_score": val_score,
+        "quality_score": qual_score,
+        "piotroski": piotroski,
+        "confidence": overall_conf,
+        "margin_of_safety": mos,
+    }
+
+
+# ============================================================================
+# FORECASTING (Conservative, assumption-explicit)
+# ============================================================================
+
+def compute_12m_forecast(data: Dict[str, Any], score_result: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Scenario-based 12-month price target.
+    
+    METHODOLOGY (explicit):
+    - Bear: Price reverts to 70% of current P/E multiple (multiple compression)
+    - Base: Price grows with earnings yield (conservative proxy for earnings growth)
+    - Bull: Price re-rates to 120% of current P/E multiple
+    
+    These are NOT statistically calibrated forecasts. They are
+    transparent heuristic scenarios. Do not treat them as predictions.
+    """
+    price = data.get("price")
+    pe = data.get("trailing_pe")
+    earnings_yield = data.get("earnings_yield")
+
+    if price is None or price <= 0:
+        return {"bear": None, "base": None, "bull": None, "expected": None,
+                "expected_return": None, "note": "Insufficient price data"}
+
+    # Base case: earnings power drives price
+    # If earnings yield = 10%, implied annual return ≈ 10% (simplistic)
+    base_growth = 0.08  # Conservative 8% nominal (below Turkish historical inflation)
+    if earnings_yield and earnings_yield > 0:
+        base_growth = min(0.20, max(0.03, earnings_yield * 0.8))
+
+    bear_return = -0.20  # 20% downside in bear
+    bull_return = base_growth * 1.8
+
+    bear = price * (1 + bear_return)
+    base = price * (1 + base_growth)
+    bull = price * (1 + bull_return)
+
+    # Probability-weighted (20/55/25 from spec)
+    expected = bear * 0.20 + base * 0.55 + bull * 0.25
+    expected_return = (expected - price) / price
+
+    # Add dividend yield if available
+    div_yield = data.get("dividend_yield") or 0
+    total_return = expected_return + div_yield
+
+    return {
+        "bear": round(bear, 2),
+        "base": round(base, 2),
+        "bull": round(bull, 2),
+        "expected": round(expected, 2),
+        "expected_return": round(expected_return, 4),
+        "total_expected_return": round(total_return, 4),
+        "dividend_yield": div_yield,
+        "base_assumption": f"{base_growth*100:.1f}% base growth",
+        "note": "Heuristic scenario, not calibrated forecast",
+    }
+
+
+# ============================================================================
+# SECTOR MEDIANS (computed from universe)
+# ============================================================================
+
+def compute_sector_medians(all_data: List[Dict[str, Any]]) -> Dict[str, Dict[str, float]]:
+    """Compute median multiples per sector from available data."""
+    sectors: Dict[str, Dict[str, List[float]]] = {}
+
+    for d in all_data:
+        sector = d.get("sector", "Unknown")
+        if sector not in sectors:
+            sectors[sector] = {"pb": [], "ev_ebitda": [], "pe": []}
+
+        if d.get("price_to_book") and d["price_to_book"] > 0:
+            sectors[sector]["pb"].append(d["price_to_book"])
+        if d.get("ev_to_ebitda") and d["ev_to_ebitda"] > 0:
+            sectors[sector]["ev_ebitda"].append(d["ev_to_ebitda"])
+        if d.get("trailing_pe") and d["trailing_pe"] > 0:
+            sectors[sector]["pe"].append(d["trailing_pe"])
+
+    medians = {}
+    for sector, metrics in sectors.items():
+        medians[sector] = {}
+        for key, values in metrics.items():
+            if values:
+                medians[sector][key] = float(np.median(values))
+    return medians
+
+
+# ============================================================================
+# SCANNER
+# ============================================================================
+
+def run_scanner(force_refresh: bool = False) -> pd.DataFrame:
+    """Run full universe scan. Returns DataFrame for display."""
+    all_data = []
+    failed = []
+
+    for i, sym in enumerate(BIST_UNIVERSE):
+        logger.info(f"Scanning {sym} ({i+1}/{len(BIST_UNIVERSE)})")
+        data = fetch_ticker_data(sym, force_refresh)
+        if data is not None and data.get("price") is not None:
+            all_data.append(data)
+        else:
+            failed.append(sym)
 
-    if len(df) < MIN_HMM:
-        print(f"[RCEA] {inst_id}: only {len(df)} bars (< {MIN_HMM})", flush=True)
-        return None
+    if not all_data:
+        return pd.DataFrame()
+
+    sector_medians = compute_sector_medians(all_data)
 
-    # Son target_bars
-    df = df.tail(target_bars).reset_index(drop=True)
+    rows = []
+    for d in all_data:
+        score_result = compute_composite_score(d, sector_medians)
+        forecast = compute_12m_forecast(d, score_result)
+
+        rows.append({
+            "Symbol": d["symbol"],
+            "Price": d["price"],
+            "Sector": d["sector"],
+            "Composite Score": round(score_result["composite_score"], 1) if score_result["composite_score"] else None,
+            "Valuation Score": round(score_result["valuation_score"], 1) if score_result["valuation_score"] else None,
+            "Quality Score": round(score_result["quality_score"], 1) if score_result["quality_score"] else None,
+            "Piotroski (partial)": score_result["piotroski"],
+            "P/E": round(d["trailing_pe"], 2) if d["trailing_pe"] else None,
+            "P/B": round(d["price_to_book"], 2) if d["price_to_book"] else None,
+            "ROE": round(d["roe"] * 100, 1) if d["roe"] else None,
+            "FCF Yield": round(d["fcf_yield"] * 100, 1) if d["fcf_yield"] else None,
+            "Graham Number": round(d["graham_number"], 2) if d["graham_number"] else None,
+            "Margin of Safety": round(score_result["margin_of_safety"] * 100, 1) if score_result["margin_of_safety"] else None,
+            "12M Base Target": forecast["base"],
+            "Expected Return": round(forecast["total_expected_return"] * 100, 1) if forecast["total_expected_return"] else None,
+            "Confidence": score_result["confidence"],
+        })
+
+    df = pd.DataFrame(rows)
+    # Sort by composite score, nulls last
+    df = df.sort_values("Composite Score", ascending=False, na_position="last")
     return df
 
 
-# ---------- Features ----------
-def features(df):
-    c = df["close"].values.astype(float)
-    h = df["high"].values.astype(float)
-    lo = df["low"].values.astype(float)
-    n = len(c)
-    o = pd.DataFrame(index=df.index)
-    o["close"] = c
-    r = np.zeros(n); r[1:] = np.diff(c) / c[:-1]; o["ret"] = r
-    a14 = _atr(h, lo, c, 14); o["atr"] = a14
-    o["atr_norm"] = a14 / np.where(c > 0, c, 1.0)
-    ef, es = _ema(c, 12), _ema(c, 26)
-    o["ema_fast"], o["ema_slow"] = ef, es
-    o["ema_diff_norm"] = (ef - es) / np.where(c > 0, c, 1.0)
-    lb, eff = 10, np.zeros(n)
-    for i in range(lb, n):
-        net = c[i] - c[i - lb]; path = np.sum(np.abs(np.diff(c[i - lb:i + 1])))
-        eff[i] = net / path if path > 1e-12 else 0.0
-    o["efficiency"] = eff
-    mom = np.zeros(n); mom[10:] = (c[10:] - c[:-10]) / np.where(c[:-10] > 0, c[:-10], 1.0)
-    o["momentum"] = mom
-    am = np.zeros(n); am[1:] = np.diff(c) / np.where(a14[1:] > 1e-12, a14[1:], 1.0)
-    o["atr_move"] = am
-    rs = _rsi(c, 14); o["rsi"] = rs; o["rsi_dev"] = (rs - 50.0) / 50.0
-    rm = pd.Series(c).rolling(20, min_periods=20).mean().values
-    dm = np.where(rm > 0, (c - rm) / rm, 0.0); o["dist_ma"] = np.nan_to_num(dm)
-    ae = np.where(a14 > 1e-12, (c - rm) / a14, 0.0); o["atr_extension"] = np.nan_to_num(ae)
-    a5, a20 = _atr(h, lo, c, 5), _atr(h, lo, c, 20)
-    o["vol_ratio"] = np.where(a20 > 1e-12, a5 / a20, 1.0)
-    ph, pl_ = np.roll(h, 1), np.roll(lo, 1)
-    ph[0], pl_[0] = h[0], lo[0]
-    o["prev_high"], o["prev_low"] = ph, pl_
-    o["breakout"] = np.where(c > ph, 1.0, np.where(c < pl_, -1.0, 0.0))
-    return o.replace([np.inf, -np.inf], np.nan).fillna(0.0)
-
-
-# ---------- HMM ----------
-def fit_hmm(f):
-    ntr = min(max(MIN_HMM, int(len(f) * TRAIN_FRAC)), len(f) - 20)
-    if ntr < MIN_HMM: return None
-    X = f.iloc[:ntr][FEAT_COLS].values
-    mu, sd = X.mean(0), X.std(0); sd[sd < 1e-12] = 1.0
-    m = hmm.GaussianHMM(n_components=HMM_K, covariance_type="diag",
-                        n_iter=100, random_state=42, tol=1e-4)
-    try: m.fit((X - mu) / sd)
-    except Exception: return None
-    m._mu, m._sd = mu, sd
-    return m
-
-
-def forward_filter(m, f):
-    n = len(f)
-    post = np.ones((n, HMM_K)) / HMM_K
-    ntr = min(max(MIN_HMM, int(n * TRAIN_FRAC)), n - 20)
-    if ntr < 10: return post
-    X = (f[FEAT_COLS].values - m._mu) / m._sd
-    ls, lt = np.log(m.startprob_ + 1e-300), np.log(m.transmat_ + 1e-300)
-    le = np.zeros((n, HMM_K))
-    for k in range(HMM_K):
-        cov = m.covars_[k]; var = np.diag(cov) if cov.ndim > 1 else cov
-        var = np.maximum(var, 1e-6); d = X - m.means_[k]
-        le[:, k] = -0.5 * np.sum(d * d / var, 1) - 0.5 * np.sum(np.log(2 * np.pi * var))
-    a = np.zeros((n, HMM_K)); a[0] = ls + le[0]
-    for t in range(1, n):
-        for k in range(HMM_K):
-            terms = a[t - 1] + lt[:, k]; mx = terms.max()
-            a[t, k] = le[t, k] + mx + np.log(np.exp(terms - mx).sum())
-    for t in range(n):
-        e = np.exp(a[t] - a[t].max()); post[t] = e / e.sum()
-    post[:ntr] = 1.0 / HMM_K
-    return post
-
-
-# ---------- Evidence ----------
-def evidence(f, rp, lam):
-    n = len(f)
-    c = f["close"].values; ef = f["ema_fast"].values; es = f["ema_slow"].values
-    eff = f["efficiency"].values; mom = f["momentum"].values; am = f["atr_move"].values
-    rd = f["rsi_dev"].values; dm = f["dist_ma"].values; ae = f["atr_extension"].values
-    vr = f["vol_ratio"].values; bo = f["breakout"].values
-    et, em, ec = np.zeros(n), np.zeros(n), np.zeros(n)
-    for i in range(n):
-        s = 0.0
-        if c[i] > ef[i] > es[i]: s += 0.4
-        elif c[i] < ef[i] < es[i]: s -= 0.4
-        s += 0.3 * eff[i] + 0.3 * np.tanh(mom[i] * 10) + 0.2 * np.tanh(am[i])
-        et[i] = np.tanh(s * 2.0)
-        s = -0.4 * np.tanh(rd[i] * 3) - 0.4 * np.tanh(dm[i] * 20) - 0.3 * np.tanh(ae[i] * 2)
-        em[i] = np.tanh(s * 2.0)
-        contr = max(0.0, 1.0 - vr[i])
-        ec[i] = np.tanh(bo[i] * (0.5 + 0.5 * contr) * 2.0)
-    raw = rp[:, 0] * et + rp[:, 1] * em + rp[:, 2] * ec
-    acc = np.zeros(n); acc[0] = raw[0]
-    for i in range(1, n): acc[i] = lam * acc[i - 1] + (1 - lam) * raw[i]
-    pl = np.array([_sig(4.0 * x) for x in acc])
-    return acc, pl, 1.0 - pl
-
-
-# ---------- Signal + Backtest ----------
-def latest_signal(f, rp, acc, pl, ps, thr, mconf):
-    i = len(f) - 1
-    if i < MIN_SIG: return None
-    p = rp[i]; dom = int(np.argmax(p)); conf = float(p[dom])
-    if conf < mconf: return None
-    e, l, s = float(acc[i]), float(pl[i]), float(ps[i])
-    sig = "LONG" if e > thr and l > 0.5 else "SHORT" if e < -thr and s > 0.5 else "NO TRADE"
-    return {"signal": sig, "evidence": e, "P_long": l, "P_short": s,
-            "regime_probs": {REGIME_NAMES[j]: float(p[j]) for j in range(HMM_K)},
-            "dominant_regime": REGIME_NAMES[dom], "regime_conf": conf,
-            "close": float(f["close"].values[i])}
-
-
-def backtest(sym, f, rp, acc, pl, ps, thr, mconf, maxhold):
-    n = len(f); c = f["close"].values; h = f["high"].values; lo = f["low"].values
-    atr = f["atr"].values
-    trades = []; in_pos = False; ei = eprice = d = sp = tp = 0
-    reg = ""; rconf = 0.0
-
-    train_end = int(n * TRAIN_FRAC)
-    start = train_end + PURGE + EMBARGO
-    start = max(start, 30)
-    start = min(start, n - 2)
-
-    if start < n:
-        pass_thr = int((np.abs(acc[start:]) > thr).sum())
-        pass_conf = int((rp[start:].max(axis=1) >= mconf).sum())
-        both = int(((np.abs(acc[start:]) > thr) &
-                    (rp[start:].max(axis=1) >= mconf)).sum())
-        print(f"[BT] {sym}: n={n} start={start} window={n-start} "
-              f"thr_pass={pass_thr} conf_pass={pass_conf} both={both}",
-              flush=True)
-
-    for i in range(start, n):
-        if not in_pos:
-            p = rp[i]; dom = int(np.argmax(p)); conf = float(p[dom])
-            if conf < mconf: continue
-            ed = 1 if acc[i] > thr and pl[i] > 0.5 else -1 if acc[i] < -thr and ps[i] > 0.5 else 0
-            if ed == 0 or atr[i] < 1e-12: continue
-            eprice = c[i] * (1.0 + SLIPPAGE * ed); d = ed; ei = i; in_pos = True
-            if d == 1: sp, tp = eprice - 1.5 * atr[i], eprice + 3.0 * atr[i]
-            else:       sp, tp = eprice + 1.5 * atr[i], eprice - 3.0 * atr[i]
-            reg, rconf = REGIME_NAMES[dom], conf
+def get_company_detail(symbol_input: str) -> Tuple[str, Optional[go.Figure]]:
+    """Return detailed markdown report and price chart for a company."""
+    symbol = symbol_input.strip().upper()
+    if not symbol.endswith(".IS"):
+        symbol = symbol + ".IS"
+
+    data = fetch_ticker_data(symbol)
+    if data is None or data.get("price") is None:
+        return f"## {symbol}\n\nNo data available. Check ticker validity.", None
+
+    # Recompute score (need sector medians from current cache)
+    all_cached = []
+    for key in _cache:
+        if key.startswith("ticker_"):
+            _, val = _cache[key]
+            if val is not None:
+                all_cached.append(val)
+    sector_medians = compute_sector_medians(all_cached) if all_cached else {}
+
+    score = compute_composite_score(data, sector_medians)
+    forecast = compute_12m_forecast(data, score)
+
+    # Build markdown report
+    lines = [
+        f"## {data['symbol']} — Company Detail",
+        "",
+        f"**Sector**: {data['sector']} | **Industry**: {data['industry']}",
+        f"**Data timestamp**: {data['data_timestamp']}",
+        "",
+        "### Valuation",
+        "",
+        f"| Metric | Value |",
+        f"|---|---|",
+        f"| Price | {data['price']} |",
+        f"| Market Cap | {data['market_cap']:,} |" if data['market_cap'] else "| Market Cap | N/A |",
+        f"| Trailing P/E | {data['trailing_pe']:.1f} |" if data['trailing_pe'] else "| Trailing P/E | N/A |",
+        f"| P/B | {data['price_to_book']:.2f} |" if data['price_to_book'] else "| P/B | N/A |",
+        f"| EV/EBITDA | {data['ev_to_ebitda']:.1f} |" if data['ev_to_ebitda'] else "| EV/EBITDA | N/A |",
+        f"| FCF Yield | {data['fcf_yield']*100:.1f}% |" if data['fcf_yield'] else "| FCF Yield | N/A |",
+        f"| Graham Number | {data['graham_number']:.2f} |" if data['graham_number'] else "| Graham Number | N/A |",
+        f"| Margin of Safety | {score['margin_of_safety']*100:.1f}% |" if score['margin_of_safety'] else "| Margin of Safety | N/A |",
+        "",
+        "### Quality",
+        "",
+        f"| Metric | Value |",
+        f"|---|---|",
+        f"| ROE | {data['roe']*100:.1f}% |" if data['roe'] else "| ROE | N/A |",
+        f"| ROA | {data['roa']*100:.1f}% |" if data['roa'] else "| ROA | N/A |",
+        f"| Operating Margin | {data['operating_margin']*100:.1f}% |" if data['operating_margin'] else "| Operating Margin | N/A |",
+        f"| Debt/Equity | {data['debt_to_equity']:.1f} |" if data['debt_to_equity'] is not None else "| Debt/Equity | N/A |",
+        f"| Current Ratio | {data['current_ratio']:.2f} |" if data['current_ratio'] else "| Current Ratio | N/A |",
+        f"| Piotroski (partial) | {score['piotroski']}/9 |" if score['piotroski'] is not None else "| Piotroski (partial) | N/A |",
+        "",
+        "### Scores",
+        "",
+        f"- **Composite**: {score['composite_score']:.1f}/100 (confidence: {score['confidence']}%)" if score['composite_score'] else "- **Composite**: N/A",
+        f"- **Valuation**: {score['valuation_score']:.1f}/100" if score['valuation_score'] else "- **Valuation**: N/A",
+        f"- **Quality**: {score['quality_score']:.1f}/100" if score['quality_score'] else "- **Quality**: N/A",
+        "",
+        "### 12-Month Scenarios (heuristic, not calibrated)",
+        "",
+        f"| Scenario | Target | Return |",
+        f"|---|---|---|",
+        f"| Bear | {forecast['bear']} | {(forecast['bear']/data['price']-1)*100:.1f}% |" if forecast['bear'] else "| Bear | N/A | N/A |",
+        f"| Base | {forecast['base']} | {(forecast['base']/data['price']-1)*100:.1f}% |" if forecast['base'] else "| Base | N/A | N/A |",
+        f"| Bull | {forecast['bull']} | {(forecast['bull']/data['price']-1)*100:.1f}% |" if forecast['bull'] else "| Bull | N/A | N/A |",
+        f"| **Probability-weighted** | **{forecast['expected']}** | **{forecast['total_expected_return']*100:.1f}%** |" if forecast['expected'] else "| Expected | N/A | N/A |",
+        "",
+        f"*{forecast['note']}*",
+        "",
+        "---",
+        "*Data source: Yahoo Finance via yfinance. Fundamentals are not point-in-time.*",
+    ]
+
+    markdown = "\n".join(lines)
+
+    # Price chart
+    try:
+        ticker = yf.Ticker(symbol)
+        hist = ticker.history(period="1y")
+        if not hist.empty:
+            fig = go.Figure()
+            fig.add_trace(go.Scatter(
+                x=hist.index, y=hist["Close"],
+                mode="lines", name="Close",
+                line=dict(color="#1f77b4", width=2),
+            ))
+            fig.update_layout(
+                title=f"{symbol} — 1 Year Price",
+                xaxis_title="Date", yaxis_title="Price (TRY)",
+                template="plotly_white", height=400,
+            )
         else:
-            bh = i - ei
-            hs = lo[i] <= sp if d == 1 else h[i] >= sp
-            ht = h[i] >= tp if d == 1 else lo[i] <= tp
-            xp = xr = None
-            if hs and ht: xp, xr = sp, "STOP (both, conservative)"
-            elif hs: xp, xr = sp, "STOP"
-            elif ht: xp, xr = tp, "TARGET"
-            elif bh >= maxhold: xp, xr = c[i], "TIME"
-            if xp is not None:
-                xa = xp * (1.0 - SLIPPAGE * d)
-                gr = (xa - eprice) / eprice if d == 1 else (eprice - xa) / eprice
-                nr = gr - COST
-                trades.append({"symbol": sym, "direction": "LONG" if d == 1 else "SHORT",
-                               "entry_bar": ei, "exit_bar": i, "bars_held": bh,
-                               "entry_price": eprice, "exit_price": xa,
-                               "stop_price": sp, "target_price": tp,
-                               "exit_reason": xr, "gross_return": gr, "net_return": nr,
-                               "regime": reg, "regime_conf": rconf, "win": nr > 0})
-                in_pos = False
-    return trades
-
-
-# ---------- Metrics ----------
-def metrics(trades):
-    if not trades:
-        return dict(total_trades=0, win_rate=0.0, profit_factor=0.0, net_expectancy=0.0,
-                    avg_win=0.0, avg_loss=0.0, max_drawdown=0.0, net_compounded_return=0.0,
-                    long_trades=0, short_trades=0, long_win_rate=0.0, short_win_rate=0.0)
-    r = np.array([t["net_return"] for t in trades])
-    w, l = r[r > 0], r[r <= 0]
-    gp = w.sum() if len(w) else 0.0; gl = abs(l.sum()) if len(l) else 0.0
-    eq = np.cumprod(1 + r); peak = np.maximum.accumulate(eq)
-    dd = (eq - peak) / peak
-    longs = [t for t in trades if t["direction"] == "LONG"]
-    shorts = [t for t in trades if t["direction"] == "SHORT"]
-    lw = sum(1 for t in longs if t["win"]); sw = sum(1 for t in shorts if t["win"])
-    return dict(total_trades=len(r),
-                win_rate=len(w) / len(r), profit_factor=gp / gl if gl > 1e-12 else 999.0,
-                net_expectancy=float(r.mean()), avg_win=float(w.mean()) if len(w) else 0.0,
-                avg_loss=float(l.mean()) if len(l) else 0.0,
-                max_drawdown=float(dd.min()) if len(dd) else 0.0,
-                net_compounded_return=float(eq[-1] - 1) if len(eq) else 0.0,
-                long_trades=len(longs), short_trades=len(shorts),
-                long_win_rate=lw / len(longs) if longs else 0.0,
-                short_win_rate=sw / len(shorts) if shorts else 0.0)
-
-
-def regime_table(trades):
-    if not trades: return pd.DataFrame(columns=["Regime", "Trades", "WinRate", "PF", "NetExp"])
-    rows = []
-    for reg in REGIME_NAMES:
-        rt = [t for t in trades if t["regime"] == reg]
-        if not rt:
-            rows.append({"Regime": reg, "Trades": 0, "WinRate": 0.0, "PF": 0.0, "NetExp": 0.0}); continue
-        n = np.array([t["net_return"] for t in rt])
-        w, l = n[n > 0], n[n <= 0]
-        gp = w.sum() if len(w) else 0.0; gl = abs(l.sum()) if len(l) else 0.0
-        rows.append({"Regime": reg, "Trades": len(rt),
-                     "WinRate": round(len(w) / len(rt), 4),
-                     "PF": round(gp / gl, 4) if gl > 1e-12 else 999.0,
-                     "NetExp": round(float(n.mean()), 6)})
-    return pd.DataFrame(rows)
+            fig = None
+    except Exception:
+        fig = None
+
+    return markdown, fig
+
 
+# ============================================================================
+# DATA QUALITY MONITOR
+# ============================================================================
 
-def coin_table(trades):
-    if not trades: return pd.DataFrame(columns=["Symbol", "Trades", "WinRate", "NetExp", "TotalNet"])
+def data_quality_report() -> pd.DataFrame:
+    """Report data completeness across the universe."""
     rows = []
-    for sym in sorted({t["symbol"] for t in trades}):
-        st = [t for t in trades if t["symbol"] == sym]
-        n = np.array([t["net_return"] for t in st])
-        w = n[n > 0]
-        rows.append({"Symbol": sym, "Trades": len(st),
-                     "WinRate": round(len(w) / len(st), 4),
-                     "NetExp": round(float(n.mean()), 6),
-                     "TotalNet": round(float(n.sum()), 6)})
-    return pd.DataFrame(rows).sort_values("TotalNet", ascending=False)
-
-
-# ---------- Pipeline ----------
-def run(timeframe, n_coins, thr, lam, mconf, maxhold, progress=gr.Progress()):
-    def err(msg, detail=""):
-        return msg, detail, pd.DataFrame(), pd.DataFrame(), pd.DataFrame(), pd.DataFrame()
-
-    n_coins = 30   # sabit — yfinance 30 parite
-    thr = max(0.0, min(1.0, float(thr)))
-    lam = max(0.0, min(0.99, float(lam)))
-    mconf = max(0.0, min(1.0, float(mconf)))
-    maxhold = max(5, min(200, int(maxhold)))
-
-    if timeframe not in YF_TF:
-        return err("ERROR: Invalid timeframe")
-
-    progress(0.02, desc="Resolving yfinance pairs...")
-    try: pairs = fetch_pairs(n_coins)
-    except Exception as e: return err(f"ERROR fetching pairs: {e}")
-    if not pairs:
-        return err("ERROR: No pairs resolved.")
-
-    signals, trades, analyzed, failed = [], [], 0, []
-    for i, sym in enumerate(pairs):
-        progress((i + 1) / len(pairs) * 0.9, desc=f"{sym} ({i+1}/{len(pairs)})")
-        time.sleep(0.25)   # yfinance rate-limit nezaketi
-        df = fetch_klines(sym, timeframe)
-        if df is None:
-            failed.append(sym); continue
-        try:
-            f = features(df)
-            m = fit_hmm(f)
-            if m is None:
-                print(f"[RCEA] {sym}: HMM fit failed (n={len(f)})", flush=True)
-                failed.append(sym); continue
-            rp = forward_filter(m, f)
-            acc, pl, ps = evidence(f, rp, lam)
-            s = latest_signal(f, rp, acc, pl, ps, thr, mconf)
-            if s: s["symbol"] = sym; signals.append(s)
-            sym_trades = backtest(sym, f, rp, acc, pl, ps, thr, mconf, maxhold)
-            trades.extend(sym_trades)
-            print(f"[RCEA] {sym}: candles={len(f)} signal={s['signal'] if s else 'NONE'} "
-                  f"trades={len(sym_trades)}", flush=True)
-            analyzed += 1
-        except Exception as e:
-            print(f"[RCEA] {sym}: EXC {e}", flush=True); failed.append(sym)
-    progress(1.0, desc="Done")
-
-    scan = ["# RCEA Lite — yfinance Market Scan",
-            f"**Timeframe:** {timeframe} | **yfinance interval:** {YF_TF[timeframe][0]}",
-            f"**Coins:** {len(pairs)} (fixed list)",
-            f"**Analyzed:** {analyzed}",
-            f"**Failed:** {len(failed)}",
-            f"**Total trades:** {len(trades)}",
-            f"**Threshold:** {thr} | **λ:** {lam} | **MinConf:** {mconf} | **MaxHold:** {maxhold}",
-            f"**UTC:** {datetime.now(timezone.utc).strftime('%Y-%m-%d %H:%M:%S')}"]
-    if len(trades) < 30:
-        scan.append(f"\n⚠️ Only {len(trades)} trades. Try threshold=0.04, "
-                    f"λ=0.65, MinConf=0.25.")
-    scan_report = "\n".join(scan)
-
-    if signals:
-        sig_df = pd.DataFrame([{
-            "Symbol": s["symbol"], "Signal": s["signal"],
-            "Evidence": round(s["evidence"], 4),
-            "P(Long)": round(s["P_long"], 4), "P(Short)": round(s["P_short"], 4),
-            "Regime": s["dominant_regime"], "Regime Conf": round(s["regime_conf"], 4),
-            "P(Trend)": round(s["regime_probs"]["TREND"], 4),
-            "P(MeanRev)": round(s["regime_probs"]["MEAN_REVERSION"], 4),
-            "P(Compress)": round(s["regime_probs"]["COMPRESSION"], 4),
-            "Close": s["close"]} for s in signals])
-        sig_df["_p"] = sig_df["Signal"].map({"LONG": 0, "SHORT": 0, "NO TRADE": 1})
-        sig_df = sig_df.sort_values(["_p", "Evidence"], ascending=[True, False]).drop(columns="_p")
-    else:
-        sig_df = pd.DataFrame(columns=["Symbol", "Signal", "Evidence", "P(Long)", "P(Short)",
-                                        "Regime", "Regime Conf", "P(Trend)", "P(MeanRev)",
-                                        "P(Compress)", "Close"])
-
-    if trades:
-        tr_df = pd.DataFrame([{
-            "Symbol": t["symbol"], "Direction": t["direction"],
-            "Entry Bar": t["entry_bar"], "Exit Bar": t["exit_bar"],
-            "Bars": t["bars_held"],
-            "Entry": round(t["entry_price"], 6), "Exit": round(t["exit_price"], 6),
-            "Stop": round(t["stop_price"], 6), "Target": round(t["target_price"], 6),
-            "Reason": t["exit_reason"],
-            "Gross": round(t["gross_return"], 6), "Net": round(t["net_return"], 6),
-            "Regime": t["regime"], "Regime Conf": round(t["regime_conf"], 4),
-            "Win": t["win"]} for t in trades]).sort_values(["Symbol", "Entry Bar"])
-    else:
-        tr_df = pd.DataFrame(columns=["Symbol", "Direction", "Entry Bar", "Exit Bar", "Bars",
-                                       "Entry", "Exit", "Stop", "Target", "Reason",
-                                       "Gross", "Net", "Regime", "Regime Conf", "Win"])
-
-    m = metrics(trades)
-    m_str = "\n".join([
-        "# Performance Metrics (net of costs)",
-        f"**Total trades:** {m['total_trades']}",
-        f"**Win rate:** {m['win_rate']:.2%}",
-        f"**Profit factor:** {m['profit_factor']:.3f}",
-        f"**Net expectancy:** {m['net_expectancy']:.6f}",
-        f"**Avg win / loss:** {m['avg_win']:.6f} / {m['avg_loss']:.6f}",
-        f"**Max DD:** {m['max_drawdown']:.2%}",
-        f"**Net compounded:** {m['net_compounded_return']:.2%}",
-        f"**Long:** {m['long_trades']} ({m['long_win_rate']:.2%}) | "
-        f"**Short:** {m['short_trades']} ({m['short_win_rate']:.2%})",
-    ])
-    if m["total_trades"] < 30:
-        m_str += "\n\n⚠️ Insufficient trades for reliable statistics."
-
-    return scan_report, m_str, sig_df, tr_df, regime_table(trades), coin_table(trades)
-
-
-# ---------- UI ----------
-with gr.Blocks(title="RCEA Lite v1.0 — yfinance") as demo:
-    gr.Markdown("# RCEA Lite v1.0 — yfinance Edition\n"
-                "HMM regime detection (causal forward filtering) · No supervised ML · Data: Yahoo Finance")
-    with gr.Row():
-        with gr.Column(scale=1):
-            tf = gr.Dropdown(["15m", "1h", "4h", "1d"], value="1h", label="Timeframe")
-            nc = gr.Number(value=30, label="Coins (fixed 30)", interactive=False)
-            thr_i = gr.Slider(0.0, 1.0, value=0.06, step=0.01, label="Evidence threshold")
-            lam_i = gr.Slider(0.0, 0.99, value=0.70, step=0.01, label="Memory λ")
-            mc_i = gr.Slider(0.0, 1.0, value=0.30, step=0.01, label="Min regime confidence")
-            mh_i = gr.Slider(10, 200, value=72, step=1, label="Max holding (bars)")
-            btn = gr.Button("🚀 Run Scan", variant="primary")
-        with gr.Column(scale=2):
-            scan_out = gr.Markdown(label="Scan Report")
-            met_out = gr.Markdown(label="Metrics")
-    with gr.Tabs():
-        with gr.Tab("📡 Signals"): sig_tbl = gr.Dataframe(interactive=False, wrap=True)
-        with gr.Tab("📜 Trades"): tr_tbl = gr.Dataframe(interactive=False, wrap=True)
-        with gr.Tab("📊 Regime"): reg_tbl = gr.Dataframe(interactive=False)
-        with gr.Tab("🪙 Coins"): coin_tbl = gr.Dataframe(interactive=False)
-    btn.click(run, inputs=[tf, nc, thr_i, lam_i, mc_i, mh_i],
-              outputs=[scan_out, met_out, sig_tbl, tr_tbl, reg_tbl, coin_tbl])
-    gr.Markdown("---\n**Data source:** Yahoo Finance (yfinance). "
-                "Net of 0.10% commission + 0.05% slippage per side.")
+    for sym in BIST_UNIVERSE:
+        data = fetch_ticker_data(sym)
+        if data is None:
+            rows.append({"Symbol": sym.replace(".IS", ""), "Status": "FETCH FAILED",
+                          "Fields Available": 0, "Critical Missing": "ALL"})
+            continue
+
+        critical_fields = ["price", "trailing_pe", "price_to_book", "roe", "fcf_yield"]
+        available = sum(1 for f in critical_fields if data.get(f) is not None)
+        missing = [f for f in critical_fields if data.get(f) is None]
+
+        rows.append({
+            "Symbol": data["symbol"],
+            "Status": "OK" if available >= 3 else "INCOMPLETE",
+            "Fields Available": f"{available}/{len(critical_fields)}",
+            "Critical Missing": ", ".join(missing) if missing else "—",
+            "Sector": data.get("sector", "Unknown"),
+        })
+
+    return pd.DataFrame(rows)
+
 
+# ============================================================================
+# GRADIO UI
+# ============================================================================
+
+def build_ui():
+    with gr.Blocks(title="BIST Value Intelligence", theme=gr.themes.Soft()) as demo:
+        gr.Markdown("""
+# BIST Value Intelligence
+### Conservative Value Screening for Borsa Istanbul
+
+**⚠️ Important limitations:**
+- Data from Yahoo Finance is **not point-in-time**. Do not use for backtesting.
+- Coverage for non-BIST-100 stocks is incomplete. Missing data is shown as `N/A`, never imputed.
+- Scores are **relative rankings within this universe**, not absolute quality measures.
+- The 12-month scenarios are **transparent heuristics**, not statistically calibrated forecasts.
+- This tool is for research and education. Not investment advice.
+        """)
+
+        with gr.Tabs():
+            # Tab 1: Scanner
+            with gr.Tab("📊 Market Scanner"):
+                with gr.Row():
+                    scan_btn = gr.Button("Run Scanner", variant="primary", scale=1)
+                    refresh_cb = gr.Checkbox(label="Force refresh (bypass cache)", value=False, scale=1)
+
+                status_text = gr.Textbox(label="Status", interactive=False, visible=False)
+                scanner_table = gr.Dataframe(
+                    label="BIST Universe Scan Results",
+                    interactive=False,
+                    wrap=True,
+                )
+
+                def do_scan(force):
+                    status_text = gr.update(visible=True, value="Scanning universe...")
+                    df = run_scanner(force_refresh=force)
+                    if df.empty:
+                        return gr.update(value=None), gr.update(visible=True, value="No data retrieved. Check network.")
+                    return df, gr.update(visible=True, value=f"Scanned {len(df)} stocks. Sorted by composite score.")
+
+                scan_btn.click(do_scan, inputs=[refresh_cb], outputs=[scanner_table, status_text])
+
+            # Tab 2: Company Detail
+            with gr.Tab("🔍 Company Analysis"):
+                with gr.Row():
+                    ticker_input = gr.Textbox(label="Ticker (e.g., THYAO, GARAN)", value="THYAO")
+                    detail_btn = gr.Button("Analyze", variant="primary")
+
+                detail_md = gr.Markdown()
+                price_chart = gr.Plot()
+
+                detail_btn.click(
+                    get_company_detail,
+                    inputs=[ticker_input],
+                    outputs=[detail_md, price_chart],
+                )
+
+            # Tab 3: Data Quality
+            with gr.Tab("📋 Data Quality Monitor"):
+                gr.Markdown("""
+Shows which fundamental fields are available for each ticker.
+**Critical fields**: price, trailing_pe, price_to_book, roe, fcf_yield.
+
+If fewer than 3 of 5 are available, the stock's score confidence is severely reduced.
+                """)
+                quality_btn = gr.Button("Check Data Quality", variant="primary")
+                quality_table = gr.Dataframe(label="Field Availability", interactive=False)
+
+                def do_quality():
+                    return data_quality_report()
+
+                quality_btn.click(do_quality, outputs=[quality_table])
+
+            # Tab 4: Methodology
+            with gr.Tab("📐 Methodology"):
+                gr.Markdown("""
+### Scoring Methodology
+
+**Valuation Score (50% weight in composite)**
+- Earnings yield (25%): normalized to 15% = 100
+- P/B vs sector median (25%): lower is better
+- EV/EBITDA vs sector median (25%): lower is better
+- FCF yield (25%): normalized to 8% = 100
+
+**Quality Score (50% weight in composite)**
+- ROE (30%): normalized to 25% = 100
+- Operating margin (25%): normalized to 20% = 100
+- Debt/Equity (25%): lower is better, 150 = 0
+- Current ratio (20%): 2.0 = 100, 0.5 = 0
+
+**Piotroski F-Score (partial)**
+- Computed from available current-period fields only
+- Does NOT include year-over-year changes (historical statements unavailable)
+- Scaled to 9-point maximum based on available components
+- **Labeled "partial" throughout the UI**
+
+**Graham Number**
+- `sqrt(22.5 × EPS × Book Value per Share)`
+- Requires positive EPS and positive BVPS
+- Returns `N/A` otherwise
+
+**12-Month Scenarios**
+- Bear: 20% downside (multiple compression)
+- Base: Earnings-yield-proportional growth, capped at 20%, floored at 3%
+- Bull: Base × 1.8
+- Probability-weighted: 20% bear, 55% base, 25% bull
+
+**Confidence Score**
+- Reflects data completeness
+- Missing critical fields reduce confidence
+- High confidence with missing data is impossible by design
+
+### What This Tool Does NOT Do
+
+- ❌ DCF valuation (requires growth assumptions we cannot validate)
+- ❌ Monte Carlo simulation (requires calibrated return distributions)
+- ❌ Machine learning (requires point-in-time data for training)
+- ❌ Historical backtesting (survivorship and look-ahead bias unavoidable with current data)
+- ❌ Fabricate missing data
+
+### Why the Limitations Exist
+
+Yahoo Finance fundamentals for BIST stocks are:
+1. **Not point-in-time**: the API returns current snapshots, not historical filing data
+2. **Incomplete**: many small/mid-cap stocks lack ROE, FCF, and debt figures
+3. **Inconsistent**: field availability changes without notice
+
+KAP (the official Turkish disclosure platform) is the authoritative source, but programmatic access requires an MKK API key and IP whitelisting. The `kap-mcp` library exists for this purpose [citation:2][citation:12] but cannot be used without institutional credentials.
+
+For a production-grade system, you need either:
+- KAP API access (via MKK)
+- A paid data vendor (Bloomberg, Refinitiv, Matriks, İş Yatırım)
+- BilancoVeri's API (free but needs validation) [citation:11]
+                """)
+
+    return demo
+
+
+# ============================================================================
+# MAIN
+# ============================================================================
 
 if __name__ == "__main__":
+    demo = build_ui()
     demo.launch(server_name="0.0.0.0", server_port=7860)